Emacs es un editor credo por el gigachad Richard Stallman por allá en 1984, es un software totalmente libre, esta presente en todas las principales plataformas (Windows, MacOS, GNU/Linux), y se caracteriza por ser también un interprete de ELisp (Emacs Lisp) que es basicamente un lenguage de programación derivado de la familia de Lisp, esto lo hace totalmente "hackeable" para cualquiera que quiera abrirse a editar sus configuraciones, ese alto nivel de customización ha logrado que haya una comunidad que este desarrollando librerías bastante convenientes para Emacs

Hay varias cosas enormemente destacables sobre Emacs, pero tal vez una de las cosas que la comunidad más se enorgullece, es que puedes usarlo para un montón de cosas: escribir notas, programar, organizar una agenda, administrar proyectos, leer libros, escuchar música, leer las noticias a través de un RSS, chatear en IRC, jugar Tetris, etc. Todo esto bajo el techo que la iglesia de Emacs puede proveer. Es por esto que algunos tienden a asociar a Emacs como un sistema operativo

Por alguna razón las comunidades de programadores les gusta comparar estos editores, aunque a mi parecer hay demasiadas diferencias, que uno puede preguntarse si los casos de uso son completamente los mismos, la comparación entre vim e Emacs es como el buen cuchillo y la cocina, en ese sentido mis razones para probar Emacs:

1. Lisp: Desde hace un tiempo tenía un interés en aprender algún lenguage de la familia de Lisp, es un lenguage imperativo/funcional, altamente flexible, de hecho Scheme otro de los lenguajes Lisperos. era usado como introducción a CS en el MIT, y uno de los libros más cabezones fueron usados como base de enseñanza, Structure and Interpretation of Computer Programs alias SICP, ha sido altamente influyente para este tema. Entonces ciertamente vale la pena darle una vuelta. Un código en Elisp se ve algo como esto:

(setq eshell-prompt-function
  (lambda nil
    (concat
     (eshell/pwd)
     " $ ")))

como puedes notar los paréntesis son una parte previo a la definición de la función y al final, lo hace un tipo de lenguage de programación bastante peculiar en estos tiempos. No es lo único especial de este tipo de lenguajes y hay muchas opiniones al respecto, pero si estás acostumbrado a los lenguajes tipo Python, C o Java, entonces Lisp te va a proveer otro tipo de paradigmas que podrás contrastar.

2. Ambiente productivo: Usualmente cuando quieres hacer un ambiente productivo en vim, tienes que usar Tmux como multiplexer, y luego concatenar otros programass basados en termimnales, usarás Newsboat para noticias, Ncmpcpp + Mpd para música, Mutt para correos electrónicos, Zathura para leer PDFs, etc. No es un mal workflow, pero tiene sus limitaciones, por ejemplo, si quieres leer blogs que tienen imagenes, Newsboat estará limitado, también tendrás que setear los shortcuts para estos programas para que sean afines a Vim, o los colores de cada software en caso de que te importe lo estético, siento que en general es más simple de abordar esto en Emacs.
3. Org Mode: Probablemente si hay alguien que me pregunte si vale la pena usar Emacs a pesar de que no programe, probablemente le diré que si, solo por una cosa: Org Mode. Creo que todos independientes del tipo de trabajo o estudio que hacemos, tenemos algunas necesidades de tomar notas, agendar eventos, administrar proyectos con tareas y deadlines, entre otros. Todo eso lo puedes hacer en Emacs con Org Mode, la herramienta es altamente customimizable y es parte integra del ecosistema de Emacs, y creo que no hay ningún usuario de Emacs que no quiera aprovechar los beneficios de este ecosistema.

Por sobre todo Emacs es un gran software, este artículo lo he estado escribiendo en Emacs, además de otras cosas, y ha sido divertido por sobre todo, pero algunas cosas que vas a tener que considerar para empezar:

1. Poco estético al inicio: Si instalas Emacs y vas desde el principio, verás una introducción con el logo bastante feo, además de unos links a tutoriales, etc. No lo encontrarás atractivo para nada, dependerá de ti, ir customizandolo para que quede un poco más agradable visualmente
2. Nuevos atajos de teclado que aprender: Si vienes de vim, probablemente ya estas acostumbrado al sistema modal de edición, esa memoria muscular tendrá que enfrentar un nuevo sistema de edición y navegación que no tiene mucha relación con Vi, verás que tendrás que usar la tecla Ctrl y Alt para llamar a distintos modos y ejecutar comandos acordes, puede que cueste al principio, pero también tiene sus fortalezas. Además existe una librería para emular los atajos de teclado de vim, llamado evil mode, lo cual puede ayudar a que inicies en Emacs, aunque yo no lo recomiendo, en mi opinión vale la pena que empieces con los atajos originales hasta que logres tener un entendimiento de ellos, y después puedes decidir usar evil mode.
3. Tiempo mayor en start ups: vim es rápido, Emacs en esencia se toma unos segundos dependiendo de la cantidad de plugins y otras customizaciones que le hayas hecho, lo cual no lo es tanto, pero por lo mismo, preferirás tener una sesión abierta todo el tiemmpo antes que estar abriendo y cerrandolo constantemente, no es algo tan grave en mi opinión, pero puede que haya gente que no le agrade mucho.

Estas distribuciones de Emacs son basicamente Emacs con ciertas opiniones de plugins y shortcuts ya establecidos, no tengo experiencia con esas distribuciones, pero tampoco lo recomiendo mucho, a mi parecer es mejor de que vayas creando tu propio config desde 0 y lo vayas adaptando poco a poco a lo que realmente necesitas, eso también te hará más consciente de lo que hace tu sistema.

Te recomiendo instalar la distribución básica de Emacs, luego:

• Lee el tutorial unas cuantas veces y acostumbrate a usar esos atajos de teclado, por unos cuantos días.
• También puedes leer el manual que hizo GNU para Emacs, que tiene un cierto material que complementa al tutorial.
• Aprender a navegar dentro de tu directorio con dired, abrir archivos, editarlos y guardarlos.
• Entender y quedar cómodo con lo de abrir y cerrar ventanas, operar con los buffers
• Explorar otras funcionalidades construídas internamente en Emacs como navegar en la web con eww, navegar pdfs, etc.
• Comienza a editar tu archivo init.el para agregar nuevas customizaciones a tu Emacs, como por ejemplo el tamaño de la letra, esquema de colores, etc
• Explora Org Mode
• Sigue disfrutando.

La verdad es que puede que mi experiencia con Vim y Neovim me hayan dado cierta experiencia de como usar Emacs, eso no quiere decir que no he quedado a veces estancado con algún asunto, pero dentro de todo el proceso ha sido entrete y la verdad me llevado una grata experiencia usando este software. Desde que empecé con el tutorial hasta ahora me ha tomado una semana y media mas o menos de jugar en mi tiempo libre, así que demás que cualquiera puede usarlo con cierta proficiencia en un par de semanas a un mes probablemente.

It has been a while since I decided to purge several of my social networks (including Twitter, Facebook, Instagram, and LinkedIn) and mainly stick to Mastodon as the only platform for interacting with people on the internet whom I don't really know. So far, it has been a positive experience, and I have no doubts that it has improved my quality of life. Furthermore, it has opened up a world that I wasn't very aware of and that I have become increasingly interested in: The world of Free software.

My first real interactions with the world of open source (which was the term I was familiar with) were through my work as a data analyst at one of the companies I worked for. I used Python for most of my analyses because I felt I could do more than the average business analyst with Excel. For the first time, I got involved with the term open source, and I was amazed that there were people who donated some of their time to create projects to share with others (of course, this is a generalization, understanding that there are also various types of organizations). Even more so, someone like me could use these libraries and benefit greatly from them in advancing my projects for which I was paid.

I believe that this is where I began to realize the power of community work and how these projects were not necessarily something artisanal that easily broke. On the contrary, many of these projects are quite solid and provide a great platform for anyone with basic programming skills to use and derive significant value from.

To be honest, this breakup started with social media, which I was an avid user of at the time, and for some reason, I felt quite tired of them. However, I still wasted my time on them. Twitter, in particular, had me fed up because of the level of aggression and toxicity on the platform. When I wanted to read about a topic related to my country, I ended up feeling annoyed by how the interactions were happening (which was similar to the discussions among family members with different political views at the annual family dinner). This reached a breaking point when Elon Musk took over Twitter. Why? Because I never believed in his idea of free speech and his intentions to make Twitter a "better place." Time has shown us that EM has never been a man of science, and his altruistic purposes are nothing but a nebula of contradictions.

