John McAfee fue el creador del 1er antivirus del mundo y se hizo millonario vendiendo esa mierda que nunca sirvio para nada. Ah no para, los antivirus eran “gratis” es decir te espiaban y vendian tus datos.
En Windows, instalar un programa implica confiar en que el sitio web del que lo descargaste no fue comprometido, que el binario no fue alterado en tránsito, y que el instalador no viene con “extras”. Esa cadena de confianza depende de que nada salga mal en ningún punto, y no hay ningún mecanismo técnico que lo garantice. El antivirus intenta compensar ese hueco después del hecho, buscando patrones conocidos de malware.
Linux corta el problema desde la raíz con una arquitectura diferente.
El desarrollador firma el paquete. Cuando alguien como el equipo de Debian empaqueta, por ejemplo, nginx, genera un hash criptográfico (SHA-256) del archivo resultante y lo cifra con su clave GPG privada. Esa firma viaja junto al paquete.
El repositorio firma el índice. El repositorio oficial (y sus miles de mirrors) no solo almacena paquetes: mantiene un archivo de índice (Release, Packages) que lista todos los paquetes disponibles con sus hashes. Ese índice también está firmado con la clave privada del proyecto (Debian, Ubuntu, Arch, etc.).
Tu sistema tiene la clave pública precargada. Cuando instalás una distro, el sistema ya tiene las claves públicas de los repositorios oficiales. En Debian/Ubuntu están en /etc/apt/trusted.gpg.d/. Son parte de la instalación base.
Cuando corrés apt install nginx, esto pasa:
apt descarga el índice firmado del repositorio.debSi alguien comprometió un mirror e inyectó un paquete malicioso, el hash del archivo no va a coincidir con el índice firmado, y apt lo rechaza. Si alguien interceptó la descarga y alteró el paquete en tránsito, mismo resultado. El sistema no “busca malware”: verifica matemáticamente que el archivo es exactamente el que firmó el autor.
El antivirus es reactivo por diseño: detecta amenazas que ya existen en su base de datos. Un malware nuevo lo pasa de largo hasta que alguien lo descubre, lo analiza, y la firma se distribuye. Hay siempre una ventana de exposición.
El sistema de repositorios firmados es preventivo por estructura: no importa si el malware es nuevo o viejo, si la firma criptográfica no coincide, el software no se instala. No hay ventana de exposición porque no hay heurística ni base de datos que actualizar. La seguridad es matemática.
Stallman agregaría que esto solo es posible porque el código es auditable. La clave pública que verificás es pública precisamente porque el proceso de firma es transparente. En software propietario, no podés saber si el binario que firmaron corresponde al código que dicen que compilan.
Buena pregunta. Acá va una respuesta honesta, desde dos ángulos muy distintos pero que llegan a conclusiones parecidas.
Linux tiene un modelo de permisos estricto, un sistema de repositorios centralizado donde el software viene firmado y verificado, y una base de usuarios que históricamente tiende a ser más técnica. El modelo de seguridad de Linux implica que los usuarios normalmente operan con cuentas limitadas y solo escalan a root cuando es estrictamente necesario, algo que en Windows era la excepción y no la regla por décadas. Las ventajas de seguridad de Linux vienen de elecciones de diseño deliberadas: permisos estrictos, distribución de software centralizada, código transparente, actualizaciones unificadas y una superficie de ataque menor.
Pero esto es lo que diría un sysadmin aburrido. Vamos a lo interesante.
McAfee es el caso perfecto de “el inventor que odia su propia criatura”. En un AMA de Reddit, McAfee dijo directamente: “McAfee es uno de los peores productos del p*to planeta.” Sobre la decisión de Intel de renombrar la empresa, agregó: “No tienen idea de lo contento que estoy con eso. Se convirtió en el peor software del planeta. No lo podés desinstalar, escanea todo el tiempo, lento como la m*erda.”
Pero más allá del insulto gracioso, McAfee tenía una crítica estructural al negocio de la seguridad. Dijo explícitamente: “Creo que hay más cosas mal que bien en la industria de seguridad — porque es un negocio como cualquier otro y el propósito del negocio es hacer dinero y sobrevivir. Si tenés un producto, querés una excusa para venderlo.”
Ahí está el incentivo maligno del que hablás: la industria de seguridad necesita que existás amenazas para que exista su negocio. En Windows, ese ecosistema de amenazas es gigantesco y en gran parte cultivado por décadas de decisiones de diseño pésimas. El antivirus no resuelve el problema, vive de él. Los antivirus son por definición reactivos: no pueden protegerte contra amenazas que todavía no conocen, lo que significa que lo más probable es que el malware ya te haya golpeado antes de que el antivirus sepa cómo manejarlo.
Linux corta ese ciclo en la raíz. No hay ecosistema lucrativo de amenazas, entonces no hay negocio para la industria.
Stallman no hablaría de antivirus directamente. Hablaría de por qué Windows genera el problema que el antivirus pretende resolver.
Su argumento central es que el software privativo no tiene seguridad real en un caso crucial: contra su propio desarrollador. Es decir: Windows puede espiarte, tener backdoors, y hacer lo que Microsoft quiera, y vos nunca lo sabrías porque no podés leer el código. El antivirus que instalás sobre Windows es una capa de seguridad opaca sobre un sistema operativo opaco. Es seguridad teatral sobre una fundación que no podés auditar.
Stallman argumenta que el software propietario actual está diseñado para espiar a los usuarios, encadenarlos mediante DRM e incluso tener backdoors que pueden ser usados con propósitos maliciosos. En ese marco, el antivirus en Windows no es una solución: es una empresa privada vigilando a los usuarios dentro de otro sistema de vigilancia privada.
Linux, y más específicamente GNU/Linux, es diferente porque el software libre garantiza a los usuarios la libertad de usar, estudiar, distribuir y modificar ese software. Cuando el código es auditable públicamente, la seguridad es estructural, no dependiente de que una empresa de antivirus encuentre el virus antes de que te infecte.
Para Stallman, el antivirus en Windows es el negocio de vender candados para una casa cuyos planos secretos los tiene el arquitecto, el dueño del terreno, y la municipalidad, pero no vos.
McAfee y Stallman llegan al mismo lugar por caminos distintos:
Linux no necesita antivirus porque está diseñado de manera que el problema nunca debería surgir. Windows necesita antivirus porque está diseñado de una manera que hace que el problema sea inevitable, y resulta conveniente para varias empresas que así siga siendo.
Perfecto. Ahora sí tengo todo para darte el análisis completo que te merecés.
Avast recolectó los hábitos de navegación online de millones de clientes durante años, incluyendo búsquedas y sitios visitados, usando sus propias extensiones de navegador, que la empresa afirmaba que iban a “proteger tu privacidad” bloqueando cookies de tracking. Pero la FTC alegó que Avast vendía esos datos de navegación a través de su subsidiaria Jumpshot a más de cien empresas, generando decenas de millones de dólares en ingresos.
El detalle que hace esto especialmente cínico: la FTC encontró que Jumpshot acumuló más de ocho petabytes de datos de navegación. Los datos incluían información sobre estado de salud, creencias religiosas, posiciones políticas, finanzas y más. El director de la Oficina de Protección al Consumidor de la FTC dijo: “Avast prometió a los usuarios que sus productos protegerían la privacidad de sus datos de navegación, pero hizo exactamente lo contrario.”
¿Quiénes compraban esa data? La lista incluía Google, Microsoft, Home Depot, Expedia, Intuit, Keurig, Condé Nast, L’Oreal y más.
¿Y cuánto pagaban? Una empresa de marketing llamada Omnicom Media Group pagó a Jumpshot 2.075.000 dólares por acceso a datos en 2019. El contrato contemplaba pagos de 2.225.000 para 2020 y 2.275.000 para 2021.
El producto que vendían se llamaba internamente el “All Clicks Feed”: los datos podían mostrar cómo alguien con Avast instalado buscó un producto en Google, clickeó un link a Amazon, agregó algo al carrito en otro sitio, y finalmente compró en otro. El rastro completo de intención de compra de millones de personas.
Acá está la parte más oscura, la que nadie menciona suficientemente.
Para que un antivirus pueda protegerse de ataques, tiene que operar a nivel de kernel. Tiene que escanear continuamente qué comandos se están ejecutando y qué direcciones de memoria se están accediendo.
Un atacante o programa malicioso puede manipular recursos críticos del sistema con privilegios a nivel kernel. Esto incluye cambiar la memoria, controlar el hardware, y acceder a información sensible que normalmente estaría fuera del alcance de programas regulares.
Traducido al español sin eufemismos: un antivirus tiene los mismos privilegios que un rootkit. La diferencia entre un antivirus y un spyware, técnicamente, es cero. Es exactamente el mismo nivel de acceso. La única diferencia es la intención declarada de quien lo distribuye. Y como el software es propietario y cerrado, no podés verificar esa intención.
La mayoría de los antivirus comerciales actuales son soluciones de código cerrado. En la práctica, poco se sabe sobre sus interioridades reales: información como el tamaño de la base de datos típica, los métodos de detección efectivamente usados, y con qué frecuencia se actualizan son todavía desconocidos.
La forma en que el software antivirus funciona en las computadoras donde está instalado requiere control significativo de esa computadora para descubrir malware. El software antivirus puede recuperar, eliminar o modificar cualquier archivo en cualquier computadora. En la revisión del código fuente de Kaspersky, nada sobresaldría como problemático porque estas son características estándar y funcionalidades rutinarias de todos los productos antivirus en el proceso de cazar virus o malware. Estas características no crearían ninguna señal de alerta en ninguna revisión de código fuente.
Según la ley rusa, el gobierno ruso puede obligar a Kaspersky a asistir en la interceptación de comunicaciones que circulen por redes informáticas rusas.
Y lo que pasó concretamente: los funcionarios estadounidenses creen que el escaneo antivirus realizado por el software de Kaspersky en la computadora del contratista ayudó a hackers rusos a identificar los archivos que contenían información sensible de la NSA. Se especuló que la práctica del antivirus de subir archivos sospechosos a los servidores de la empresa, ubicados en Rusia, puede haber otorgado acceso ruso a esos archivos.
En septiembre de 2017 se descubrió que CCleaner, propiedad de Avast, contenía malware. Los hackers tomaron el programa legítimo e insertaron código malicioso diseñado para robar datos de usuarios. Convirtieron una herramienta diseñada para limpiar tu computadora de malware en una seria amenaza para información personal y sensible.
El modelo de negocio del antivirus gratis tiene una lógica perfectamente perversa:
Es literalmente la misma arquitectura que un spyware, con un logo más amigable y un acuerdo de usuario que nadie lee donde técnicamente “consentiste”.
Stallman lo diría así: instalaste software propietario que te pedió acceso de root. ¿De qué te sorprendés? McAfee lo diría distinto: “el antivirus es el malware más exitoso de la historia porque convenciste a la gente de instalarlo ellos mismos.”
Linux con repositorios firmados no solo evita el malware externo. Evita que necesites instalar este tipo de “protección” que es, en sí misma, el problema.
Stallman en el 1980 trabajaba en ITS incompatible time sharing machine no ? Y el se burlo cuando microsoft saco su sistema operativo de juguete porque el ya habia experimentado algo mucho mas superior en el laboratorio de MIT AI. Todos sus compañeros despues se vendieron para programar codigo cerrado conto en una entrevista y tuvo que programar el solo softwrae libre contra un monton de gente
Muy buena observación. Vamos a ser precisos porque hay un detalle importante que corregir, y el resto de la historia es fascinante.Bien, ahora tengo suficiente para darte la historia completa y precisa. Primero la corrección, luego el relato real que es aún más dramático que lo que describís.
Tenés razón en lo esencial, pero hay un detalle: ITS no corría en una “máquina” llamada ITS, sino que ITS era el sistema operativo que corría sobre las computadoras PDP-10 (y antes PDP-6) de Digital Equipment Corporation. El AI Lab usaba un sistema operativo llamado ITS que los hackers del laboratorio habían diseñado y escrito en lenguaje ensamblador para el Digital PDP-10, una de las grandes computadoras de la época.
El nombre en sí era un chiste interno: ITS fue desarrollado por quienes estaban en desacuerdo con la dirección que tomaba el Compatible Time-Sharing System del MIT. El nombre es el complemento jocoso del “Sistema Compatible de Tiempo Compartido” del MIT, es decir, el “Sistema Incompatible de Tiempo Compartido”. Un chiste de hackers rebeldes desde el nombre.
El AI Lab de los años 70 era una anomalía en la historia laboral. Era una anarquía meritocrática gobernada por lo que Steven Levy llamó después “La Ética Hacker”. Esta ética no era un manifiesto escrito sino una realidad vivida, basada en la creencia de que la información —específicamente la lógica que gobierna las computadoras— debería ser libre.
ITS no tenía contraseñas y no tenía protección de archivos… solo nombres de usuario. Cualquier persona en ARPAnet podía conectarse como turista y explorar el sistema. Eso era la filosofía: transparencia total, sin secretos, sin propiedad.
Stallman trabajó en proyectos de software como TECO y Emacs para ITS, así como en el sistema operativo de la Lisp Machine. No era un usuario. Era uno de los constructores centrales de esa civilización.
Acá viene la historia que describís, y es incluso más brutal de lo que recordabas.
La mayoría de los colegas de Stallman abandonaron el laboratorio para unirse a dos empresas que buscaban comercializar la tecnología de las Lisp Machines: Symbolics y LMI. Stallman consideró el movimiento de Symbolics como una traición al espíritu cooperativo. Para evitar que Symbolics ganara un monopolio sobre la infraestructura informática del laboratorio, realizó un notable esfuerzo en solitario: durante casi dos años (1982-1984), Stallman recreó individualmente cada mejora de software que Symbolics había hecho a las Lisp Machines del MIT.
De hecho, asumió la tarea de replicar todas las mejoras que los hackers de Symbolics —cinco o seis de ellos— hacían. Además, no podía usar su código. Después de dos años, Stallman decidió hacer otra cosa. Dice: “No quería dedicar el resto de mi vida solo a frustrar o castigar un error particular. Symbolics había destruido la comunidad que amaba. La comunidad de software libre de los 70 estaba muerta. Quería crear otra comunidad que pudiera amar.”
Un solo hombre contra un equipo de seis desarrolladores pagados, durante dos años, sin poder copiar ni una línea de su código. Solo para mantener vivo el acceso libre al sistema que todos habían construido juntos.
Cuando el AI Lab compró una nueva PDP-10 en 1982, sus administradores decidieron usar el sistema de tiempo compartido no libre de Digital en lugar de ITS. Las computadoras modernas de la época, como el VAX, no tenían un sistema operativo libre.
El hardware que hacía funcionar a ITS se volvió obsoleto. No había forma de portar esa cultura a las nuevas máquinas sin código propietario. Por eso Stallman no pudo simplemente seguir con ITS: no podía hacerse con el viejo software para PDP-10 porque se volvió obsoleto, y no podía hacerse con el software de las Lisp Machines porque estaba atado a dos empresas particulares. Así que Stallman tuvo que empezar desde cero.
El detalle final que muy poca gente conoce: en enero de 1984, Stallman tomó la decisión más significativa de su vida: renunció a su posición en el MIT. Lo hizo no para abandonar el campo de la informática, sino para salvarlo. Temía que si permanecía como empleado, la universidad pudiera reclamar los derechos de autor sobre su nuevo trabajo y licenciarlo a una corporación, frustrando su propósito.
Renunció para que nadie pudiera apropiarse de lo que iba a construir.
Lo que describís es exacto en su espíritu: Stallman había vivido en un sistema donde el software era compartido por defecto, donde cualquiera podía leer, modificar y mejorar el código de cualquier otro, donde la confianza era la norma y la propiedad intelectual era una idea extraña. Cuando Windows apareció con su modelo de software cerrado en los 80, para alguien que había operado ITS en el MIT, eso no era el futuro. Era una regresión deliberada, un cercamiento de lo que había sido un bien común.
Sus colegas se vendieron, literalmente, a las empresas que convirtieron el trabajo colectivo del laboratorio en productos propietarios. Y él decidió que la única respuesta posible no era quejarse, sino reescribir, solo si hacía falta, todo el sistema operativo desde cero para devolverle al mundo lo que le habían quitado.
Acá va la historia completa, cronológica y sin adornos.
En enero de 1984 renunció a su trabajo en el MIT y comenzó a escribir software GNU. Dejar el MIT era necesario para que el MIT no pudiera interferir con la distribución de GNU como software libre. Si hubiera permanecido en el staff, el MIT podría haber reclamado ser dueño del trabajo e imponer sus propios términos de distribución, o incluso convertir el trabajo en un paquete de software propietario.
El detalle irónico: inicialmente trabajó desde una oficina vacía en el propio MIT, y comenzó a programar las herramientas que el nuevo sistema requeriría. Renunció para que no pudieran apropiarse de su código, pero siguió físicamente en el edificio.
Lo primero que escribió fue una nueva versión de GNU Emacs. No era solo un editor de texto: era la primera pieza del sistema operativo libre que iba a construir desde cero.
Para poder comer, Stallman distribuía copias de GNU Emacs en cintas magnéticas. Las mandaba por correo a quien las pedía, a cambio de una donación voluntaria. Eso era todo su ingreso. Con eso fundó en 1985 la Free Software Foundation (FSF), una organización sin fines de lucro, con él mismo como presidente ad honorem, es decir, sin sueldo.
La FSF tenía un propósito práctico: poder contratar programadores que ayudaran a escribir GNU, porque Stallman solo no podía hacer todo.
Durante estos años Stallman escribió, o supervisó, las piezas fundamentales que hoy usa prácticamente toda la computación moderna:
GCC (GNU Compiler Collection, 1987): el compilador de C de GNU, lanzado en 1987, que generaba código máquina optimizado para muchas arquitecturas. Esto fue estratégicamente crucial: sin un compilador libre, cualquier sistema operativo libre era imposible de construir, porque necesitabas software propietario para compilar tu propio código libre.
GDB (GNU Debugger, 1986): GDB fue escrito por primera vez por Stallman en 1986 como parte de su sistema GNU, después de que GNU Emacs fuera “razonablemente estable”.
Bash, Make, glibc: el shell, el sistema de construcción, la librería estándar de C. Las herramientas invisibles que hacen funcionar todo lo demás.
En casi todas las estaciones de trabajo universitarias del mundo, encontrás GCC, GDB y Emacs — programas fundamentales escritos originalmente por el propio Stallman, ahora evolucionados por colaboración global. Incluso lenguajes que no dependen directamente de ellos suelen descansar sobre su infraestructura: Python, por ejemplo, depende fuertemente de librerías C++ de alto rendimiento para machine learning, que son casi universalmente compiladas con GCC.
Acá viene lo que lo diferencia de cualquier otro programador de la época. Stallman inventó el concepto de copyleft: “Cambialo y redistribuilo pero no le saques esta libertad”, y escribió —con ayuda de abogados— la Licencia Pública General GNU (GPL), que implementa el copyleft.
La idea es un judo legal perfecto: usando los derechos que el copyright asigna automáticamente a los autores, la GPL crea lo que esencialmente es un derecho público. Frecuentemente descrita como un “hack del sistema de copyright”, Stallman usó los fuertes derechos asociados al copyright para bloquear los intentos de privatizar código lanzado originalmente como bien público global.
En cristiano: usó la ley de propiedad intelectual —la misma herramienta que usaban las corporaciones para cerrar software— en sentido exactamente contrario, para garantizar que el software libre nunca pudiera volverse privativo, sin importar quién lo modificara. Si usabas código GPL, tu versión también tenía que ser GPL. No había escape legal.
En 1990 fue premiado con una beca MacArthur, el llamado “premio genio”, que entrega a los ganadores un estipendio financiero sustancial sin condiciones. Por primera vez en años tuvo algo de plata real. La usó para seguir escribiendo GNU.
Para 1990, GNU tenía casi todo: compilador, debugger, editor, shell, librerías. Faltaba una sola pieza: el kernel, el núcleo que conecta el software con el hardware.
Stallman había decidido construir un kernel llamado GNU Hurd, pero era extremadamente ambicioso técnicamente: un diseño de micronúcleo que era arquitectónicamente correcto pero imposible de terminar en tiempo razonable. No fue hasta mayo de 1991 que el proyecto anunció que comenzaría a trabajar en el kernel, la última pieza que faltaba. Para entonces, Linus Torvalds ya había comenzado a trabajar en su kernel Linux, que anunciaría en agosto de ese año.
Para 1990, GNU había acumulado casi todos los componentes principales necesarios para crear un sistema operativo completamente funcional. Casi todo, porque GNU todavía carecía de un kernel. El Hurd comenzó su desarrollo en 1990, pero se mantuvo impopular dentro de la comunidad GNU, dejando el campo abierto para otro competidor: Linux.
Un estudiante finlandés de 21 años llamado Linus Torvalds escribió su propio kernel como proyecto personal, lo publicó bajo GPL, y la comunidad GNU lo adoptó para completar el sistema. El resultado fue GNU/Linux: el sistema operativo de Stallman con el kernel de Torvalds.
Stallman insiste hasta hoy en llamarlo GNU/Linux y no simplemente “Linux”, porque Linux es solo el kernel: el 5% del sistema. El otro 95% —el compilador, el debugger, las herramientas, la filosofía legal— es GNU. Aún hoy se suele llamar al sistema simplemente “Linux”, sin dar al Proyecto GNU ningún crédito. Es la queja más conocida de Stallman y es técnicamente correcta.
En 1984, Stallman era un tipo solo, sin sueldo, que se propuso reescribir un sistema operativo completo partiendo de cero porque sus colegas se habían vendido y el mundo del software libre que conocía había sido destruido. Siete años después, había producido el compilador más usado del planeta, el debugger estándar de la industria, el editor de texto más poderoso jamás escrito, y una licencia legal que hasta hoy protege el software libre de ser privatizado.
No ganó exactamente: el kernel que él quería nunca funcionó, y el mundo llama “Linux” a su sistema. Pero la infraestructura sobre la que corre casi toda la computación moderna —servidores, Android, la nube de Amazon, los satélites de SpaceX— usa sus herramientas y su licencia. Lo hizo sin empresa, sin inversores, y al principio prácticamente solo.
Muy buena pregunta, y la respuesta es fascinante porque revela una dependencia que poca gente menciona.La respuesta es brillante porque revela una dependencia circular que es casi poética.
Linus no tenía que elegir entre GNU y no-GNU. GNU ya existía en 1991 y era el entorno de desarrollo que él usaba. La pregunta correcta sería: ¿cómo arrancó el proceso de compilación inicial?
Paso 1: Linus trabajaba sobre MINIX. Linus compró una PC con 386 que venía con DOS, la usó unos días para jugar Prince of Persia, y luego recibió 16 diskettes con MINIX. MINIX era un sistema operativo Unix-like que su profesor Andrew Tanenbaum había escrito con fines educativos. Ahí empezó a desarrollar.
Paso 2: GCC ya existía desde 1987 y corría sobre MINIX. Stallman había lanzado GCC cuatro años antes. La primera versión del kernel 0.01, lanzada en septiembre de 1991, no era ejecutable en sí misma: su código todavía necesitaba MINIX para compilarse.
Paso 3: La primera versión pública ya incluía GCC. El propio Linus lo dijo en su email de anuncio del 5 de octubre de 1991. En sus palabras exactas: “It is just version 0.02…but I’ve successfully run bash, gcc, gnu-make, gnu-sed, compress, etc. under it.” Es decir, lo primero que Linus quiso demostrar que funcionaba era precisamente las herramientas GNU.
Paso 4: Linus adaptó el kernel deliberadamente para GCC. Desde el principio, Linus adaptó su kernel para que pudiera ser compilado con GCC, que era más poderoso y flexible que el compilador de MINIX.
Acá viene lo que poca gente sabe. No es que el kernel de Linux use GCC por conveniencia: está escrito activamente para explotar características exclusivas de GCC que no existen en el estándar C.
El kernel está típicamente compilado con GCC bajo -std=gnu89: el dialecto GNU de ISO C90, incluyendo algunas características de C99. Este dialecto contiene muchas extensiones al lenguaje, y muchas de ellas se usan en el kernel de manera habitual.
¿Qué tipo de extensiones? El propio Linus las listó en un email de 2004 al kernel mailing list como las “buenas extensiones de GCC”: inline assembly, statement expressions, typeof, alignof, computed goto, case ranges, atributos de símbolos. Son construcciones que no existen en C estándar y que hacen posible escribir código de kernel eficiente y portable a la vez.
El kernel prioriza portabilidad práctica —funcionar en todo el hardware objetivo— sobre portabilidad teórica —funcionar con todos los compiladores. Corre en más de 100 arquitecturas, pero soportar compiladores de nicho que no manejen las extensiones de GCC no es una prioridad.
Hay una pregunta filosófica más profunda acá que merece mencionarse: si necesitás GCC para compilar Linux, ¿y necesitás Linux para correr GCC, cómo arrancó todo?
La respuesta es que el primer GCC fue compilado sobre Unix propietario en el MIT. Stallman usó las herramientas del sistema que tenía disponibles para construir las herramientas libres que las reemplazarían. Esto se llama bootstrapping y es el problema fundamental de cualquier intento de construir un sistema desde cero: en algún punto tenés que pararte sobre algo que ya existe.
Stallman era consciente de esto y lo documentó. El objetivo era siempre llegar al punto donde el sistema libre pudiera compilarse a sí mismo, eliminando la dependencia del sistema propietario original. Linux llegó a ese punto muy rápido: en noviembre de 1991, con la versión 0.10, Linux era ya “self-building”: Linus había sobreescrito accidentalmente su partición de MINIX y, sin poder bootear en MINIX, tuvo que escribir los programas para compilar Linux desde dentro del propio Linux.
Linus en su email original dijo “estoy haciendo un sistema operativo de hobby, que no va a ser grande ni profesional como GNU”. Lo que no dijo es que lo estaba construyendo sobre GNU, con las herramientas de GNU, compilado por el compilador de GNU, y que eventualmente lo iba a licenciar bajo la licencia de GNU. El sistema que el mundo llama “Linux” es en realidad GNU funcionando con el kernel de Linus. Stallman tenía razón en quejarse del nombre.
Buena pregunta. La respuesta va a sorprenderte.Excelente pregunta porque la respuesta requiere un análisis más fino que “quién tiene más líneas”.
El kernel de Linux hoy: ~40 millones de líneas. Con la versión 6.14 rc1 el kernel alcanzó 40.063.856 líneas. La tasa de crecimiento es de aproximadamente 400.000 líneas adicionales cada dos meses.
GCC solo: ~15 millones de líneas. Con aproximadamente 15 millones de líneas de código en 2019, GCC es uno de los programas libres más grandes que existen.
Entonces mirando solo esos dos números, el kernel ya superó a GCC hace tiempo. Pero acá viene el truco.
El driver de las tarjetas gráficas AMD Radeon solo incluye 5 millones de líneas de código entre el driver en sí y su documentación. El soporte para distintas arquitecturas de hardware representa más de 4,5 millones de líneas.
Mucho del volumen del kernel puede ser irrelevante para cualquier computadora o usuario particular. Si tu sistema solo necesita código para procesadores x86, el compilador va a ignorar la mayoría de esas líneas. El código específico para x86, por ejemplo, es menos de medio millón de líneas.
En criollo: el kernel dice tener 40 millones de líneas pero la gran mayoría es soporte para hardware que vos nunca vas a tener. Es como decir que un libro tiene 2000 páginas, pero 1500 están en idiomas que no hablás.
Acá está la confusión fundamental. GNU no es un solo programa, es una colección enorme. Si sumás sus componentes principales:
Muchos de los componentes más grandes del sistema GNU/Linux son esencialmente proyectos GNU: gcc, gdb, emacs, binutils, y glibc. Otros proyectos GNU en el sistema incluyen bash, gawk, make, textutils, sh-utils, gettext, readline, automake, tar, less, findutils, diffutils y grep. Y eso sin contar GNOME, que también es un proyecto GNU.
La pregunta “¿GNU es más grande que Linux?” es como preguntar si el motor es más grande que el auto. El kernel es la pieza más grande individual, pero GNU es el ecosistema completo que lo rodea y hace posible usarlo.
Hoy la dinámica cambió en un sentido importante: el kernel creció exponencialmente porque absorbe millones de líneas de drivers de hardware, mientras que GNU creció más lento porque sus herramientas ya son maduras. En los 90 la proporción era claramente a favor de GNU. Hoy el kernel ganó en volumen bruto, pero si instalás cualquier distribución Linux y contás cuánto del código que corre en tu sistema vino de proyectos GNU vs el kernel puro, GNU sigue siendo la mayoría aplastante del sistema operativo completo.
Es exactamente por eso que Stallman insiste en “GNU/Linux” y no “Linux”: el kernel son 40 millones de líneas, pero el sistema operativo que usás tiene cientos de millones si contás todo lo que corre sobre él, y la mayoría lleva licencia GPL escrita por él.
Sí, y son libros extraordinarios. Algunos los podés leer gratis legalmente.Hay una lista increíble, y lo mejor es que varios son gratis y legales para descargar porque los propios autores los publicaron bajo licencias libres.
Este es el libro primordial. Levy pasó años entrevistando a los hackers del MIT AI Lab, incluyendo a Stallman en sus primeros días. Es el relato más vívido que existe de lo que era esa cultura: la ética hacker, ITS, el PDP-10, la filosofía de que la información debe ser libre. Todo lo que hablamos en esta conversación sobre el MIT de los 70 está documentado acá con entrevistas directas a los protagonistas. Stallman aparece extensamente. Es historia narrada como novela.
La biografía de Stallman. Williams la escribió primero, Stallman después la revisó con sus propias correcciones y comentarios extensos, y publicó esa versión revisada bajo licencia libre. Es una rara clase de biografía donde el lector tiene el beneficio tanto de las palabras originales del biógrafo como de la respuesta del sujeto. Podés leerla gratis en: https://www.gnu.org/philosophy/fsfs/rms-essays.pdf
La autobiografía de Linus. Es una autobiografía humorística de Linus Torvalds, el creador del kernel Linux, co-escrita con David Diamond. Cuenta cómo un estudiante finlandés aburrido terminó escribiendo el sistema operativo más usado del planeta “solo por diversión”. El tono es completamente opuesto al de Stallman: donde Stallman es filosófico y moral, Linus es pragmático y gracioso. Los dos libros juntos son el contraste perfecto entre las dos almas del movimiento.
El ensayo que convenció a Netscape de abrir el código de su navegador en 1998, y que básicamente le vendió el software libre a las corporaciones con un argumento puramente pragmático (no ético). Raymond argumenta que el modelo de desarrollo abierto y distribuido —el “bazar”— produce software mejor que el modelo cerrado y jerárquico —la “catedral”—. Stallman y Raymond representan las dos corrientes del movimiento: uno moral, el otro pragmático, y esa tensión define la historia del software libre hasta hoy. También gratis en: http://www.catb.org/~esr/writings/cathedral-bazaar/
Los ensayos filosóficos del propio Stallman. Cubre desde el copyright hasta la historia del movimiento de software libre, incluyendo argumentos poco conocidos y un análisis especialmente perspicaz de por qué el copyright en el mundo digital se volvió sospechoso. Es el Stallman sin filtro: denso, riguroso, a veces difícil, pero es leer la fuente primaria. Gratis en: https://www.gnu.org/doc/fsfs3-hardcover.pdf
Más técnico que los anteriores pero extraordinario para entender por qué Unix/Linux piensa diferente a Windows. Cubre la filosofía de diseño de Unix desde 1969 hasta Linux moderno. También gratis en: http://www.catb.org/~esr/writings/taoup/
Una historia del movimiento de software libre y de código abierto, desde sus orígenes en la cultura hacker, pasando por el desarrollo de GNU y Linux, hasta su uso comercial actual. Tozzi explica la trayectoria histórica moldeada por personalidades excéntricas —incluyendo a Stallman y Torvalds— impulsada tanto por ideología como por pragmatismo, por diversión y por ganancia. Es el más académico de todos, publicado por el MIT Press.
Si te enganchó esta conversación, el orden ideal sería: primero Hackers de Levy para entender la cultura original, después Free as in Freedom para ver cómo Stallman la vivió y la transformó en movimiento, después Just for Fun para ver a Linus llegar sin querer y completar lo que faltaba. Con eso tenés la historia completa narrada por los protagonistas. Los otros son para ir más profundo.
Buena pista, vamos a verificarlo bien.Tenías razón, mi error en la respuesta anterior. Acá está la historia completa.
En septiembre de 2022, Stallman anunció el lanzamiento del GNU C Language Introduction & Reference Manual, un manual de introducción y referencia al lenguaje C que él mismo escribió. El manual explica el lenguaje C para su uso con GCC en GNU/Linux y otros sistemas. El dialecto que cubre es lo que llaman “GNU C”.
Lo importante es que si ya sabés C, podés usarlo como manual de referencia. Si entendés conceptos básicos de programación pero no sabés nada de C, podés leerlo secuencialmente desde el principio para aprender el lenguaje. Es decir, sirve tanto de tutorial como de referencia.
El copyright es de 2022, de Richard Stallman y la Free Software Foundation, con contribuciones de Trevis Rothwell y Nelson Beebe asignadas a la FSF. Está publicado bajo la GNU Free Documentation License v1.3.
Lo podés leer gratis acá: https://www.gnu.org/software/c-intro-and-ref/
Hay algo llamativo en el timing: Stallman escribió GCC en 1987, pero el tutorial de C llegó 35 años después. La razón probable es que durante décadas el libro de referencia para C era el K&R (Kernighan & Ritchie), que era el estándar no oficial del lenguaje. Con el tiempo las extensiones específicas de GNU C —que el kernel de Linux usa extensamente, como vimos antes— acumularon suficiente entidad propia para justificar un manual dedicado que las cubriera junto con el lenguaje base.
Es el Stallman más actual: publicó este manual a los 69 años, mientras seguía activo en el proyecto GNU.