Configurando o Emacs: primeiros passos

Este post faz parte de uma série de textos sobre LaTeX e sobre a ideia de tratar documentos como código. Ao longo dos anos, acabei montando um workflow para escrever documentos técnicos, artigos, relatórios e apresentações baseado em LaTeX, Emacs, latexmk e Git, e esta série é basicamente uma tentativa de organizar e documentar esse processo.

A ideia não é ensinar LaTeX do zero, mas sim discutir o ambiente de trabalho ao redor dele: editores, compilação automática, organização de projetos, templates e versionamento. Cada post da série aborda uma parte desse sistema.

Introdução

Agora que já passamos pela fase de entender um pouco melhor o LaTeX e a escolha de um editor, é hora de começar a configurar de fato o ambiente a ser usado ao pôr a mão na massa. Como eu expliquei – extensivamente, admito – no post passado, o editor de escolha para isto é o GNU Emacs.

Dito isso, vale deixar uma coisa bem clara desde já: este post — e, na verdade, esta série como um todo — não tem como objetivo servir como guia geral de configuração do Emacs, nem como introdução ao LaTeX. Ao ler este texto, eu realmente recomendo que você já tenha alguma familiaridade com os dois, embora a experiência prévia com LaTeX seja bem mais importante. Experiência com Emacs ajuda, claro, mas não é estritamente necessária, porque vamos montar tudo passo a passo e de forma incremental.

Nosso objetivo aqui é mais específico: construir um ambiente, centrado no Emacs, que funcione como facilitador para escrever documentos em LaTeX. Em vez de apresentar logo de cara uma configuração enorme, monolítica e fechada, a ideia é montar esse ambiente aos poucos, ao longo da série, de forma modular e compreensível. Cada ferramenta — AUCTeX, RefTeX, latexmk, Git e assim por diante — será incorporada conforme passar a fazer sentido dentro do workflow.

Isso é importante por dois motivos. O primeiro é que configurações gigantescas, copiadas de uma vez só, costumam ensinar muito pouco sobre o que está realmente acontecendo. O segundo é que o tipo de ambiente que quero descrever aqui não nasceu pronto: ele foi sendo construído aos poucos, em resposta a problemas concretos que apareciam no dia a dia. Faz mais sentido, portanto, apresentar essa configuração do mesmo jeito que ela foi surgindo: por camadas, cada uma resolvendo um problema específico.

Também vale a pena antecipar uma ideia que vai reaparecer várias vezes ao longo desta série: o ponto não é transformar o Emacs em uma espécie de IDE universal para tudo, nem mostrar um “setup definitivo”. O objetivo é bem mais modesto — e, ao mesmo tempo, mais útil. O que queremos é montar um ambiente estável, previsível e confortável para escrever em LaTeX, compilar documentos, navegar por referências, lidar com bibliografia e integrar isso tudo com o restante do workflow.

Para conseguir isso sem transformar a configuração em um amontoado caótico de opções espalhadas por um único arquivo, vamos adotar uma organização modular. Em vez de concentrar tudo em um init.el gigantesco, a ideia é dividir a configuração em partes menores, cada uma responsável por um aspecto do ambiente. Isso facilita a manutenção, torna o processo mais legível e prepara o terreno para os próximos posts, em que vamos expandir essa base aos poucos.

Neste post, o foco será o primeiro passo dessa construção: transformar o Emacs em um ambiente realmente útil para edição de qualquer arquivo de texto. Vamos ajustar o comportamento dele e também a sua interface de usuário. Assim, já vamos ter um visual pronto para aceitar as configurações específicas que vamos fazer com relação ao LaTeX, que vamos ver no próximo post. Além disso, vamos fazer isso sem ficar introduzindo o básico do básico: o formato da configuração do Emacs é LISP, que tem uma sintaxe que pode parecer meio diferenciada. É bem fácil de entender, uma vez que você pegue o espírito da coisa. Mesmo assim, se houver dificuldade, recomendo uma busca rápida no seu mecanismo de busca preferido e isso vai ficar mais claro.