The best thing you can do is make a gradual transition. Some of this software is not so simple to use. If you've never programmed in your life and have never opened your computer's terminal to perform any operations, some of this software may seem more complicated than it really is. So, I recommend starting with things that are super simple to change, like your browser. If you're using something like Bing or Google Chrome, download Firefox. Create an account on Mastodon and join an instance that interests you. See if you like it more than Twitter, and then delete your Twitter account. I assure you that if you don't like Elon Musk, no matter how much you complain on his platform, nothing will change. Install the DuckDuck Go extension and avoid opening Google.com for your searches. Okay, but what next? If you're a business analyst, I recommend considering learning one of the alternatives to Excel. You'll realize that you can do much more than with Excel (and in 6 months, you might negotiate a better salary or a job change with better benefits). Besides, I think this will be the gateway to other skills. But above all, it's worth the idea of learning new things and stepping out of your comfort zone, as it will allow you to be a little more free and independent from third parties. For example, I created this blog on my own with some open-source tools and by browsing the source code. What I mean is, can someone come and delete my posts or block me without consulting me? The answer is simply no.

Of course, this is not so difficult, and you don't need to be a software engineer to do many of these things; in fact, I'm not. As an extra anecdote, a friend of mine also decided to buy a Raspberry Pi and has learned a lot about self-hosting and networking, which allows him to create websites and not rely on third parties to host his blogs and other sites he creates. I think I'll do the same in the future.

The most important and highlighted impact is the feeling of tranquility and less stress. After purging social networks (Twitter, Facebook, Instagram, and LinkedIn), I'm simply much less attached to my phone, and I receive less stress from information overload. It's basically one less addiction in my life, and it's difficult to control. If you're the person who's glued to your phone, it's not your fault, but it's these platforms that turn their product into a drug to keep you there for as long as possible. In fact, checking the statistics of my Instagram account, I spent around 1 to 2 hours a day there. Doing what? Nothing relevant, if you ask me. So, I won't deny that my life has improved.

On the other hand, I've learned different things about computers that I had no idea about before, and I've become better at it. Just by knowing certain tools, I became more proficient at work, so I could automate things that other colleagues simply didn't know how to do. I automated tasks with Bash scripting, created pipelines with Python to manipulate data, and learned a bit more about statistics since I now had libraries available, among other things.

Lastly, I've learned more about the value of personal information and independence. Many of the proprietary software we use have some form of telemetry or seek to gather all kinds of information about you. I understand that people don't place much value on their personal information, but I think it's something we shouldn't so easily give away. After all, companies make money directly or indirectly from your information, and it's a shame that schools and the education system, which are supposed to be guardians of forming free and independent individuals capable of thinking for themselves, do not emphasize these topics and promote dependence on proprietary software without even mentioning these alternatives. For example, when Windows forces you to accept new updates or changes to the license (which few probably read), you can realize that you're not really free to choose. And if your PC becomes slow because software updates are denser than any hardware can handle, then consider installing Linux and saving that PC.

The truth is the only negative impact I can mention is that by not using social networks, I'm not "up to date" with what acquaintances and colleagues are doing. I don't know if they changed jobs or what they did yesterday, which was something Instagram, for example, was good at. Is it really important? Not at all. In fact, I think we tend to overvalue the idea that knowing in real-time what's happening with 300 people (or more) is important. I have a group of friends with whom I still talk from time to time, and I can really know what they're doing, and that's enough for me. If there are people who matter to you, ask them for their email or some other means of contact where you can chat from time to time.

This has been my experience primarily delving into the world of open-source software and reducing the consumption of social networks. These are two different things but are closely related. To summarize in a few points:

1. Try to eliminate social networks, especially those supported by recommendation systems to keep you hooked.
2. Consider and value the idea of using open-source software. If you're using proprietary software, evaluate if there's an alternative that upholds the fundamental principles of open-source software or at least follows minimum values of security and privacy.
3. Learn more about open-source software, and if there's software you use regularly that helps you in your daily life, look for ways to support it.
4. Don't be afraid to learn more. I believe the idea of "I don't know about computers," "I'm not a programmer," among others, is a poor argument for self-limitation. Take the time to learn gradually about these topics.

I hope this has been helpful, and if you have any questions, you can write to my email or find me on Mastodon.

Para ir directo al grano el método tiene un proposito, que es construír una compleja red de conocimiento personal y que este sea facil de administrar. Esta red se basa en "nodos" de conocimiento que sean lo más atómicos posibles y construir "links" entre estos nodos para cohesionar el contenido de tal forma que puedas ir enlazandolo en la red, estos nodos contendrán una metadata referenciando tópicos, fechas, títulos, links, etc. Con esto el conocimiento es capturado, puede ser conectado, cohesionado y administrado.

El método puede ser creado (notas, carpetas, post-it, etc ), como también usado con herramientas digitales, existe un montón de software ahí afuera que trata de cubrir estas propiedades como Obsidian, Forester, Mem, Denote, etc. Antes de que trates de usar algunos de estos softwares, pensemos un poco en cual es el ejercicio que tú harías en tu laptop si quisieras usar esta metodología.

Imagina que estás estudiando inglés en tu día a día y te gustaría trackear tu conocimiento sobre el lenguaje, y la forma en que quieres tomar notas en una carpeta llamada Zettelkasten donde estas creando distintos archivos, principalmente en .txt (aunque podría ser cualquier tipo de archivo). Hoy aprendiste una nueva regla gramatical, y quieres guardar ese conocimiento, entonces harás algo como lo siguiente:

1. Ir a la carpeta Zettelkasten, y crear un archivo .txt con la estructura Fecha--Titulo__Tag.txt, imaginemos que lo llamas 20250130t105229--uso-de-la-palabra-more-y-less__ingles_gramatica.txt
2. Escribirás como leíste en el título a lo mejos escribirás una breve definición y ejemplos sobre estas palabras como:

- more significa más y less significa menos
  ejemplo: I love dogs more than cats.
  I feel like I have less time these days

3. Luego guarda ese archivo, y continua con tu día.

Hasta acá hay algunas cosas especiales, como puedes ver el archivo creado es un nodo de conocimiento y su título contiene metadata (fecha, nombre, tópicos), y su contenido por supuesto hasta ahora puede que sea una simple toma de notas, pero en la medida de que vas incorporando nuevo conocimiento, puedes construir relaciones y agregar nuevas capas de conocimiento. Imaginemos que aprendiste algo nuevo en inglés, y tomas notas sobre esto:

4. Crear un archivo 20250211t221209--regla-consecuencia-the-more-the-more__ingles_gramatica.txt
5. Escribes sobre la regla the more.. the more

Cuando quieres usar un efecto que se produce cuando algo cambia puedes
usar la regla the more... the more

ej: - the more you study, the more you know
- the less time I have, the more productive I am

Importante saber las reglas gramaticales more o less para usar esta regla,
revisar 20250130t105229--uso-de-la-palabra-more-y-less__ingles_gramatica.txt

6. Guardar el archivo y seguir con tu vida.

Como puedes ver aquí volví a crear un archivo y esta vez linkié este conocimiento con otro nodo. Así que con esto podemos ir creando una carpeta de conocimientos y la metadata nos ayuda a preservar clasificaciones, por lo que si quisieras también estudiar alemán por ejemplo, puedes aprovechar esto para conectar conocimiento, tal vez se te ocurra crear un nodo (.txt) para comparar gramática en ingles y aleman, o tal vez estas también estudiando economía, y quieres crear una tarjeta que incluya terminos económicos en inglés, por lo que usaras tags como "economía" e "inglés", por ejemplo.

Es bastante simple, y no requieres ser un ingeniero de la Nasa para construir algo como esto, puedes además facilmente buscar y filtrar archivos a través de cualquier search, organizarlo y depurar el conocimiento en la medida que accedes a él. Aquí coloqué ejemplos usando .txt, pero podría ser lo que sea: archivos, imágenes, .pdf, videos, etc. Así mismo puedes agregar links a la web, entre otras cosas.

Probablemente lo más tedioso en usar este método es como automatizar el proceso de creación, guardado y linkeo de estos nodos, y de ahí que los softwares pueden facilitar bastante este proceso.

