Paradigmas
Bueno, es momento de empezar el aprendizaje. El problema aquí es ¿Qué paradigma y qué filosofía escoger?. La respuesta es complicada y depende bastante de los objetivos que se tengan. Afortunadamente, en la entrada anterior, ya había mencionado el enfoque que deseaba adquirir, punto por punto. Solo para recordar, los mencionaré denuevo:
1. Código abierto y auditable.
2. Código minimalista, no inflado y que tenga una superficie reducida.
3. Código legible y bien documentado.
4. Código eficiente y portable, que pueda ser utilizado en el sistema que el usuario prefiera.
5. Código seguro y que encapsule fallos de manera correcta.
Ahora lo que queda es ponernos a investigar para focalizar nuestro enfoque y saber qué paradigmas y filosofías
existentes nos darán una mano para no reinventar la rueda.
1. Cómo muchos sabrán, Linux es mencionado como la alternativa a Windows y a Mac ya que el código de este es completamente
público, modificable y distribuible. No explicaré todo este tema desde 0, solo diré que en el mundo en donde es permitido
leer el código de la herramienta que usamos, existen paradigmas: el "Open Source" y el de "Software Libre". Los dos son opciones
que se acomodan bien de momento, no nos casaremos con ninguna ya que estamos en una etapa muy temprana y no es necesario.
Los recursos con respecto a ambos paradigmas son los siguientes. Para entender bien los paradigmas, es importante leer bien
lo que nos dicen los recursos principales:
Open Source: https://opensource.org/
Software Libre: https://www.fsf.org/
2. En el punto anterior ya redujimos bastante la cantidad de posibles candidatos. Ahora toca el minimalismo. Aunque suene simple
el minimalismo en el mundo del código auditable, es todo un mundo y hay bastantes paradigmas. De acuerdo a lo que he visto en mi
experiencia, los principales referentes del minimalismo en la programación de código auditable son los siguientes:
Suckless: https://suckless.org/
OpenBSD: https://www.openbsd.org/
NetBSD: https://www.netbsd.org/
SeL4: https://sel4.systems/
Nota: Puede que haya más, pero de acuerdo a mis investigaciones y a mi experiencia, creo que vale más la pena enfocarnos en los cuatro
anteriores ya que el minimalismo es uno de sus objetivos principales. Linux lamentablemente no pasa este filtro ya que llega a
enfocarse más en el uso general, lo que hace dificil que pueda considerar el código de Linux como minimalista a pesar de ser considerado
de alta calidad especialmente en comparacion a código privativo.
3. Ahora tenemos a cuatro referentes de donde escoger, seguiremos filtrando. En cuando a legibilidad, los cuatro referentes son bastante
buenos pero llevan el enfoque de una manera distinta. Suckless se enfoca en que el código en sí sea extremadamente sencillo de entender
para un programador al verlo de inmediato. SeL4, OpenBSD y NetBSD no ven tan necesario que el código por sí mismo diga de manera tan
extremadamente directa lo que hace el programa a como lo exige suckless, si no, que se enfocan en dar una documentación extremadamente
exhaustiva, pero a pesar de eso, los tres aún así se preocupan grandemente por que el código sea legible.
4. En este punto es donde Suckless llega a perder contra OpenBSD y NetBSD. El software de Suckless es muy eficiente y se preocupa mucho de que el código sea super
legible y entendible para el usuario avanzado al punto en el que llegan a ver las abstracciones como problemáticas en ciertos
puntos y por esto, el código no llega a estar hecho para que sea super portable sin que haya que tocar código. Es importante
destacar que Suckless ve como algo completamente positivo que el usuario manipule el código y de hecho hay que hacerlo para poder
usar sus herramientas de la manera más provechosa posible. NetBSD, es el principal referente en cuanto a portabilidad, ya que
este se toma extremadamente en serio las abstracciones y el soporte que le dan a distintas arquitecturas. OpenBSD y SeL4 por razones
ligeramente más colaterales también son muy portables pero no se enfocan primariamente en este aspecto como lo hace OpenBSD.
5. En el último punto es donde hay cierto conflicto. En cuanto a seguridad, definitivamente los 3 son muy buenos referentes, pero el orden
definitivo sería SeL4, OpenBSD y NetBSD. SeL4 se construyó utilizando metodologías extremadamente avanzadas en informática
las cuales son probar mediante métodos matemáticos y teoremas, que el código es seguro y predecible, esto se puede ver en la documentación
oficial de SeL4. La metodología sobre la cuál se construyo SeL4 definitivamente es suprema pero al mismo tiempo es la más
costosa en términos de tiempo, además de que no me parece buena idea para yo que soy un principiante. Afortunadamente, de acuerdo a lo que llegué a
investigar, en teoría, cualquier programa podría aplicar las metodologías sobre las cuáles se construyó SeL4 en etapas más avanzadas. Esto me deja a OpenBSD
con la filosofía que puedo tomar de referente para este proyecto ya que se enfoca en minimalismo, gracias a la manera en la que se toman
la seguridad llega a ser bastante portable, es bastante exigente y en general es un referente muy sólido en cuando a código bien estructurado.
Nota: Se escogió a OpenBSD como referente principal y a SeL4 como posible referente secundario, pero no quiere decir que me vaya a casar al 100% con sus filosofías, puede que difiere por momentos en sus prácticas y en las herramientas. Aquí no hay fanatismo, no voy a intentar ser exactamente como los desarrolladores de estas herramientas ya que no tiene sentido práctico, solo son una especia de brújula en cuanto a los estándares y las prácticas que se llevarán acabo a la hora de programar. Sé que resumí demasiado y no me adentré mucho en la filosofía de cada uno, pero es que no lo veo necesario, ya que la ideología solo es un marco de referencia como ayuda opcional.
Herramientas
Ya que elegimos los referentes, ahora vamos a escoger el stack de herramientas que utilizaremos.
El sistema operativo que usaremos será OpenBSD: https://www.openbsd.org/
En cuanto al editor de texto, intenté utilizar vi, pero sinceramente aún no estoy acostumbrado a su naturaleza de un solo color. Así que decidí utilizar Vim: https://man.freebsd.org/cgi/man.cgi?vim(1)
El compilador que se utilizará será Clang. No es muy diferente a gcc en cuanto a uso. Este es el recurso que tomaré de referencia: https://clang.llvm.org/docs/UsersManual.html
Para que el desarrollo sea más sencillo, utilizaré BSD Make: https://man.openbsd.org/make
El lenguaje de programación que aprenderé será C.
C
Para aprender C, utilizaré lo más obvio posible, el manual "C programming v2 manual". Seguiré los paso a medida de que lo vea necesario.
Vamos punto por punto. Instalé una máquina virtual de OpenBSD en Virt Manager, con Qemu y KVM. Este stack ya lo tenía y mi host OS es Void Linux
(no entraré en detalles respecto a mi host). Para tener una experiencia más cómoda, decidí programar en la VM de OpenBSD por medio de SSH.
Utilicé las herramientas doas y pkg_add para instalar lo necesario.
Para no alargar mucho la historia, con mkdir creé un directorio llamdo prueba y con cd entré.
Seguidamente con vim creé el primer archivo llamado main.c.
Seguí las instrucción del manual de C hasta la página 10 y usando clang, logré compilar mi primer programa en C.
openjazz$ mkdir prueba
openjazz$ cd prueba/
openjazz$ vim main.c
#include <stdio.h>
main()
{
printf("hello, world\n");
}
openjazz$ clang main.c
main.c:3:1: warning: type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int [-Wimplicit-int]
3 | main()
| ^
| int
1 warning generated.
openjazz$ ls
a.out main.c
openjazz$ ./a.out
hello, world
Perfecto, el manual de C de momento ha sido de mucha ayuda. El reto vendrá en el futuro cuando empecemos a aplicar estandares de OpenBSD al código que vaya a escribir.