Fonte e Tema: escolha pessoal, porém não arbitrária

Antes de entrar nas ferramentas específicas para LaTeX, vale a pena ajustar duas coisas básicas no Emacs: a fonte e o tema.

Essas escolhas são, em grande parte, pessoais. Cada pessoa acaba encontrando combinações que funcionam melhor para o próprio fluxo de trabalho, seja por preferência estética, seja por hábito. Nesse sentido, há um paralelo direto com o que discutimos no post anterior: assim como a escolha do editor, a escolha de fonte e tema não tem uma resposta única correta.

Ao mesmo tempo, isso não significa que qualquer escolha funcione igualmente bem.

Diferente de um editor ocasional, o Emacs tende a ser usado por longos períodos de tempo, muitas vezes por horas seguidas, lendo e escrevendo texto continuamente. Nesse contexto, escolhas muito “espalhafatosas” — fontes com desenho incomum, temas com contraste exagerado ou cores muito saturadas — podem até parecer interessantes no começo, mas rapidamente se tornam cansativas ou até inviáveis no uso diário.

Por isso, critérios como legibilidade e conforto de leitura são mais importantes e precisam informar essa decisão. Não vou repassar em detalhes a lógica das escolhas que estou fazendo aqui, mas você é livre para adaptar esta configuração para suas próprias escolhas.

Fonte

A fonte é provavelmente o elemento mais importante da interface. É para ela que passamos a maior parte do tempo olhando. Ela precisa ser agradável, distinta (isto é, caracteres parecidos precisam ser diferentes o suficiente pra não causar confusão) e fácil de ler (para evitar a fadiga, como diria o Jaiminho).

Para escrita em LaTeX, uma boa fonte monoespaçada costuma ser a melhor escolha – como é sempre o caso quando programamos. Isso ajuda a manter alinhamento visual, facilita a leitura de comandos e reduz ambiguidades.

A IBM Plex Mono tem um bom equilíbrio entre legibilidade e densidade de informação, além de ter suporte adequado a caracteres especiais que aparecem com frequência em documentos técnicos. Com mais um bônus: é de fácil acesso (tem até na Debian).

Mais importante do que a fonte específica, no entanto, são alguns critérios (tenha em mente se for escolher outra):

• boa distinção entre caracteres (1, l, I, 0, O, etc.);
• espaçamento confortável;
• ausência de elementos muito estilizados;
• suporte adequado a Unicode.

Tema

A escolha do tema segue a mesma lógica.

No meu caso, uso:

(load-theme 'misterioso t)

Mas, novamente, o ponto não é o tema específico, e sim os critérios por trás da escolha.

Algumas coisas que fazem diferença no longo prazo:

• contraste suficiente para leitura contínua;
• cores discretas, sem saturação excessiva;
• destaque claro para elementos sintáticos (comandos, comentários, strings);
• fundo que não cause fadiga visual.

Temas muito contrastantes ou com cores muito saturadas podem parecer interessantes em um primeiro momento, mas tendem a cansar rapidamente. O mesmo vale para temas muito apagados, com pouco contraste, que dificultam a leitura.

Muito ajuda quem não atrapalha

Essa etapa pode parecer secundária, mas ela define o “pano de fundo” de todo o resto.

A ideia não é encontrar a combinação perfeita de fonte e cores, mas chegar a um ponto em que o ambiente:

• não chama atenção para si mesmo;
• não causa desconforto ao longo do tempo;
• não atrapalha a leitura e a escrita.

Em outras palavras, o melhor setup de fonte e tema é aquele que você praticamente esquece que está usando.

Early init e interface: limpando o terreno

Depois de escolher fonte e tema, precisamos começar com as configurações iniciais do Emacs. Isso garante que ele esteja num estado que já poderia ser usado com eficiência, inclusive para LaTeX, pois oferece um ambiente onde dá para passar bastante tempo sem fadiga, e que não vai atrapalhar o trabalho.

A primeira parte da configuração do Emacs é o early-init.el, que é carregado antes mesmo do init.el. Quando o emacs encontra esse arquivo, ele carrega as opções dele antes de iniciar o sistema de pacotes e a interface de usuário. Isso ajuda justamente neste passo, quando preparando o Emacs antes da interface e do sistema de pacotes serem carregados. Assim, ele já carrega com a aparência que queremos que ele tenha, sem carregar uma e depois mudar para outra, o que gera uma inicialização que pode parecer meio esquisita.

Nesse arquivo colocamos só o básico, até mesmo porque vamos precisar de coisas que são carregadas depois dele, como o sistema de pacotes. No meu caso, ele está assim:

;; Early Init - configurações precoces

(setq package-enable-at-startup nil)                ; desabilita a inicialização do sistema de pacotes
(setq frame-inhibit-implied-resize t)               ; inibe mudança de tamanho da janela
(setq native-comp-async-report-warnings-errors nil) ; inibe mensagens de debug

(menu-bar-mode -1)
(tool-bar-mode -1)
(scroll-bar-mode -1)

Normalmente, o Emacs inicializa o sistema de pacotes antes do init.el. Como vamos fazer isso na nossa própria configuração, vamos desabilitar isso aqui. Isso agiliza a inicialização e previne redundâncias. Pra isso desabilitamos a opção package-enable-at-startup. frame-inhibit-implied-resize impede que a janela do editor seja redimensionada conforme opções são carregadas, o que evita o comportamento “errático”. A opção native-comp-async-report-warnings-errors pode ficar desabilitada enquanto construímos a configuração, pois ela inibe a exibição de mensagens de erro (o que melhora o tempo de carregamento quando a configuração já está estabelecida).

Finalmente, desabilitamos as barras de menu, de ferramentas e de rolagem (vamos ter opções melhores pra cada uma dessas coisas). Essas são as opções menu-bar-mode, tool-bar-mode e scroll-bar-mode. Como vamos basear o nosso uso do emacs em atalhos de teclado, essas barras não vão ser utilizadas e só vão ficar no caminho. Claro, se você acha melhor clicar em botões com o mouse feito um homem das cavernas, fique à vontade para remover esses comandos.

O núcleo da configuração: init.el

Ponto de entrada

Com o básico do básico resolvido, podemos nos voltar então para o centro nervoso da configuração do Emacs: o arquivo init.el. Neste ponto, é relevante lembrar que esse arquivo (e outros arquivos relacionados ao Emacs) mora num diretório especial: o .emacs.d. Esse diretório substituiu o .emacs, que era o arquivo tradicional de configuração do Emacs. Isso facilita um pouco as coisas pois assim fica mais conveniente separar a configuração em vários arquivos, e esse diretório também serve para conter outros arquivos relacionados ao Emacs, como caches de pacotes, arquivos temporários, e assim por diante.

A função deste arquivo é ser o ponto central da configuração, gerindo a inicialização de pacotes, garantindo que o comando use-package vai funcionar, e carregando os módulos da configuração. Assim, evitamos um único arquivo de configuração gigante e difícil de gerenciar, separando cada parte da configuração no seu próprio lugar.

Sistema de pacotes

Começamos com:

(require 'package)

(setq package-archives
      '(("gnu"   . "https://elpa.gnu.org/packages/")
        ("melpa" . "https://melpa.org/packages/")))

(package-initialize)

Sem mistério: inicializamos o sistema de pacotes, adicionamos os repositórios (de onde vamos baixar os pacotes que formos instalando e/ou atualizando), e inicializamos o sistema de pacotes. Normalmente, versões mais recentes do Emacs não precisam que o comando package-initialize seja usado explicitamente, mas como estamos usando um truque no early-init, não custa nada (neste caso) ter certeza que tudo está funcionando.

Em seguida, acertamos o uso do use-package:

(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(eval-when-compile
  (require 'use-package))

(setq use-package-always-ensure t)

Nesta parte, verificamos se a macro use-package está disponível. Se não estiver, instalamos. Em seguida, ele garante que o Emacs conheça a macro use-package no momento certo, sem carregá-la desnecessariamente em tempo de execução. Finalmente, a configuração pede que ele sempre confira se os pacotes sendo carregados já estão instalados. A vantagem de usar o use-package é que podemos já carregar várias configurações dos pacotes que vamos usar junto com os próprios pacotes, além de poder usar essa ferramenta de garantir que o pacote está instalado (e instalar, caso não esteja).

Daí vem a parte seguinte do init.el, que é onde vamos acertar o carregamento dos demais módulos da configuração:

(add-to-list 'load-path (expand-file-name "lisp" user-emacs-directory))

(setq custom-file (expand-file-name "custom.el" user-emacs-directory))
(load custom-file t)

(require 'fmn-ui)
(require 'fmn-editing)
;(require 'fmn-pdf)
;(require 'fmn-latex)
;(require 'fmn-git)

Agora, adicionamos o diretório lisp/ ao caminho do Emacs, para ele saber onde buscar os arquivos adicionais. Depois, falamos para ele usar o arquivo custom.el para salvar customizações. Não vamos colocar nada nesse arquivo, mas ele é importantíssimo. O Emacs tem ferramentas próprias de configuração, e às vezes pode ser conveniente acertar algum detalhe de configuração (ou até toda ela, se for o caso) usando essas ferramentas. Pra poupar todo o trabalho que temos em montar esta configuração em particular, estamos dizendo ao Emacs que as configurações feitas através do comando customize devem ser salvas nesse arquivo.

Desta forma, as configurações que o próprio Emacs for salvando não vão parar dentro do init.el, causando confusão. Além disso, o custom.el não é carregado por último, de forma que as nossas configurações próprias não vão ser sobrescritas por acidente por qualquer coisa que o Emacs faça. Assim podemos testar configurações sem ter medo de acabar perdendo alguma coisa .

Finalmente, carregamos os módulos. Todos eles estão no diretório lisp/, e têm nomes convenientes: uma identificação própria (neste caso, as minhas iniciais), e o tipo de customização que aquele arquivo contém. É nesses arquivos que está, de fato, a lógica do ambiente.

A divisão segue uma ideia simples:

• fmn-ui → aparência e interface (aquelas que não entraram no early init)
• fmn-editing → comportamento de edição
• fmn-pdf → visualização de PDF
• fmn-latex → tudo relacionado ao LaTeX
• fmn-git → integração com versionamento

Por enquanto, os três últimos estão desativados – por isso eles estão comentados ali em cima. Afinal, ainda não passamos por eles. Conforme formos configurando cada aspecto, é só voltar no init.el e descomentar.

Aparência e interface

Para concluir a configuração básica do Emacs, vamos ao arquivo lisp/fmn-ui.el, que fecha a configuração da interface. Vamos começar com algumas opções gerais:

;; --------------------------------------------------
;; Interface geral
;; --------------------------------------------------
(setq inhibit-startup-screen t)
(column-number-mode 1)
(display-time-mode 1)
(setq display-time-24hr-format t)

(load-theme 'misterioso t)
(show-paren-mode 1)

; Janela maximizada
(add-to-list 'default-frame-alist '(fullscreen . maximized))
(add-hook 'window-setup-hook
          (lambda ()
            (set-frame-parameter nil 'fullscreen 'maximized)))

Esse bloco inibe a tela inicial do Emacs (inhibit-startup-screen), adiciona o número da coluna e a hora do dia à linha de status (column-number-mode e display-time-mode). Em seguida, carregamos o tema misterioso, que carrega uma paleta de cores (texto, fundo, palavras selecionadas para cada linguagem, comentário, etc). Uma opção especial é show-paren-mode, que destaca pares de delimitadores, o que facilita a correspondência entre abertura e fechamento.

As duas opções no final fazem com que a janela do Emacs fique maximizada por padrão. São duas estratégias para isso porque o jeito de fazer isso depende de qual backend gráfico está em uso (isto é, depende do seu ambiente gráfico).

Em seguida, temos a configuração da fonte e outras opções de exibição do texto:

(add-to-list 'default-frame-alist '(font . "IBM Plex Mono-11"))

(set-face-attribute 'default nil
                    :font "IBM Plex Mono"
                    :height 110)

(set-face-attribute 'fixed-pitch nil
                    :font "IBM Plex Mono"
                    :height 110)

;; Zoom rápido de texto
(global-set-key (kbd "C-=") #'text-scale-increase)
(global-set-key (kbd "C--") #'text-scale-decrease)
(global-set-key (kbd "C-0") (lambda () (interactive) (text-scale-set 0)))

;; Números de linha
(global-display-line-numbers-mode 1)
(setq display-line-numbers-type 'relative)
(setq display-line-numbers-current-absolute t)

;; Linha atual sem apagar a colorização de sintaxe
(global-hl-line-mode 1)
(set-face-attribute 'hl-line nil
                    :inherit nil
                    :background "#444455"
                    :foreground 'unspecified
                    :underline nil
                    :box nil)

Definimos a IBM Plex Mono como fonte para a interface, fonte padrão e fonte de espaço fixo. Ou seja, tudo vai ficar na mesma fonte; dá pra customizar isso de outras formas, mas pra mim a consistência de fontes é importante. Em seguida, configuramos atalhos para ajuste rápido do tamanho do texto: 'Ctrl =' aumenta o tamanho da fonte, 'Ctrl -' diminui. 'Ctrl 0', por sua vez, retorna a fonte ao seu tamanho original (que, neste caso, é 11).

Em seguida, vamos acertar as linhas de texto. Esta configuração mostra o número da linha onde o cursor está. Para as demais linhas, ela mostra a distância a partir do cursor. Por exemplo, o texto que estiver 5 linhas acima do cursor vai ter um “5” à esquerda. Isso ajuda a visualizar o tamanho do texto. Além disso, a linha do cursor ganha uma cor de fundo diferenciada, para ficar fácil de encontrar.

Transparência

Às vezes, podemos querer um visual diferenciado para o texto. Em outras ocasiões, podemos estar consultando algo online e querer um jeito fácil de copiar as coisas de um lugar para o outro, mas sem apelar para copiar e colar as coisas – não importa o motivo. Sem falar que visualmente é legal ter um fundo translúcido! Então, vamos acertar isso na configuração:

(defun fmn/toggle-transparency ()
  "Toggle frame transparency between two useful presets."
  (interactive)
  (let ((alpha (frame-parameter nil 'alpha)))
    (set-frame-parameter
     nil 'alpha
     (if (eql (cond ((numberp alpha) alpha)
                    ((numberp (cdr alpha)) (cdr alpha))
                    ((numberp (cadr alpha)) (cadr alpha)))
              100)
         '(85 . 50)
       '(100 . 100)))))

(defun fmn/transparency (value)
  "Set frame transparency. 0=transparent, 100=opaque."
  (interactive "nTransparency Value 0 - 100 opaque: ")
  (set-frame-parameter (selected-frame) 'alpha value))

(global-set-key (kbd "C-c C-t") #'fmn/toggle-transparency)
(global-set-key (kbd "C-c t")   #'fmn/transparency)

Nesta parte do código, fazemos três coisas:

1. Definimos a função “fmn/toggle-transparency“, que alterna entre janela com transparência e janela sem transparência. Assim podemos escolher quando queremos que a janela tenha transparência ou desativar isso completamente.
2. Definimos a função “fmn/transparency“, que altera o valor da transparência em termos porcentuais: 0% é totalmente transparente e 100% é totalmente opaco.
3. Finalmente, definimos os atalhos de teclado:'Ctrl c + Ctrl t' alterna entre transparente e opaco, e 'Ctrl c + t' pede para o usuário dizer qual o valor de transparência desejado.

Benchmarking

Por último, vamos implementar um benchmarking, para ver quanto tempo o Emacs leva para carregar a nossa configuração.

(add-hook 'emacs-startup-hook
          (lambda ()
            (message "Emacs carregado em %s com %d GC(s)"
                     (format "%.4f segundos"
                             (float-time
                              (time-subtract after-init-time before-init-time)))
                     gcs-done)))

Aqui, definimos um “gancho”: durante a inicialização, ele cronometra o tempo necessário, e mostra uma mensagem quando está tudo pronto. Essa mensagem aparece abaixo da linha de status, na área onde os comandos são digitados.

Conclusão

Para concluir, colocamos no final:

(provide 'fmn-ui)

Esse comando informa o emacs que este arquivo provê o módulo fmn-ui, que é chamado de dentro do init.el.

Comportamento de edição

Para completar a configuração inicial do Emacs, vamos entrar no lisp/fmn-editing.el, que controla o comportamento do editor durante o processo de edição. Ele está abaixo:

(setq make-backup-files nil)
(setq auto-save-default nil)

(use-package company
  :hook (after-init . global-company-mode))

(provide 'fmn-editing)

Não é muita coisa, mas caso apareça mais algum comportamento de edição ou algo relacionado, é nesse arquivo que vamos adicionar a configuração. Começamos desabilitando o salvamento de arquivos de backup, bem como o auto-save. Pode parecer uma decisão perigosa, mas estamos montando um ambiente de trabalho que usa o Git para controle de versão. Por isso, caso aconteça alguma coisa, podemos sempre recuperar o trabalho usando os mecanismos do próprio Git. Por isso, desabilitamos essas opções para manter o diretório limpo. Dependendo da situação, é possível reabilitar essas opções.

Além disso, ativamos o mecanismo de autocompletar, usando company-mode. Estamos fazendo essa ativação de forma global, porque ele funciona com vários modos, além do LaTeX. Assim, se formos criar uma configuração para trabalhar com outra linguagem, por exemplo, essa opção já vai estar ativa. No caso do LaTeX, ele vai nos dar opções para facilitar o uso de comandos, ambientes, labels, referências, citações e nomes de arquivos. Isso vai entrar na configuração específica, mas essa ativação acontece aqui pois ela pode se aplicar a outros modos.

Por último, como no módulo anterior, avisamos ao Emacs que este arquivo fornece o fmn-editing.

Conclusão

Com isso, concluímos a configuração prévia do Emacs. Agora, ele está com a aparência e o comportamento certos. Neste ponto, ele já pode inclusive ser utilizado para escrever LaTeX, caso seja o caso. Só com isso ele já é capaz de oferecer um ambiente agradável e útil para editar qualquer arquivo de texto, oferecendo informações úteis não importa o que seja que estivermos escrevendo. Neste ponto, o que temos ainda não é um ambiente de escrita específico para LaTeX — pelo menos não no sentido completo. Não falamos de AUCTeX, nem de RefTeX, nem de compilação, nem de bibliografia.

Começamos ajustando o comportamento inicial do Emacs com o early-init.el, depois organizamos a configuração com um init.el enxuto, e por fim definimos uma camada de interface no lisp/fmn-ui.el e no lisp/fmn-editing.el. Separar responsabilidades, evitar arquivos monolíticos e manter o controle explícito da configuração são decisões que parecem pequenas agora, mas fazem uma diferença enorme conforme o sistema cresce. Note que, nesses módulos customizados, estou sempre usando o prefixo “fmn-“, assim posso ficar à vontade para nomear módulos e funções sem correr o risco de encontrar algum conflito, caso o nome escolhido já esteja sendo usado no próprio Emacs.

Mais importante do que qualquer opção específica que apareceu aqui é a lógica por trás delas. Em vez de acumular configurações, a ideia é estruturar o ambiente de forma que ele seja compreensível, previsível e fácil de evoluir. Com isso, o Emacs deixa de ser apenas um editor genérico e passa a ser um ambiente de trabalho em construção.

No próximo passo, vamos finalmente começar a transformar esse ambiente em algo voltado para LaTeX de fato. Isso significa adicionar as ferramentas que permitem estruturar documentos, lidar com referências e integrar o processo de escrita com o restante do workflow.

Em outras palavras: no próximo post, o Emacs começa a entender LaTeX.