El flujo de trabajo anterior es una explicación práctica (y opinable) de como he estado usando Denote para el método Zettelkasten, obviamente Denote me ayuda en la automatización de este proceso. Cabe notar de que otra alternativa bastante popular a Denote es OrgRoam, dado que era más popular me interesaba más, pero la idea de setear una base de datos para poder trabajar con archivos, si bien práctica considero que le agrega una capa de complejidad innecesaria. Por lo que decidí testear Denote primero y terminó siendo más que aceptable.

En mi init.el agregué lo siguiente:

;; Denote to taking notes or the Second Brain
(use-package denote
  :ensure t
  :custom
  (denote-directory "~/Denotes")
  (denote-rename-confirmations '(rewrite-front-matter))
  (denote-save-buffers t)
  :config
  (add-hook 'text-mode-hook #'denote-fontify-links-mode-maybe))

;; Integration Denote with Org capture

(with-eval-after-load 'org-capture
  (add-to-list 'org-capture-templates
               '("n" "New (De)note" plain
                 (file denote-last-path)
                 #'denote-org-capture
                 :no-save t
                 :immediate-finish nil
                 :kill-buffer t
                 :jump-to-captured t)))

No hay mucho que agregar acá más que la instalación de la librería y asegurarme de que en cualquier momento que precione C-c c pueda abrir org capture y seleccionar Denote como opción, se abre un prompt para agregar el título y tags. Y de inmediato se abre un archivo .org con la metadata lista, y puedo tranquilamente escribir lo que requiera, luego salvar el archivo con C-c C-c, y volver a lo que estaba haciendo previamente. También puedo linkear notas para empezar a relacionar conceptos dentro de la red de notas, y así esta se va ir desarrollando organicamente.

Quiero recalcar que Denote es una herramienta con mayor complejidad, tiene bastantes funcionalidades, pero mi uso es relativamente sencillo, por lo que no he sentido la necesidad de experimentar con todo lo que puede ofrecer esta herramienta.

En estas semanas experimentando con el método Zettelkasten he visto varias cosas interesantes, el primero es que la idea de tomar breves periodos de estudios del tópico que te interesa, se hace más sencillo de desarrollar organicamente con un sistema de toma de notas instantaneas que vas depositando en un repositorio, esto es ideal cuando te encuentras en el proceso de que aprendes algo mientras vas de paso. Pero algunos desafíos que tienes que considerar:

1. Zettelkasten debiera ser un espacio para escribir notas depuradas de lo que has aprendido, no algo como un copy paste de una definición de Wikipedia.
2. Es positivo revisar estas notas constantemente, porque te permite retroalimentarte de ese conocimiento y depurarlo mientras desarrollas nuevas ideas.
3. Esto no es algo para escribir números de telefonos o lista de supermercado
4. La parte más importante es sobre la producción de ideas y la conexión de estas para la producción de nuevo conocimiento
5. La automatización ayuda bastante para que la producción de la red sea más llevadera, esto te permite capturar ideas y conocimientos de forma instantanea.

• https://github.com/protesilaos/denote
• https://protesilaos.com/emacs/denote
• https://www.goodnotes.com/blog/zettelkasten-method
• https://www.alexkehayias.com/essays/zettelkasten-setup/

It is said that there are two paradigms within the world of window managers: Stacking and Tiling. If you use Windows or MacOS, you may be familiar with the former, where basically the windows you operate for each running software can be overlapped, while the latter works on the avoidance of this (although it can be done) to take advantage of the space used by each program.

Despite this, the popularity of tiling window managers is mainly due to a niche, primarily the Linux community. You can check out the famous Reddit r/unixporn where people customize their operating systems to make them aesthetically and operationally tailored to their users. It's worth noting that this is not exclusively a characteristic of tiling window managers, but they do have a strong representation in that environment.

Finally, the reason why twms are interesting as software is that they are lightweight, highly customizable, and through the use of shortcuts, they can allow your workflow to be more efficient if you learn to use them.

When installing Asahi Linux on MacOS, I decided to install GNOME, which is a stacking window manager, and I was working normally within that ecosystem. Typically, this environment is quite user-friendly, with LibreOffice installed, Firefox, file management, etc.

Within this environment, I decided to install a tiling window manager (twm). Initially, I wanted to install i3, which is a very popular tiling window manager with more documentation and tutorials available. However, despite my attempts to install it, I ended up failing. This was probably because GNOME was mainly working in Wayland, which is a protocol server that the Asahi Linux ecosystem was based on, while i3 is based on the X11 protocol. For this reason, I had to switch to Sway, which is a twm based on Wayland. To install it, you simply open the terminal and type:

sudo dnf install sway

After entering that command in the terminal, you will install the window manager. Then, you close the session or reboot your system. When you need to log in again, go to the bottom right section and select Sway from the list of window managers to start the new environment. You should notice that the screen has nothing but a new wallpaper and a top bar. From there onwards, you'll need to go to your configuration file located at ~/.config/sway/config and add some configurations if needed. I personally made a few changes, for example:

1. Adding layouts to switch between Spanish, English, and Japanese:

input type:keyboard {
    xkb_layout latam,us,jp
    xkb_options grp:alt_shift_toggle
}

2. Tab style, where I remove borders, add gaps, and use a color adjusted to the gruvbox format for focused windows:

gaps inner 10
gaps outer 10

client.focused "#98971A" "#98971A" "#ffffff" "#98971A"
font pango:monospace 0
titlebar_padding 1
titlebar_border_thickness 0

3. Set Audio and brightness shortcuts

#Set audio 
# Increase volume
bindsym $mod+F12 exec pactl set-sink-volume @DEFAULT_SINK@ +5%

# Decrease volume
bindsym $mod+F11 exec pactl set-sink-volume @DEFAULT_SINK@ -5%

# Mute/unmute
bindsym $mod+F10 exec pactl set-sink-mute @DEFAULT_SINK@ toggle

#Set Brightness
# F9 - Decrease brightness
bindsym $mod+F9 exec brightnessctl s 5%+

# F8 - Increase brightness
bindsym $mod+F8 exec brightnessctl s +5%-

This is generally some of the changes I made, trying to adjust it to my workflow, and it's been going quite well, to be honest.

One of the strengths (and challenges) of working in a twm is that you quickly feel encouraged to use more shortcuts after realizing that you can open the terminal, the browser, send windows to other workspaces, and move between those workspaces. If you're using the Vimium extension in your browser and also use Vim for text editing, you may resonate with this way of working as it's quite consistent.

I get the impression that twms strongly encourage working in the terminal, so you may consider installing other software to work harmoniously in this environment. Some of the software I've been incorporating into this environment:

• (Neo)Vim: Text editor
• Tmux: Terminal multiplexer
• Newsboat: An RSS reader
• Alacritty: Terminal
• Zsh: Unix shell
• Cmus: Music player
• Ranger: File manager
• htop: For system monitoring
• waybar: A highly customizable bar for Sway
• dmenu: Application launcher

You can visit my .dotfiles

Short and obvious answer: it depends. If you're someone willing to invest the time to understand and configure your system, I'm sure it can accelerate your workflow process, and you might even enjoy working in this mode. I personally have enjoyed it, especially the way you can simply fly between different workspaces, making the experience incredibly satisfying. However, I've also had some annoying moments. For example, when you want to connect your devices via Bluetooth, you'll have to do it in the terminal, although you can open the settings within Sway if you're using GNOME or KDE Plasma, but otherwise you'll have to figure out how to do it in the terminal. Similarly, if you want to connect to Wi-Fi or take a screenshot, these small things that are so simple in general in other systems with a GUI can be a bit annoying to perform in the terminal or try to build your own shortcut in a config file. So, things that you had very well resolved before, you now have to rethink.

Likewise, if you're not someone who is really interested in delving into config files and prefers just navigating with your mouse within a GUI, then simply stick with GNOME or KDE or any other stacking window manager. Although I would still recommend installing a twm at least once to experience it.

I must say, I like notebooks. I used them extensively in my first job in analytics, and they really helped me dive into the problem and experiment with different use cases. I have also worked with VSCode, although I am not a big fan of it, it has helped me in some specific use cases where a more "software engineering" perspective is needed.

With that in mind, when I read the book "Approaching Almost Any Machine Learning Problem" by Abhishek Thakur, and then watched the controversial and yet funny conference by Joel Grus on why he dislikes notebooks, I started to think deeply about the perspective of writing software that follows good practices, is expressive, and still easy to prototype. Unfortunately, I think Grus is right about it. Working with notebooks can lead to some weird behaviors, like running cells in different positions, populating your analysis with too much unnecessary information and plots, not creating abstractions when needed, and having issues with reproducibility. On the other hand, the script perspective didn't help me with fast iteration when I needed quick answers to simple questions.

When I moved to Julia, I realized that the REPL is in another level, and I understood that an important part of this community uses (Neo)Vim or Emacs for development. I was curious about using these tools for data science projects. Although there are not many articles about it, and the community using Vim/Emacs is quite small compared to other options, I found it pretty cool because it is minimalistic (though you can customize it extensively), fast, and promises to increase productivity after mastering the Vim keybindings (in 10 years).

What I realized is that you can still prototype like notebooks (but with a perspective closer to RStudio) with one pane for your code and another pane with your REPL open. Then, you can start transforming your code to make it look like serious software, all within one window without moving all the .ipynb file contents to another .py or .jl file. I found this workflow more enjoyable.

First of all, make sure to install Neovim and Tmux. There are plenty of tutorials out there on this topic, so I won't go into the details here.

The important thing is to create an init.lua file. If you don't want to install everything one by one, I recommend following the kick starter, provided by nvim-lua/kickstart.nvim. It provides the basic tools for working with Neovim, including a package manager, Treesitter, LSP integration, etc. This kickstarter uses LazyVim, which should be faster and doesn't require frequent updates like PackerNvim. Just create the init.lua file, copy and paste all the content into that file, save it, and quit. When you open it again, it should start installing or upgrading everything.

Also you want to create a Tmux config, the default config in Tmux is already ok for working with Data Science or the Julia experience, but anyway you would want to edit a file for setting a colorscheme or edit some shortcuts, to create just add ~/.tmux.conf

You also want to create a Tmux config file. The default config in Tmux is already suitable for working with Data Science or the Julia experience, but you may want to edit it to set a colorscheme or modify some shortcuts. Just add ~/.tmux.conf to create the file.

Here are the things required for editing the init.lua file:

1. Add Julia in the init.lua for treesitter and also consider to add the julials = {} for local servers
2. Make sure to add the sysimage for the languageserver. in this discussion, they summarize the procedures well, Follow the instructions and add the snippet of code to your init.lua

-- Run Julia LSP
require'lspconfig'.julials.setup{
    on_new_config = function(new_config, _)
        local julia = vim.fn.expand("~/.julia/environments/nvim-lspconfig/bin/julia")
        if require'lspconfig'.util.path.is_file(julia) then
        -- vim.notify("Hello!")
            new_config.cmd[1] = julia
        end
    end
}

3. This should be enough for setting up Julia. If you open a Julia file, Neovim should be able to detect the LSP and work with other properties like jump to definition, etc. For R and Python, this should be a bit more straightforward for now (not need step 2).
4. There are other things you want to add, for a data science project, one is vim-slime, This package is great for sending snippets of code from your file to a Julia REPL. Make sure to install it and add the following code to your init.lua. This will allow you to open a Tmux pane and start interacting with the file. You can modify the snippet below to change your target_pane (if you prefer the REPL on your left side or above, you can change this). The actual shortcut is Ctrl-c + Ctrl-c, which you can modify if you prefer.

vim.g.slime_target = 'tmux'
-- vim.g.slime_default_config = {"socket_name" = "default", "target_pane" = "{last}"}
vim.g.slime_default_config = {
  -- Lua doesn't have a string split function!
  socket_name = vim.api.nvim_eval('get(split($TMUX, ","), 0)'),
  target_pane = '{top-right}',
}

5. For Tmux, there are some things you can add. Here is my config, which is really simple. However, I encourage you to find your own taste with Tmux.

set -g mouse on
set -g history-limit 102400
set -g base-index 1
set -g pane-base-index 1
set -g renumber-windows on

unbind C-b
set -g prefix C-x

# vim key movements between panes
# smart pane switching with awareness of vim splits
bind h select-pane -L
bind j select-pane -D
bind k select-pane -U
bind l select-pane -R
# reloading for now:w

unbind r 
bind r source-file ~/.tmux.conf \; display "Reloaded ~/.tmux.conf"
# plugin
# Initialize TMUX plugin manager (keep this line at the very bottom of tmux.conf)

set -g @plugin 'egel/tmux-gruvbox'
set -g @tmux-gruvbox 'dark' # or 'light'
run '~/.tmux/plugins/tpm/tpm'

For this purpose, I have considered the following in my Tmux config: activate the mouse, increase the history limit in the panes (this is necessary because the default limit in Tmux is quite constrained), count from 1 with panes, change the prefix (I found it easier to use Ctrl-x rather than Ctrl-b), and add the keybindings to move between paneslike vim. The r shortcut is used to restart the config file when you add or modify features, so you can use prefix + r to apply your changes. Finally, in Tmux, you can use a package manager called TPM. Make sure to added in your config file.

So far, the workflow with Neovim and Tmux has been set up nicely. However, there are some areas that can be improved. One of them is the visualization aspect. As a data scientist, you need to constantly iterate and visualize your data. If you want to have a deep understanding of your dataset and generate plenty of visualizations, the current setup may not be the best. However, in Julia, you can easily switch to Pluto to display all the figures you want. One thing I have tried is to constantly display those plots you are working on inside the terminal. One way to do this is by using unicodeplots. If you like working with Plots.jl, you can change your backend from gr() to unicodeplots(). In my opinion, the quality of the visualization may not be the best, but it allows for instant plots in your terminal without the need for third-party software. For fast iteration, it is good enough.

Another important point to consider is maintaining consistency in the workflow between Julia code and the Julia REPL. Currently, I have a workflow with Vim and my code, but the REPL follows a different logic. This is where the aforementioned repository could potentially help, as it aims to bridge the gap and maintain homogeneity between the two panels. Integrating Vim keybindings into the REPL would provide a seamless experience, allowing for a smoother transition and enhancing the overall workflow. It is definitely an area I look forward to exploring in the future to further improve my development process.

In this blog, I have explained how to set up Neovim and Tmux with Julia (or any other data science programming language). This setup provides a minimalist perspective. For people who like to have a variety of tools at hand, it may feel a bit lacking. However, if you are someone who is looking for a lightweight tool, minimalistic design, and enjoys working within the terminal, I highly recommend giving it a try.

For these two machines, I installed different operating systems, for the old laptop at first I wanted to install Arch Linux, the truth is that that operating system attracted me more attention, but I was having problems with the installation and not recognizing the problem, I ended up taking a few steps back and decided to try something simpler. Then, I started my process with Ubuntu.

I still had doubts about the MacBook Pro, as it was the project whose primary choice was to go with Fedora. Even though there are experienced people who have installed another operating system, Asahi's team is working along with this distribution to advance the project of bringing the latest MacBooks so that they can be used without significant problems in Linux environments. But a few days ago, they made the official release. And I decided to give it a chance.

The final result: In general, it is better than expected; my old laptop got a second life; I could use it for work that does not require high-intensity computing, such as internet browsing, writing documents, etc. While the MacBook Pro excepting some details still works well.

Finally, I believe I will continue using Linux, at least for the older PC, as it seems worthwhile to have a supportive device or for simple experimentation. Moreover, my interest in using Linux as the primary operating system is growing. I would probably switch to Fedora since I find the Gnome version of it more user-friendly than Ubuntu's. Regarding the MacBook, I will continue working in the Asahi/Fedora environment, but in case of any complications, I will revert to MacOS. I'll maintain the dual boot, even though I have some specific issues with its interaction. Nevertheless, I still find it quite manageable to use Asahi on this powerful machine.

To start with the distributions, Debian is incredibly simple to get started with, the installation is approachable, and I must admit that I like that it is (or pretends to be) 100% free software. Furthermore, once you go through the installation process, the desktop you choose just works, no surprises, it's rock solid, and of course, you don't expect much on the horizon regarding updates. In fact, every time I did an apt update, everything was simply up to date. So it's a rather boring distribution if you want to be constantly surprised with new things, but for me, this is quite positive, as it maintains certainty in the system, you know it won't fail unless you do something stupid. Regarding the software you install, obviously this is where you notice the gap, since Debian is quite conservative when it comes to bringing software into its main repository and therefore it's not uncommon to have software versions that may be 10 or 12 months behind the current development version. This may not be a big problem, but each software has a different development speed, and in a year you can have significant differences. Also, if you've been carrying more updated versions of programs that have some kind of config file, that can be a problem. An example where I noticed this was when I wanted to install Alacritty and port my .toml file with my configurations, when using it, I realized that the changes weren't applied. The reason was that the version of Alacritty that comes from Debian's apt was an old version that used .yml files, so I had to 1) adapt my configuration files to this version, which for this case wasn't complicated, or 2) compile from source.

Compiling from source isn't a bad approach, however, it means that you're at the mercy of your package manager taking care of future updates, and obviously that can represent a risk. An important issue with a system like Linux is that you have your software updated and operating harmoniously with your operating system. Of course, there's nothing wrong with compiling from source, I've done it with some software, but it's important to note that it's not the most desirable. However, a positive aspect to recognize is that Debian has a vast repository, which reduces the chances of having to resort to installing from source code.

On the other hand, I'm now using Arch (btw) so I'm still in a process of experimentation with this variant. Arch is different in its installation process, although now there's a script that simplifies the process, the manual installation is in the terminal by typing commands and where you have to follow the instructions from the wiki, it's not that difficult, but obviously it's more likely that you can make a mistake along the way and therefore mess up, in fact, I messed up a couple of times because I didn't configure the Nvidia driver properly and therefore my system failed, so I had to start the process again.

If you want up-to-date software, this is the distribution and even if you want to access proprietary software, Arch has no problems, it's a distribution agnostic and therefore has a laissez-faire mentality towards users, I can run the analog of apt update which in this case is Pacman -Syu every day and there may be new updates. Obviously with software like Alacritty or Neovim I didn't have to resort to compiling it from source because Arch itself provides recent updates which is also a pleasure not to have to directly intervene with the code, another thing is that in addition to the base repository, Arch has the AUR which is another repository where the community can upload software and of course that allows your possibilities to expand, however in my experience, it's in the AUR where you have more chances of software failure.

Here are some other examples of software that allowed me to compare distributions. As I like to watch anime, I wanted to install ani-cli which is an application to watch content from the terminal (you have to thank that the hacker community is quite otaku), unfortunately, this software in Debian is not considered in its main repository yet and will apparently be added in version 13, so one option was to compile it, but I finally gave up on it. On the other hand, with Arch there was no problem, the repo was in AUR so the installation was quite simple. The second case was Anki, a flashcard application, which I like and have used a lot to learn languages so I thought about installing it on my pc as well (although the Android app is quite good to be honest), unfortunately Anki is a mess, I went to the documentation and tried to install it following the instructions but had problems in the process, fortunately Debian has Anki in its main repository, so installing it with apt was the best option, on the other hand Arch had it in the AUR, however, I had problems with the installation so I didn't continue with it. The third and last case was Librewolf, in this case Debian had no problems, by following the steps in the documentation the issue worked without problems, Arch had it in the AUR, and the installation process took quite some time and finally I had problems with that but the binary worked fine.

As a side note, I must praise the Arch Linux Wiki, you may or may not like Arch, but I think no one can deny that its documentation is of a high level, it helped me to see a specific case where I wanted to see how to install the Japanese keyboard on it with the kanas specific to the writing of this language, I checked the documentation in Debian and Arch, finally the latter gave me clear instructions on how to configure it correctly, besides that on other occasions when I've had problems with something in Debian/Ubuntu/Fedora or even Arch itself the Wiki has been helpful.

Finally, I want to highlight that both have the possibility of minimal installations, so if you have a laptop with hardware restrictions, I think there's no problem with any of these variants for you to do a minimal installation and instead of using a bloated desktop environment, you can use a window manager that will be much lighter and more efficient in resources like Sway, i3, or dwm. Although I wrote about Sway in another post, now I want to focus on dwm and another set of software that belongs to suckless.

Suckless is a community of hackers who have built a set of software based on the concepts of minimalism, simplicity, and frugality, part of this decision you can read in their philosophy, but to try to get to the point, all the code is written in C, and there are no configuration files, if you want to install this, you download the code and compile it, if you want to make modifications to something, you go straight to the C source code and modify it and recompile it. The most important software (in my opinion) are:

1. st a terminal emulator
2. dwm the window manager
3. dmenu the dynamic menu that you can use to run your programs

Something you have to notice is that this software has minimal features, for example, St doesn't have a way to scroll, nor does it have a way to make your terminal transparent, if you want to achieve this, you have two options: the first is to write the code yourself, but if you're like me and have no idea about C then accessing the patches that the community has created and improved over time is the option, so for example, to the terminal I can add transparency with alpha and a gruvbox color scheme. To dwm I can add patches to add gaps with useless gaps. all this just with the command

patch -p1 < path/to/patch

It should be noted that starting to add patches can lead to errors, so you will have to be the one to make the corresponding adjustments for the failures, and in some cases if you have several patches in mind, you have to consider that there is a more appropriate order to do it to reduce the potential number of errors. Obviously the idea is not that you go and take a collection of patches that you "like" and apply them, but that you be much more austere and select them according to a real need that arises, for example, I only applied useless gaps to dwm for a bit of aesthetics, but the truth is that dwm by itself has been fantastic, I haven't had the intention of adding another patch for now, I haven't needed to add scrolling to st, since I use tmux quite a bit, which serves that function as a substitute. So if you like to add things to your application just because, it's possible but you'll have to deal with debugging the errors that occur while adding the patches.

Other software that I have been adding and that follows a similar philosophy:

1. nsxiv: To display images
2. scrot: screenshots
3. feh: set an image as background
4. cmus: music player
5. ly: minimal session manager.
6. mpv: Media player
7. slock: lock your system with a password.
8. xclip: X11 clipboard

Among others…

Obviously I have to point out that these exercises for a machine that isn't really that old and has relatively decent hardware maybe is considered exaggereted, as an exercise it was worth it and it taught me a lot about minimal installations and how you can reach customization levels while keeping resource usage to a minimum and in fact I will continue using this configuration until I get bored, but if you're not interested in that Gnome or KDE run quite well on a machine like this.

Regarding Arch and Debian I don't have a clear preference yet, both have their pros and cons, for now I'll continue using Arch to continue evaluating how it goes. Although there are other distributions, even some more hardcore ones like Gentoo, for now my curiosity hasn't reached that point yet.

Suckless software is an interesting perspective, quite radical to market trends and for a niche taste, I can't imagine many people wanting to get into this point, but for those who do, I'm sure it's a good exercise to use something like dwm, inspect the C code, customize, add patches, etc. If you can do that, the idea of making your own software for a specific personal need may not be so far-fetched.

I've also had a lot of fun with Linux over the past 4 months, it has taught me a lot about how an operating system works especially when I've wanted to go to slightly deeper levels and start eliminating the use of interfaces, I'm not going to call myself a "power user", but certainly t here's some knowledge that I value and I understand a bit more about those people who want to know more about their system and adjust it to their liking and have absolute control over it. If there's anyone interested in knowing what my "learning path" was, which by the way was not planned at all it was just pure curiosity, I would describe it as follows:

1. Install free and open source software on your own machine, even if you're on MacOS or Windows. Install and familiarize yourself with their basic uses and if you can include it in something you do daily even better. For example, Vim, Python, R, LibreOffice, etc.
2. Learn basic commands in a terminal: commands like cd, mv, rm, cp, ls. I use them constantly nowadays and I would recommend reading a bit about them and doing some tests to remove the fear of the black screen, then you can add new commands like curl, grep, sed, etc.
3. Install Ubuntu or another friendly distribution: I used Ubuntu at the time, there are people who criticize it currently for various reasons. But something that Ubuntu has is that its installation process was super friendly, a modern look, there's plenty of documentation on the internet and it works well. Linux Mint seems like another good alternative to Ubuntu, but I don't have experience with that distribution. This is for a start, later if you want to move to another distribution nothing will prevent you from doing it
4. Get familiar with the package manager: The first way to install software is from the terminal using your package manager, if you're on Ubuntu or Mint you'll have to use something like sudo apt update and then sudo apt install yoursoftware, there are other alternatives to install software but this should be your priority method.
5. Install software by compiling source code: Take a software that interests you, go to its documentation or the repository where it is and read about its installation process, probably besides the package manager it will have a space where it will give instructions on how to do it, follow those instructions.
6. Use a Tiling Window Manager: There are two major desktop environments in Linux GNOME and KDE, both have a lot of features and you can easily navigate in them, adjust brightness, connect to wifi, explore your folders with files, screenshots, etc. With a twm you won't have any of that, and you'll have to look up how to execute each of these commands, you need to connect your mouse via bluetooth, one possible solution is to install bluez and bluez utils, open the terminal and use the bluetoothctl command, there are also GUI options, but it will depend on you to find a way to execute it. Play with this and if you want try to do a ricing (configure your environment to look aesthetically attractive).
7. Create a remote server and run some programs on them: If you have an old laptop, or a raspberry pi, or rent a vps, you can try to create a remote server where you can host some programs, this is the path to another world that is self-hosting, I'm quite a newbie in this, but there are a couple of experiences that can teach you something, for example create a personal website and host it on your server, buy your domain and redirect it to your website. One thing I did for example was to get rid of Kindle and host my books in Calibre, so now I can access my personal library from my own server. With this you can learn a bit about connecting via ssh, nginx, dns, docker, etc. There are people who host a bunch of applications from a youtube frontend, emails, vpn, etc. There you can see for yourself what to do.
8. Install Arch Linux manually: If you installed Ubuntu before, you'll notice that the process is quite simple in general, installing Arch is more complex, but it will teach you how to make an operating system from scratch, so you can understand what some of the base libraries are for, make the partitions manually, configure network, timezone, keyboard, decide between X11 or Wayland, etc. Try to use it for a period of time as your main machine and use it for everything you can.
9. Contribute to Linux: I plead guilty of not doing it yet, I suppose this is a note for the future…

Anyway, it's been an interesting journey and I think I'll continue using Linux for my personal machines. I'll probably continue to see some self-hosting things, but I think I've had enough with ricing and trying distributions, it's time to move on to another topic.

Si bien no me ataño a ninguna filosofía en particular más de que debe ser cómodo para mi trabajar dentro de Emacs, trato de que: * Solo contenga software que voy a usar: No es necesariamente minimalista, pero tampoco quiero instalar cosas que no necesite, sino, hubiera elegido algo como Doom Emacs. * Mantenerse lo más apegado a los shortcuts originales de Emacs, no he hecho grandes cambios ni agregado muchos nuevos bindings, no pretendo usar Evil mode, dado que todavía me considero un novato con Emacs, por lo que prefiero que se retrate de forma más precisa como Emacs funciona ¹.

Para partir lo más básico es lo estético, he decidido remover las barras de herramientas, la barra para scroll y menú, además de algunas configuraciones de fuente y tamaño.

(setq inhibit-startup-message t)

(scroll-bar-mode -1)        ; Disable visible scrollbar
(tool-bar-mode -1)          ; Disable the toolbar
(tooltip-mode -1)           ; Disable tooltips
(set-fringe-mode 10)        ; Give some breathing room

(menu-bar-mode -1)            ; Disable the menu bar

;; Set up the visible bell
(setq visible-bell t)

;; set font decoration
(setq font-lock-maximum-decoration t)

(set-face-attribute 'default nil :font "Iosevka" :height 160)

;; set time
(setq display-time-24hr-format t)
(setq display-time-format "%H:%M")
(display-time-mode 1)

;;set full screen
(set-frame-parameter (selected-frame) 'fullscreen 'maximized)
(add-to-list 'default-frame-alist '(fullscreen . maximized))

Lo siguiente es inicializar el administrador de paquetes y las fuentes donde se descargaran estos paquetes. Aquí tengo seteado melpa (librerías de la comunidad para la comunidad) y elpa (librerías de GNU y adicionales).

;; Initialize package sources
(require 'package)

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

(package-initialize)
(unless package-archive-contents
 (package-refresh-contents))

;; Initialize use-package on non-Linux platforms
(unless (package-installed-p 'use-package)
   (package-install 'use-package))

(require 'use-package)
(setq use-package-always-ensure t)

Una vez seteado las conexiones a melpa y elpa, ya puedes empezar a descargar y usar librerías, soy un ferviente usuario del tema gruvbox, y me gusta usar números relativos para editar ² aunque lo desabilito en algunos unos casos

(use-package doom-themes
     :if window-system
     :ensure t
     :config
     (load-theme 'doom-gruvbox t)
     (doom-themes-org-config)
     (doom-themes-visual-bell-config)
     (menu-bar-mode -1)
     (tool-bar-mode -1)
     (fringe-mode -1)
     (scroll-bar-mode -1))


;; set numbers in the left
(column-number-mode)
(global-display-line-numbers-mode t)
(setq display-line-numbers 'relative)


;; But disable the numbers in some modes
(dolist (mode '(org-mode-hook
               term-mode-hook
               shell-mode-hook
       vterm-mode-hook
               treemacs-mode-hook
       dashboard-mode-hook
               eshell-mode-hook))
 (add-hook mode (lambda () (display-line-numbers-mode 0))))

Aquí agrego un poco de "color" a Emacs al agregar cosas como Ivy para autocompletado, agregar iconos para dired (el administrador de archivos por defecto de Emacs), modificar la barra de estatus, si quieres más color a esta última puedes usar doom-modeline, pero a mi parecer la barra de estatus que viene por defecto es lo suficientemente bueno. ```elisp ;; Set Autocompletion (use-package ivy) (ivy-mode 1)

(setq ivy-use-virtual-buffers t) (setq ivy-count-format "(%d/%d)")

;; basic icons (use-package all-the-icons :ensure t :init)

(use-package all-the-icons-dired :ensure t :init (add-hook 'dired-mode-hook 'all-the-icons-dired-mode))

(use-package all-the-icons-ibuffer :ensure t :init (all-the-icons-ibuffer-mode 1))

;; set delimiters to distinct the language (use-package rainbow-delimiters :hook (prog-mode . rainbow-delimiters-mode))

;; ui to display characters (use-package which-key :defer 0 :diminish which-key-mode :config (which-key-mode) (setq which-key-idle-delay 1))

;; ivy rich (use-package ivy-rich) (ivy-rich-mode 1) ``` Dos librerías fundamentales para incorporar en el workflow de Emacs y que pareciera ser un "must" en la comunidad es Projectile (para administración de proyectos) y Magit (para control de versiones), no los he usado extensivamente pero son buenas piezas de software.

;; Projectile
(use-package projectile
 :ensure t
 :init
 (projectile-mode 1))

;; magit
(use-package magit
 :ensure t
 :config
 (setq magit-push-always-verify nil)
 (setq git-commit-summary-max-length 50)
 :bind
 ("M-g" . magit-status))

La parte que más me interesaba entender de Emacs era Orgmode, así que setié una configuración que me ha funcionado bien, y que las posibilidades son infinitas al momento de customizarlo.

En esta sección me enfoqué en definir una carpeta llamada org, donde he alojado varios archivos para eventos, tareas, etc. y ahí puedo hacer capturas de notas, tareas solo presionando C-c c, también saqué la idea de System Crafters ³ de usar org-refill para poder ir archivando tareas una vez que las completo, también agregué un poco de estilo a los archivos .org (para más placer).

;; org mode
(global-set-key (kbd "C-c l") #'org-store-link)
(global-set-key (kbd "C-c a") #'org-agenda)
(global-set-key (kbd "C-c c") #'org-capture)

(setq org-ellipsis " ")
(setq org-src-fontify-natively t)
(setq org-src-tab-acts-natively t)
(setq org-confirm-babel-evaluate nil)
(setq org-export-with-smart-quotes t)
(setq org-src-window-setup 'current-window)
(setq org-directory "~/org")
(setq org-agenda-files '("events.org" "tasks.org" "birthday.org"))
(setq org-agenda-start-with-log-mode t) ;; set log for completion in agenda
(setq org-log-done 'time)
(setq org-log-into-drawer t)

;; After complete a task send to Archive or other file listed
(setq org-refile-targets
     '(("archive.org" :maxlevel . 1)
   ("tasks.org" :maxlevel . 1)))
;; after send the task completed, save all the org files
(advice-add 'org-refile :after 'org-save-all-org-buffers)

;; Set templates for fast note taking and other
(setq org-capture-templates
     '(("t" "Todo" entry (file+headline "~/org/tasks.org" "INBOX")
        "* TODO %?\n  %i\n  %a")
       ("j" "Journal" entry (file+datetree "~/org/journal.org")
        "* %?\nEntered on %U\n  %i\n  %a")))


(add-hook 'org-mode-hook 'org-indent-mode)


;; sintactic sugar for bullets
(require 'org-bullets)
(add-hook 'org-mode-hook (lambda () (org-bullets-mode 1)))

Uso de Dashboard a la hora de abrir Emacs para poder ver archivos, proyectos y tareas pendientes, además de una frase bíblica para más inspiración.

;; Dashboard at open emacs
(use-package dashboard
 :ensure t
 :config
   (dashboard-setup-startup-hook)
   (setq dashboard-center-content t)
   (setq dashboard-startup-banner 'official)
   (setq dashboard-items '((recents  . 5)
               (projects . 5)
               (agenda    . 5)))
   (setq dashboard-banner-logo-title "Do you see a man skillful in his work? He will stand before kings; he will not stand before obscure men. (Proverbs 22:29)"))

Permitir procesos asincronos elisp ;; allow async process (use-package async :ensure t :init (dired-async-mode 1))

Syntax highlighting para markdown elisp ;; Use markdown (use-package markdown-mode :ensure t :mode ("README\\.md\\'" . gfm-mode) :init (setq markdown-command "multimarkdown"))

Para leer archivos pdf, Emacs tiene incorporado un ereader, con funcionalidades básicas, sé que existe una librería con mayor funcionalidades llamado pdf-tools, pero no he tenido la necesidad de usarlo ⁴, sin embargo, porque tengo varios epubs que leo, instalé nov.el para dicho propósito.

También he incorporado emms para escuchar música, hace el trabajo de base, pero todavía no me he tomado el tiempo de revisar a fondo como funciona.

Y finalmente agregué elfeed para leer rss de distintas noticias y blogs, definitivamente me ha gustado más que newsboat. Dado que tiendo a leer blogs de estadística y análisis de datos que por su naturaleza contienen muchas imagenes, no requiero de abrir el navegador para poder tener un detalle completo sobre este.

;; Nov.el to read Epub
(use-package nov
 :ensure t)
(add-to-list 'auto-mode-alist '("\\.epub\\'" . nov-mode))

;; To display music as a gigachad
(use-package emms)
(emms-all)
(setq emms-player-list '(emms-player-mpv)
     emms-info-functions '(emms-info-native))

;; To read RSS
;; Somewhere in your .emacs file
(use-package elfeed)
(setq elfeed-feeds
     '(
   ("https://planet.emacslife.com/atom.xml" Emacs Blog)
   ("https://news.ycombinator.com/rss" News)
   ))
;; set global keybinding for elfeed
(global-set-key (kbd "C-x w") 'elfeed)

Ahora para algunas de las partes más relacionadas a desarrollo y análisis de datos, he incorporado ess (Emacs speaks Statistic), librería fundamental para trabajar con R y otros software ⁵. Para Python he incorporado elpy que es una librería que viene con lo necesario para desarrollo en Python, también sé de la existencia de ein para Jupyter Notebooks, no lo he probado todavía, tal vez lo haga en algún futuro. Para Julia hay varias discusiones dando vueltas sobre como aprovechar Emacs ⁶, por ahora tengo solo seteado 2 librerías, julia-mode y julia-snail, el primero es solo syntax highlighting y el segundo permite interactuar con el REPL, de una forma similar a la que usarías Slime, haciendo evaluaciones linea por linea cuando sea requerido.

;; statistical mode in emacs
(use-package ess)
(use-package company
 :config
 (add-hook 'after-init-hook 'global-company-mode))

;; python development
(use-package elpy
 :ensure t
 :init
 (elpy-enable))

;; Julia mode
(use-package julia-mode
 :ensure t)

(use-package julia-snail
 :ensure t
 :hook (julia-mode . julia-snail-mode))
(setq-default julia-snail-executable "/home/navi/.juliaup/bin/julia")

Emacs por alguna extraña razón tiene incorporado 3 terminales, eshell, shell, term. Sé que existen usos específicos para cada uno aunque aunque no estoy del todo claro ⁷, especialmente por ese extraño patrón de que puedes borrar lineas de código escritas en la terminal, o porque tienes que cambiar tus bindings al momento de moverte de un buffer a otro (C-x a C-c), o no ser capaz de abrir vim dentro estas terminales ⁸, sin embargo, leí comentarios positivos con respecto a Vterm, y decidí instalarlo y probarlo, hasta ahora es el que se ha ajustado mejor a mis preferencias. Y por lo tanto, he usado por defecto ⁹

;;A new  terminal with more capabilities
(use-package vterm
  :ensure t)

Finalmente, una cosa que a menudo me encuentro haciendo es copiando y pegando lineas completas de texto, tomé esta función customizada de BugsWriter para poder alcanzar ese propósito.

;; custom function to copy whole line with C-c w l
 (defun copy-whole-line ()
   (interactive)
   (save-excursion
     (kill-new
      (buffer-substring
    (point-at-bol)
    (point-at-eol)))))
(global-set-key (kbd "C-c w l") 'copy-whole-line)

Notar algo que apoyo completamente y doy como consejo es reemplazar el Ctrl por la tecla CapsLock, realmente resolverá un montón de dolores que tienes con Emacs y su extraña posición con las teclas lideres. Así que por favor antes que te lances a usar emacs por primera vez, te recomiendo hacer este cambio.

Algunas cosas que quiero seguir explorando y probablemente incorporando en Emacs en caso de que se ajusten bien:

1. Operar email dentro de Emacs
2. Org Roam, bastantes cosas positivas he escuchado sobre este software para tomar notas que parece inspirarse en el Zettelkasten method. También Denote es una opción.
3. Eglot o cualquier servidor del lenguaje que funcione.
4. Org Babel, para literate programming.
5. Integraciones con Quarto.
6. EXWM, un windows manager dentro de Emacs, parece innecesario en mi caso de estar usando Sway, pero ¿Por qué no probarlo?.
7. Aprender Elisp, hasta ahora he usado principalmente librerías que la comunidad o GNU han creado, pero el verdadero valor está en que puedas aprender Elisp y hackear por tu cuenta.
8. Incorporar algún LLM ¹⁰.

Dentro de todo, Emacs ha probado ser un interesante reemplazo al flujo de trabajo que estaba usando con Vim + Tmux + amigos, muchas de las cosas que me tomaron tiempo aprender a usar con este workflow, en Emacs fue resuelto casi en un par de semanas, por supuesto, hay un sesgo acá de aprendizaje de herramientas previas que sin dichas experiencias hubiera probablemente ralentizado mi aprendizaje de Emacs.

Otra cosa que cabe notar, es que si vienes con una mente abierta, Emacs puede ser realmente divertido de usar, Elisp realmente es un buen lenguaje para este software y la mística de "hackear" tu editor es algo que de verdad puede llevarte a inspirar hacer cosas por tu cuenta y darte absoluta libertad, convertir un editor en tu workshop digital tiene sus dificultades, pero estoy seguro de que vale la pena si te atreves a ensuciarte las manos.

1. It will require to install:
2. mu4e
3. isync/mbsync
4. msmtp

sudo apt install isync

Create a new file ~/.mbsyncrc

     
IMAPAccount migadu
Host imap.migadu.com
User mail@mymail.xyz
PassCmd "pass mail/my_mail_password"
TLSType IMAPS
CertificateFile /etc/ssl/certs/ca-certificates.crt
#AuthMechs Login
Port 993

IMAPStore migadu-remote
Account migadu

MaildirStore migadu-local
Path ~/Mail/migadu/
Inbox ~/Mail/migadu/INBOX/
Trash ~/Mail/migadu/Trash/
SubFolders Verbatim

Channel migadu
Far :migadu-remote:
Near :migadu-local:
Patterns *
CopyArrivalDate yes
Create Both
Sync All

SyncState *

Then, make sure to run in the terminal the following statement:

mu init --maildir=DIR --my-address=ADDRESS

then run:

mu index

Go to your init.el and write this snippet

(use-package mu4e
:ensure nil
;; :load-path "/usr/share/emacs/site-lisp/mu4e/"
:defer 20 ; Wait until 20 seconds after startup
:config

;; This is set to 't' to avoid mail syncing issues when using mbsync
(setq mu4e-change-filenames-when-moving t)
(setq mail-user-agent 'mu4e-user-agent)

;; Refresh mail using isync every 10 minutes
;;(setq mu4e-update-interval (* 10 60))
;;(setq mu4e-get-mail-command "mbsync -a")
(setq mu4e-get-mail-command (concat (executable-find "mbsync") " -a"))
;; how often to call it in seconds:
(setq mu4e-update-interval 300)

(setq mu4e-maildir "~/Mail/migadu")

(setq mu4e-drafts-folder "/Drafts")
(setq mu4e-sent-folder   "/Sent")
(setq mu4e-refile-folder "/All")
(setq mu4e-trash-folder  "/Trash")
(setq mu4e-junk-folder  "/Junk")
(setq mu4e-others-folder  "/Others")
(setq mu4e-maildir-shortcuts
  '(("/INBOX" . ?i)
      ("/Sent" . ?s)
      ("/Trash" . ?t)
      ("/Drafts" . ?d)
      ("/Junk" . ?a)
  ("/Others" . ?o)
  ))
(mu4e t))

With this you can run mu4e inside emacs and you should see how your system is pulling up your emails. But notice is not ready to send emails yet, we need to consider an extra customization.

Make sure to install msmtp (sudo apt install ) and create a file ~/.msmtprc, and write the following

defaults

auth on

tls on
 
port 587
tls_trust_file /etc/ssl/certs/ca-certificates.crt
logfile        ~/.msmtp.log


account personal
host smtp.migadu.com
from mail@mymail.xyz
user mail@mymail.xyz
passwordeval pass mail/mail@my_mail_password | head -1


account default : personal

Finally write in your emacs 'init.el' this.

  (setq
   message-send-mail-function   'smtpmail-send-it
   smtpmail-default-smtp-server "smtp.migadu.com"
   smtpmail-smtp-server         "smtp.migadu.com"
   smtpmail-local-domain        "migadu.com"
   )

(setq sendmail-program "/usr/bin/msmtp")
(setq message-sendmail-extra-arguments '("--read-envelope-from"))
(setq message-sendmail-f-is-evil t)
(setq message-send-mail-function 'message-send-mail-with-sendmail)

Then you should ready to go, enjoy the spam…

• https://thanosapollo.org/posts/mu4e-guide/
• https://www.youtube.com/embed/yZRyEhi4y44
• https://www.youtube.com/embed/Qq6s3PwSwjo
• https://djcbsoftware.nl/code/mu/mu4e/
• https://www.reddit.com/r/emacs/comments/bfsck6/mu4e_for_dummies/

So what I recommend is following some servers, while Gnus has his own functions to extract rss (nnrss), I just recommend you to connect to Gwene.org and Feedbase.org via nntp to follow your blogs, mailing list and Youtube channels.

(use-package gnus
:ensure nil
:config

(setq gnus-select-method '(nnnil ""))
(setq gnus-secondary-select-methods
      '(
          ;; Connecting to gwene
          (nntp "news.gwene.org")
          ;; Connecting to Feedbase
          (nntp "feedbase"
                (nntp-open-connection-function nntp-open-tls-stream) ; feedbase does not do STARTTLS (yet?)
                (nntp-port-number 563) ; nntps
                (nntp-address "feedbase.org"))
          ;; Here can come another connections like your emails for example
)

With this basic setup, you can start Gnus and you should be able to connect to these servers, obviously nothing will appear because you didn't subscribe to anything yet, but if you press ^ you should be able to see all the servers you are connected to, select gwene, it will open all the groups in that server find your blogs, mailing lists and Youtube feeds, if you are missing some just add the rss to the respective websites (gwene.org) and in minutes, the new rss will appear on the list, you can subscribe to the group by putting the cursor on the group and pressing u.

After You subscribed to few groups close the servers with q and you should come back to Gnus Groups, you can update pressing g or just quick with q and enter again to Gnus, You should see the new groups you subscribed.

Another nice feature of Gnus is that you can create topics, this is just a simple way to sort your groups so it become easier to navigate through them. Press T-n to create a topic, and to move specific group to that topic just press T-m and then select the topic to send that group to it.

Finally, you want to read the news, select the group if it has too many articles Gnus will prompt you how many you wants to get, select 10 for example and then it will open the latest 10 articles, you can press Enter to open the article, n and p to move to the next and previous article unread, Space to reading through the article and q to close the Group and comeback to the main Gnus default. If you want to mark all the articles in the group as read, just press c and select y.

If you want to read the article from another way, let's say Youtube from mpv and blogs from eww, I recommend you to use a code I steal from Joshua:

  (defun my-browse-url-mpv (url &rest _args)
  "Open URL in mpv."
  (start-process "mpv" nil "mpv" url))

(defun my-browse-url-pdf (url &rest _args)
  "Fetch remote PDF and open in pdf-tools within Emacs."
  (let ((tmp (make-temp-file "emacs-pdf-" nil ".pdf")))
    (url-copy-file url tmp t)
    (find-file-other-window tmp)
    (pdf-view-mode)))

(setq browse-url-handlers
      '(("\\(youtube\\.com\\|youtu\\.be\\|vimeo\\.com\\|twitch\\.tv\\)" . my-browse-url-mpv)
        ("\\.mp4$" . my-browse-url-mpv)
        ("\\.pdf$" . my-browse-url-pdf)
        ("^gemini://" . elpher-browse-url-elpher)
        ("^gopher://" . elpher-browse-url-elpher)
        ("." . eww-browse-url)))

This allow me to open articles with eww, and youtube and other websites with mpv. I am sure there is a better way to handle the urls with Gnus but for now this solve my basic use.

Gnus is huge, and many people prefer the simplicity of Elfeed to access to news and blogs, but while that is true, I don't think you need to know that much about Gnus in order to consume information, surprisingly enough, Gnus has been a nice experience for reading news and emails. and I think We should appreciate that we have such a solid tool inside Emacs.

1. A Tiling Window Manager, in my case, I use Sway
2. Vim
3. Tmux
4. Julia or any other scientific computing language

This is the one I read most of the time on Reddit. Here, you will need to install Vim-Slime or a similar "send-to-REPL" plugin. In this scenario, you will enjoy the feature of sending snippets of code to your REPL. You only need to activate Tmux, open your .jl file on one side and the REPL on the other using Tmux panes, and that's it.

The pro is that you can run all your files or experiment with different snippets. The cons of this workflow are that you will be constrained by the space of your screen when it comes to seeing your plots because it will use half of the screen when it displays. The double pane will be shrunk, so you cannot clearly see the code and the REPL. To mitigate this, you could use UnicodePlots to see your data and plots only in the REPL without emergent windows.

I used this as a standard for a while, but it didn't click on me when working with plots in this workflow.

You can achieve this without using Tmux (but it is still convenient to display different sessions). Julia has a really powerful REPL, and the way you can change to Shell mode deserves more attention. Many people will not understand why that is important, but Julia's key is to stay with the REPL activated as much as you can. If you need to shut down it and do other things, then you lose a lot of the power that Julia holds.

Some people dislike using REPL-based languages because they force you to work with workflows that deal with code snippets instead of running all your programs at once. But this is not true at all.

Similarly, you run julia my script.jl in the terminal and then open the file with Vim to keep editing, you can use the REPL to change to the Shell mode, modify your script and then come back to the Julia mode and run your script using include("myscript.jl").

In particular, you can work very well with this work and keep your workspace cleaner. However, if you are working with a script that creates several variables for data cleaning and plots, you will be annoyed to try to remember all of them; at least, that happened to me. When I close the script and run it, sometimes I want to check some results stored in specific variables and call them again, but not always remember them all. You can mitigate part of this by using a main function, saving your plots, and processing the data.

This try to replicate the experience on RStudio or VSCode you will mainly will deal with 2 panels, one with your code, and for other side The REPL, these terminals are splitted, so you are not using Tmux to open panes as in the first case.

Here is where your Tiling Windows Manager will shine in your workflow. If you set up correctly, a new emergent window will appear on your screen every time you run your script and display the plots you want to see. You can easily explore it, zoom in and out, close it, and return to work with your script. I am having a good time using sxiv from suckless to display plots. If you need to see the plots again, here is where the REPL and the Shell mode can help you; if you saved it, you could open it up using tools like Sxiv to explore your plot again.

The positive thing about this style is that you can have everything displayed in a comfortable way, see the code and the REPL clearly, and display your figures in a noninvasive way when you need to explore your figures. The bad thing about it, again this disminished the utilities of Tmux and also made you dependent of your tiling windows manager, not all work in the same way; if you use Sway or dwm, for example, you will have different experiences given the basic set up, so you will have to change the configuration to set your own needs.

Finally, I want to add that there is still room for improvement, and I would like to see other people's workflows and how they deal with their data science projects. These days, I am more inclined to use the last option for this kind of project, and the first one I found more useful for software engineering, like a project where interactivity is not a central part of the process.