El popular cliente de intercambio de archivos P2P ha dado a conocer el lanzamiento oficial de «qBittorrent 5.2.0», una nueva versión que no solo se centra en la estabilidad , sino que introduce mejoras en la capacidad de personalización visual. Los desarrolladores han escuchado a la comunidad, implementando desde controles mejorados para el rendimiento hasta la posibilidad de adaptar la paleta de colores y el estilo de la interfaz de manera uniforme en todas las plataformas soportadas. Más allá de la estética, esta actualización interviene directamente en los motores de búsqueda, la gestión de fuentes RSS y la administración remota a través de una interfaz web fuertemente modernizada.

Con la eliminación de dependencias obsoletas, como el soporte para la compilación con Qt 6.5, el proyecto asegura un código más limpio y preparado para el futuro. Todo esto convierte a esta iteración en una herramienta mucho más robusta, eficiente y adaptada a los exigentes flujos de trabajo de los usuarios avanzados.

Principales novedades de qBittorrent 5.2.0

La experiencia de usuario recibe mejoras al incorporar un sistema de tematización que permite personalizar los colores de los paneles de progreso y el mapa de bloques de descarga. Para facilitar la lectura rápida, se ha añadido una opción que vincula el color de la barra de progreso directamente con el estado actual del torrent, aunque los usuarios más conservadores disponen de un interruptor para desactivar por completo esta indicación.

La barra de herramientas también experimenta mejoras: los botones para añadir archivos y enlaces han intercambiado posiciones, y se ha introducido un nuevo icono con forma de paleta para acceder instantáneamente a la interfaz de creación de torrents. Adicionalmente, la barra de estado ahora muestra información crítica en tiempo real, indicando el espacio libre disponible en el dispositivo de almacenamiento. En cuanto a la gestión de datos y metadatos, el programa ahora permite copiar las rutas del contenido de los torrents seleccionados y transferir sus comentarios directamente a aplicaciones externas.

Rendimiento asíncrono y control de categorías

Bajo el capó, el motor de descargas ha optimizado sus procesos computacionales más pesados, destacando que el cálculo de los bloques de los archivos torrent ahora se ejecuta en modo asíncrono para evitar bloqueos en la interfaz. El sistema de reanudación también ha sido mejorado mediante la optimización de la cola de carga, reduciendo drásticamente el tiempo necesario para reactivar descargas pausadas al evitar la copia redundante de datos.

A nivel de organización de ficheros, las restricciones previas en las subcategorías han sido eliminadas, permitiendo su uso incondicional y habilitando la configuración de límites de subida de forma individual para cada una de ellas. Como medida de seguridad organizativa, si un administrador elimina una categoría, los torrents que albergaba no quedan huérfanos, sino que son trasladados automáticamente a su categoría principal.

Además, se ha incorporado una función de automatización del sistema que permite reiniciar el equipo automáticamente una vez que todas las descargas activas han finalizado.

Evolución de la interfaz web, RSS y búsquedas

La administración remota mediante la interfaz web ha sido reescrita para incluir herramientas de grado profesional, destacando el soporte para crear nuevos torrents directamente desde el navegador y la autenticación segura mediante claves API y credenciales básicas. Esta plataforma de control web reemplaza los antiguos iconos GIF por imágenes vectoriales SVG de alta calidad, permite el desplazamiento horizontal por pestañas y estrena una experiencia de usuario totalmente nueva para la adición de archivos y el filtrado de rastreadores por estado. En el ámbito de la automatización de contenidos, el lector RSS otorga un control absoluto al permitir personalizar el tiempo de actualización de forma independiente para cada fuente seleccionada e implementar filtros mediante el uso de máscaras o cadenas simples.

Por su parte, el motor de búsqueda integrado recibio mejoras de conexión y precisión al añadir soporte nativo para proxies SOCKS4 y SOCKS4a, junto con opciones de filtrado de resultados de búsqueda mucho más avanzadas.

Ajustes específicos por sistema operativo y limpieza de código

Los usuarios de Windows se benefician de una herramienta de creación de torrents que ahora comprende y permite el uso de enlaces simbólicos, mientras que los usarios de Linux, se ha decidido eliminar la antigua opción que limitaba el consumo de memoria RAM, confiando esta gestión puramente a los mecanismos modernos del núcleo del sistema operativo.

Mientras tanto, la versión de macOS recibe una lluvia de correcciones que solucionan bloqueos críticos al eliminar archivos o al cerrar la aplicación debido a interbloqueos de accesibilidad, junto con nuevos menús en la barra de estado para visualizar métricas de velocidad de subida y bajada.

Finalmente, si estas interesado en poder conocer mas al respecto, puedes consultar los detalles en el siguiente enlace.

¿Cómo instalar qBittorrent en Ubuntu y derivados?

Para quienes deseen instalar la nueva versión de qBittorrent, pueden seguir las instrucciones que detallamos a continuación.

En las distribuciones basadas en Ubuntu (como Linux Mint, Kubuntu, Zorin OS, Elementary, entre otras), la aplicación se encuentra disponible en los repositorios oficiales. Sin embargo, también existe un repositorio que ofrece actualizaciones más rápidas.

Para agregar este repositorio y obtener las versiones más recientes, abre una terminal (puedes hacerlo usando la combinación de teclas Ctrl + Alt + T) y ejecuta los siguientes comandos:

sudo add-apt-repository ppa:qbittorrent-team/qbittorrent-stable -y

Después proseguimos a instalar la aplicación:

sudo apt-get install qbittorrent

Desinstalar qBittorrent

Para eliminar qBittorrent simplemente tenemos que ejecutar los siguientes comandos:

sudo add-apt-repository --remove ppa:qbittorrent-team/qbittorrent-stable

sudo apt remove --autoremove qbittorrent

Hace ya algunos dias los desarrolladores del proyecto Zorin OS (conocido por ofrecer una de las transiciones más amigables para los usuarios que migran desde Windows) dieron a conocer el lanzamiento oficial de su versión 18.1.

Construida sobre la base de Ubuntu 24.04, esta actualización de medio ciclo llega apenas seis meses después de la version principal (18.0) para refinar la experiencia de usuario y ampliar masivamente su soporte de hardware. Lejos de conformarse con ajustes esteticos, esta entrega mejora la gestión de ventanas, potencia el ecosistema ofimático y resucita la esperada edición «Lite», diseñada específicamente para inyectar vida a equipos con recursos limitados.

Principales novedades de Zorin OS 18.1

La gran estrella de esta actualización es la mejora en el modo de mosaico de ventanas (Advanced Window Tiling), una característica diseñada para organizar el área de trabajo sin depender de atajos de teclado complejos. Ahora, al hacer clic en una aplicación acoplada desde la barra de tareas, el sistema trae automáticamente al primer plano todas las ventanas que conforman ese diseño de mosaico específico.

Además, se ha incorporado una herramienta visual para reordenar estos diseños directamente desde el cuadro de configuración, y se ha optimizado el acoplamiento a los bordes de la pantalla para que las ventanas respeten los diseños personalizados en lugar de limitarse a divisiones de media pantalla o cuartos.

Otra de las mejoras que presenta la nueva version es la ampliacion de la base de datos integrada, encargada de detectar instaladores .exe de Windows. Y es que ahora ha sido ampliada en un 40%, reconociendo ahora más de 240 aplicaciones populares. Si un usuario intenta instalar un programa como Plex desde su archivo ejecutable original, Zorin OS intercepta la acción y muestra un cuadro de diálogo sugiriendo la descarga de la versión nativa de Linux directamente desde la tienda de software. En el caso de aplicaciones exclusivas de Windows, el sistema recomendará alternativa, como Evolution Mail en sustitución de Microsoft Outlook.

El regreso triunfal de la edición Lite con XFCE 4.20

Para los usuarios con hardware modesto o portátiles antiguos, la gran noticia es el restablecimiento de la edición «Lite». Esta versión ligera abandona los entornos pesados para abrazar XFCE 4.20, garantizando fluidez sin sacrificar la estética. El administrador de archivos ha sido rediseñado hacia una interfaz mucho más compacta, ideal para pantallas de baja resolución. A pesar de su enfoque en el bajo consumo, la edición Lite estrena soporte nativo para lectores de huellas dactilares, permitiendo la autenticación biométrica desde el panel de ajustes.

El apartado visual también se ha renovado con temas de escritorio redondeados, paletas de colores de alto contraste para facilitar la lectura y la adición de los colores amarillo y marrón en la aplicación Zorin Appearance.

Soporte extendido, núcleo 6.17 y LibreOffice 26.2

Zorin OS 18.1 integra LibreOffice 26.2, la última versión de la suite ofimática que presume de una compatibilidad muy superior con los formatos cerrados de Microsoft Office 365, soporte nativo para Markdown y mejoras de rendimiento al gestionar hojas de cálculo complejas. El entorno general del escritorio ha recibido correcciones de errores que se traducen en una navegación más rápida y fluida, complementadas con detalles de usabilidad como la capacidad de desactivar los iconos de estado de las aplicaciones en la bandeja del panel o la correcta visualización de texto de derecha a izquierda para idiomas como el árabe o el hebreo.

Por la parte del corazon del sistema, esta nueva version a optato por la adopción del kernel Linux 6.17. Este nuevo núcleo expande enormemente el soporte de hardware, integrando controladores actualizados para las recientes tarjetas gráficas NVIDIA, soporte para gráficos Intel Xe3 y una gestión mejorada para arquitecturas híbridas con GPU AMD.

La lista de periféricos ahora abarca sin problemas desde controladores de juego como el PlayStation 5 DualSense hasta consolas portátiles modernas como la ASUS ROG Ally y dispositivos Apple como el Magic Mouse 2. Con todo esto, Zorin OS 18.1 asegura soporte continuo y parches de seguridad garantizados hasta junio de 2029, consolidándose como una opción a considerar.

Finalmente, si estás interesado en poder conocer más al respecto, puedes consultar los detalles en el siguiente enlace.

Descargar y obtener Zorin OS 18.1

Para los interesados en esta nueva versión, deben de saber que soló, tienen que dirigirse a la página web oficial de la distribución y en su sección de descargas podrán obtener la imagen del sistema. Las imágenes del sistema tienen un tamaño de 4 a 8GB y el enlace para poder descargar el sistema es este

La infraestructura pública de Canonical y los servicios de Ubuntu, una de las distribuciones de Linux más extendidas a nivel global, se han visto afectados por un ataque distribuido de denegación de servicio (DDoS) que ha dejado fuera de juego durante horas componentes esenciales del ecosistema. La ofensiva ha tenido impacto directo en la capacidad de muchos usuarios y organizaciones para instalar y actualizar el sistema operativo, algo especialmente delicado en entornos empresariales y de administración pública donde Ubuntu es una pieza clave en servidores y nubes privadas.

El incidente, descrito por la propia empresa como un ataque sostenido y de alcance transfronterizo, no se ha limitado a tumbar una web corporativa: ha comprometido repositorios, APIs de seguridad, plataformas de desarrollo y servicios de autenticación. Todo ello ha puesto de manifiesto hasta qué punto la infraestructura centralizada de proyectos open source puede convertirse en un cuello de botella crítico cuando se enfrenta a ataques de gran volumen.

Un ataque DDoS prolongado que paraliza servicios críticos

Canonical reconoció públicamente el problema a través de su página de estado oficial, de su sitio web e incluso redes sociales, donde informó de que su infraestructura web estaba bajo un ataque DDoS persistente y que los equipos internos trabajaban contra reloj para recuperar la normalidad. En el momento de los primeros reportes, la caída acumulaba ya entre 15 y 20 horas de indisponibilidad en parte de los servicios, un intervalo considerable para una plataforma base utilizada de forma masiva por desarrolladores y empresas.

Para quienes no estén familiarizados con este tipo de incidentes, un ataque de denegación de servicio distribuido consiste en saturar los sistemas objetivo con grandes volúmenes de tráfico basura, procedente de miles o millones de dispositivos, hasta agotar sus recursos de red o de cómputo. Aunque se trata de una técnica considerada “clásica” frente a otros vectores más sofisticados, sigue siendo una herramienta muy eficaz para dejar fuera de servicio portales, APIs y repositorios de los que dependen infraestructuras críticas.

Repositorios, API de seguridad y portales afectados

La comunidad de desarrolladores de Ubuntu empezó a comentar los problemas en foros no oficiales y canales técnicos cuando detectaron que determinados servicios eran inaccesibles o funcionaban de forma intermitente. Entre los elementos más sensibles mencionados se encuentran la Ubuntu Security API, los repositorios de paquetes utilizados por el gestor apt, el portal principal ubuntu.com, la Snap Store, la plataforma de desarrollo Launchpad y servicios vinculados a Ubuntu Pro.

El hecho de que la API de seguridad y los repositorios se vieran comprometidos tuvo un efecto directo: muchos administradores de sistemas reportaron errores al intentar actualizar paquetes, aplicar parches de seguridad o instalar nuevas instancias del sistema. Pruebas realizadas por terceros en dispositivos con Ubuntu confirmaron que las actualizaciones fallaban mientras el ataque estaba en curso, algo que eleva el incidente muy por encima de una simple caída puntual de una página web.

En paralelo, se destacó que los administradores perdieron temporalmente el acceso a información actualizada sobre vulnerabilidades y parches, lo que complica todavía más la gestión de riesgos en entornos donde se exigen tiempos de reacción muy cortos. En empresas sujetas a normativa estricta de ciberseguridad, como NIS2, un bloqueo prolongado de estos canales puede traducirse en brechas de cumplimiento y en exposición adicional frente a otros tipos de ataques.

El grupo 313 Team se atribuye el ataque DDoS

La autoría de la ofensiva fue asumida por un grupo hacktivista que se presenta como The Islamic Cyber Resistance in Iraq 313 Team, también conocido simplemente como 313 Team. A través de su canal de Telegram, los atacantes se proclamaron responsables del derribo de la infraestructura pública de Ubuntu y Canonical, afirmando que habían dejado indisponibles servicios esenciales para millones de usuarios.

En algunos mensajes difundidos en ese canal, los atacantes fueron más allá de la reivindicación y amenazaron con prolongar el ataque si la compañía no se ponía en contacto con ellos, e incluso habrían llegado a plantear exigencias económicas. Aunque Canonical no confirmó públicamente detalles sobre posibles demandas o comunicaciones directas, la simple existencia de estas amenazas muestra hasta qué punto los DDoS se utilizan como palanca de presión y chantaje.

Beamed: el servicio DDoS por encargo detrás de la ofensiva

Uno de los puntos que más preocupa a los expertos es que, según la propia reivindicación, los atacantes no recurrieron a una botnet construida ad hoc, sino a un servicio comercial conocido como Beamed, una plataforma de DDoS por encargo. Este tipo de servicios, también llamados booters o stressers, permiten contratar capacidad de ataque como si se tratara de un servicio de suscripción más, rebajando drásticamente la barrera de entrada al cibercrimen.

Beamed asegura ser capaz de generar picos de tráfico de hasta 3,5 terabits por segundo (Tbps), una cifra que, aunque no ha sido verificada de forma independiente en este caso concreto, da una idea de la magnitud potencial de la infraestructura que se puede alquilar en el mercado negro. Para ponerlo en contexto, esa capacidad se aproxima a una fracción significativa de algunos de los mayores ataques DDoS jamás documentados por proveedores de mitigación como Cloudflare.

Al externalizar la “potencia de fuego” a estos servicios, los operadores de ataques pueden centrarse en elegir objetivos y coordinar campañas, sin necesidad de gestionar su propia red de dispositivos comprometidos. Esto acelera la profesionalización del fenómeno y complica la respuesta policial, ya que cada cierre o incautación va seguido, casi inmediatamente, por la aparición de nuevos servicios o por la migración de la infraestructura a otros dominios y jurisdicciones.

Tendencia global: el auge de los DDoS comerciales

El caso Canonical/Ubuntu encaja en una tendencia más amplia observada por empresas de ciberseguridad y organismos internacionales: el crecimiento explosivo del volumen y frecuencia de los ataques DDoS. Informes recientes de proveedores como Cloudflare, Nexusguard o Radware apuntan a decenas de millones de incidentes anuales, con incrementos de más del doble de un año para otro y picos históricos de tráfico malicioso en cuestión de segundos.

Buena parte de estos ataques se sitúan por debajo de 1 Gbps y se ejecutan en ráfagas muy cortas, diseñadas para pasar desapercibidas y desbordar mecanismos de defensa automatizados antes de que se activen. Sin embargo, episodios como el de Canonical demuestran que los atacantes también son capaces de sostener campañas más largas cuando el objetivo es visible, simbólico o estratégico, algo especialmente relevante para infraestructuras de software libre de referencia.

En los últimos años, agencias como el FBI y Europol han lanzado operaciones específicas para desmantelar redes de servicios DDoS por encargo, incautando dominios y deteniendo a algunos responsables. Pese a ello, la realidad es que el ecosistema de booters se comporta como un juego constante del gato y el ratón: por cada servicio clausurado, otros aparecen o se reorganizan, lo que mantiene vivo un mercado que alimenta ataques contra empresas, gobiernos y proyectos tecnológicos abiertos.

Impacto en empresas, startups y administraciones

Más allá del ruido mediático, el ataque a Canonical evidencia la dependencia estructural respecto a proyectos open source como Ubuntu. Muchas organizaciones públicas, universidades, centros de investigación y compañías privadas utilizan esta distribución como base de sus servidores, nubes híbridas y estaciones de trabajo de desarrollo. Cuando el proveedor central sufre un DDoS de este tipo, el efecto dominó puede sentirse en sectores muy distintos.

En el caso de las startups tecnológicas y las pymes digitales españolas, la caída de servicios como repositorios, Launchpad o la Snap Store se traduce en retrasos en despliegues, imposibilidad de aplicar parches y bloqueos en pipelines de integración continua. Esto puede afectar a contratos con clientes, acuerdos de nivel de servicio (SLA) y, en el peor de los escenarios, provocar incidentes de seguridad adicionales si los sistemas quedan sin actualizar durante demasiado tiempo.

La indisponibilidad de la infraestructura de Canonical plantea dudas adicionales sobre continuidad de negocio y cumplimiento normativo. La interrupción de la Ubuntu Security API, de los canales de parches y de la documentación oficial dificulta la gestión de vulnerabilidades, justo en un contexto en el que la presión regulatoria sobre la ciberseguridad va en aumento.

Riesgo de cadena de suministro en el ecosistema open source

El episodio también se interpreta como un recordatorio de la fragilidad de la cadena de suministro de software basada en proyectos de código abierto. Una parte enorme de la infraestructura tecnológica mundial se apoya en repositorios y servicios mantenidos por equipos relativamente reducidos. Cuando uno de estos nodos se satura o queda inoperativo, el efecto se propaga rápidamente hacia todos los productos y servicios que lo utilizan por debajo.

Casos recientes, como los ataques a repositorios de otras distribuciones Linux, han mostrado la misma debilidad: si se bloquean o comprometen los canales de actualización, las organizaciones quedan expuestas a vulnerabilidades no parcheadas y a la imposibilidad de desplegar versiones corregidas. En el escenario donde el uso de Linux en servidores públicos y privados es masivo, este tipo de incidentes se analiza ya como un riesgo sistémico más que como un problema puntual.

Como respuesta, muchos equipos técnicos en empresas y startups están empezando a implementar estrategias de resiliencia y diversificación: mirrors locales de paquetes, imágenes de contenedor preconstruidas y almacenadas en registros privados, y planes de contingencia que contemplan la caída temporal de proveedores clave. El objetivo es poder seguir operando con cierta normalidad aunque el proveedor upstream atraviese un episodio de DDoS prolongado.

Lecciones para la comunidad técnica sobre este ataque DDoS

En el entorno hispanohablante, donde abundan startups y scaleups que basan su infraestructura en Linux y servicios cloud, el incidente de Canonical sirve de toque de atención. Muchas compañías jóvenes siguen funcionando con la idea de que “a nosotros no nos van a atacar”, cuando las estadísticas muestran justo lo contrario: los ataques DDoS afectan cada vez más a empresas de todos los tamaños, y no solo a grandes corporaciones o plataformas globales.

Para los equipos técnicos, el caso subraya la importancia de contar con protecciones DDoS en capa de red y de aplicación, soluciones de DNS resilientes, sistemas de monitorización de tráfico y planes de comunicación de crisis preparados de antemano. Aunque gran parte de estas herramientas son de bajo coste o incluso open source, lo que suele faltar es la inversión de tiempo y la planificación previa para ponerlas en marcha antes de que llegue el problema.

Algunas empresas tecnológicas de referencia han reforzado de forma notable su infraestructura tras incidentes tempranos, entendiendo que la ciberseguridad no es un gasto superfluo, sino un habilitador de crecimiento y de confianza. El ataque a Canonical y Ubuntu encaja en esa narrativa: si una pieza tan central del ecosistema puede verse paralizada por un DDoS comercial, cualquier actor que construya sobre ella debe asumir la resiliencia como una prioridad.

Lo ocurrido con Canonical y Ubuntu deja claro que un ataque DDoS bien orquestado contra un proveedor crítico puede traducirse en problemas inmediatos para millones de sistemas repartidos por el mundo. La combinación de servicios DDoS por encargo, motivación ideológica y uso masivo de software libre convierte estos episodios en algo más que una anécdota técnica: son un recordatorio de que la infraestructura digital sobre la que trabajamos a diario es vulnerable y exige medidas de defensa, planificación y diversificación a la altura de su importancia.

La segunda candidata a lanzamiento de Linux 7.1-rc2 ya está disponible para pruebas y llega con un paquete considerable de correcciones repartidas por todo el núcleo. Pese al tamaño del conjunto de cambios, Linus Torvalds ha descrito esta RC como “bastante normal”, lo que refuerza la previsión de un ciclo que termine, como de costumbre, alrededor de una séptima release candidate si no surge ningún contratiempo de última hora.

En esta fase del desarrollo, el foco está puesto menos en grandes novedades visibles y más en la estabilidad del kernel y el soporte de hardware real, algo especialmente relevante para usuarios y empresas europeas que dependen de Linux en servidores, equipos de escritorio y dispositivos móviles. La combinación de arreglos en virtualización KVM, controladores gráficos y el nuevo driver NTFS apunta a pulir los detalles antes de que la versión 7.1 estable llegue a las distribuciones, incluida la gestión de actualizaciones de firmware con herramientas como gestión de actualizaciones de firmware.

Linux 7.1-rc2 grande, comportamiento normal: el papel de KVM y la IA

Uno de los aspectos que más ha llamado la atención de esta Linux 7.1-rc2 es que, en las cifras brutas, el diffstat parece inusualmente voluminoso. Torvalds ha explicado que cerca de la mitad de los cambios se concentran en los selftests de KVM, principalmente por una oleada de renombrados internos para que las pruebas sigan las mismas convenciones que el código principal del kernel, tanto en nombres de variables como de tipos.

Este tipo de limpieza no modifica el comportamiento funcional de la virtualización por sí mismo, pero sí tiene impacto en el mantenimiento a largo plazo. Al homogeneizar la estructura interna de las pruebas de KVM, los desarrolladores pueden validar mejor el comportamiento de las máquinas virtuales, algo crucial para centros de datos europeos, proveedores de nube y entornos de pruebas que confían en KVM para consolidar cargas de trabajo, al igual que proyectos de virtualización como VirtualBox 7.2.8.

Torvalds ha señalado también que se sigue observando un patrón de más parches de lo habitual, tendencia que ya se vio en Linux 7.0 y que se atribuye en buena medida al uso de herramientas de inteligencia artificial para generar o asistir en los cambios de código. Ese incremento de volumen no implica necesariamente más inestabilidad, pero sí obliga a reforzar la revisión, el fuzzing y los sistemas de prueba automatizados, algo que ya se nota en áreas como el planificador sched_ext, donde se han incorporado varias correcciones adicionales.

Nuevo controlador NTFS: estabilización antes de la versión final

Otro frente relevante de Linux 7.1 y que afecta directamente a usuarios de escritorio en España y el resto de Europa es el nuevo controlador NTFS integrado en el kernel principal. Tras años de trabajo, el desarrollador Namjae Jeon ha logrado que este driver moderno, basado en el controlador NTFS original de solo lectura pero ampliamente mejorado, sustituya al NTFS3 de Paragon y deje obsoletas soluciones en espacio de usuario como NTFS-3G.

En esta Linux 7.1-rc2 se ha incorporado una nueva tanda de correcciones para el driver NTFS, fruto tanto del aumento de uso en entornos reales como de pruebas intensivas y fuzzing sobre el código C. Entre los arreglos se incluyen la resolución de posibles fugas de memoria y referencias de página, la prevención de desreferencias de punteros nulos y la rectificación de problemas menores de codificación que podían derivar en errores difíciles de rastrear.

Concretamente, se han ajustado funciones como ntfs_index_walk_down() mediante una validación más estricta de la asignación de bloques de índice para evitar accesos inválidos; se ha solucionado una fuga de memoria relacionada con el manejo de cadenas de destino de enlaces simbólicos en rutas de error; y se han introducido controles adicionales en ntfs_mapping_pairs_decompress() para prevenir desbordamientos de VCN y posibles corrupciones en las listas de asignación (runlists).

Además, el equipo ha corregido una mala utilización de PTR_ERR() sobre punteros de folio válidos en __ntfs_bitmap_set_bits_in_run(), se ha afinado el recuento de enlaces de directorio para alias WIN32/DOS ajustando el decremento de nlink únicamente cuando el contador de la MFT llega a cero, y se ha solucionado el uso de una variable no inicializada en el mismo proceso de descompresión de mapping pairs. Aunque ninguna de estas incidencias se ha catalogado como un fallo catastrófico, su corrección mejora la fiabilidad general del controlador, algo especialmente interesante para quienes usan particiones NTFS compartidas con Windows en equipos personales o de oficina.

Estas mejoras, fusionadas en el árbol principal del kernel durante el fin de semana, forman parte ya de Linux 7.1-rc2 y servirán de base para la versión estable prevista para junio, si el calendario no sufre retrasos. Para la comunidad europea que maneja entornos mixtos Windows-Linux en empresas, centros educativos o administraciones públicas, un NTFS más robusto reduce el riesgo de corrupción de datos al alternar entre sistemas operativos.

Correcciones gráficas: AMDGPU e Intel Xe bajo la lupa

Junto al trabajo sobre NTFS y KVM, esta RC también incorpora un bloque significativo de arreglos en el subsistema gráfico DRM. El conjunto más amplio de cambios ha recaído en el controlador AMDGPU, con mejoras que abarcan desde las GPU más recientes hasta modelos más veteranos que siguen presentes en muchos equipos de usuario y profesionales.

Entre las novedades, hay numerosas correcciones para IP blocks GFX11.5.4 y otros componentes recientes, pero también ajustes que benefician a gráficas AMD de la generación GCN 1.0/1.1. Gracias al trabajo de Timur Kristóf, desarrollador vinculado a Valve, se ha habilitado de forma adecuada el soporte para configuraciones de GPU «harvested», como la Radeon HD 7870 XT (Tahiti LE) y modelos similares, que hasta ahora daban problemas con el kernel principal desde informes de hace más de una década.

Los cambios en AMDGPU incluyen además una corrección en la salida analógica de la capa DC, que se había visto afectada por una regresión, y mejoras en el soporte de conectores de pantalla integrados sin DDC, así como en la lectura de la EDID a partir de la información de panel embebida en la vBIOS. Este trabajo se traduce en un mejor comportamiento con pantallas LVDS/eDP de portátiles antiguos, un tipo de hardware que sigue siendo habitual en entornos domésticos y laborales donde se alarga la vida de los equipos.

En paralelo, el controlador Intel Xe también recibe retoces y soluciones específicas para GPUs Xe3P, con nuevos workarounds y ajustes de rendimiento. Estos parches contribuyen a estabilizar la experiencia en sistemas que están empezando a desplegar hardware gráfico de nueva generación de Intel, algo que puede ser relevante tanto para estaciones de trabajo como para equipos de desarrollo gráfico y multimedia dentro del ecosistema europeo.

Impacto directo en dispositivos de consumo: Steam Deck OLED

Más allá del hardware de escritorio clásico, Linux 7.1-rc2 introduce una corrección destacada para el audio de la Steam Deck OLED. Durante los últimos dos años, la versión principal del kernel había roto la compatibilidad de sonido en este dispositivo portátil, obligando a Valve y a varias distribuciones orientadas a consolas portátiles a mantener parches propios en sus ramas descendentes.

Con esta RC, el problema se corrige en el árbol oficial, lo que reduce la necesidad de soluciones específicas aguas abajo y facilita que distribuciones generalistas que se usen en España y Europa puedan ofrecer una mejor compatibilidad out-of-the-box con este tipo de hardware. Es un ejemplo claro de cómo regresiones aparentemente pequeñas pueden afectar de forma directa a la experiencia de juego y multimedia en dispositivos que se han popularizado entre usuarios de Linux.

Pulido general del núcleo y disponibilidad

Además de las áreas más visibles, Linux 7.1-rc2 acumula numerosos arreglos pequeños repartidos por todo el kernel: desde controladores de red y GPU (que vuelven a dominar el conjunto de cambios de drivers) hasta ajustes en el planificador sched_ext y otros componentes internos. La tónica general es la de una RC que no es especialmente pequeña, pero que mantiene un perfil estable y sin regresiones de gran calado conocidas hasta el momento.

Tal y como es habitual, el código fuente de Linux 7.1-rc2 puede obtenerse desde kernel.org para quienes necesiten probarlo en entornos de desarrollo, integrarlo en distribuciones de prueba o simplemente adelantarse a la versión estable, o incluso para quienes quieran instalar el kernel y evaluar su comportamiento en máquinas de prueba. Torvalds ha animado a continuar con las pruebas para detectar posibles regresiones, sobre todo teniendo en cuenta el incremento sostenido del volumen de parches asociados al uso de herramientas de IA.

La fotografía que deja Linux 7.1-rc2 es la de un núcleo en fase de afinado intensivo, con la virtualización KVM reordenando sus pruebas internas, un driver NTFS moderno que se afianza con correcciones específicas, y un bloque gráfico DRM que ajusta tanto GPUs AMD como Intel Xe, sin olvidar arreglos concretos para dispositivos como la Steam Deck OLED. Todo ello acerca a Linux 7.1 a su lanzamiento estable con un enfoque claro en la robustez y el soporte de hardware que, salvo sorpresas, deberían notar tanto usuarios domésticos como organizaciones en España y el resto de Europa.

KDE sigue incansable su trabajo por mejorar Plasma. Esta semana han seguido puliendo la serie 6.6, pero parecen estar más centrados en el Plasma 6.7 que llegará a mediados de 2026. Hace unos instantes han publicado una nueva nota semanal, y en ella se recogen nuevas funciones con las que saldremos beneficiados los usuarios de KDE. Por ejemplo, hay una que mejorará indirectamente el soporte para aplicaciones de GNOME, lo que hará que ganemos en consistencia.

También han aprovechado para seguir corrigiendo errores, parte de la lista que no incluimos en nuestros artículos para no alargarlos demasiado. Quien quiera saber qué han corregido, mejor que abra el artículo original al que enlazaremos al final del nuestro. Lo que sigue es la lista con las novedades más destacadas de la última semana.

Nuevas funciones destacadas que llegarán a KDE

Plasma 6.7

• Se ha implementado soporte para el portal “Background apps”, lo que permite que las aplicaciones (especialmente apps de GNOME más recientes) utilicen este portal para ejecutarse en segundo plano y aparecer como iconos en la bandeja del sistema, junto a las aplicaciones que ya usan la funcionalidad tradicional de la bandeja del sistema.
• Se ha implementado una función de escalado de contenido en pantalla cuando se utiliza el efecto Zoom de KWin. El filtro intenta mejorar la nitidez y escalar el contenido, lo que resulta en una apariencia más suave y menos pixelada, especialmente en niveles de zoom altos. Esta función puede desactivarse si no se desea utilizarla.
• El widget de impresoras ahora muestra una insignia con el número de trabajos de impresión activos y en cola.

Mejoras en la interfaz de KDE

Plasma 6.7

• El software que usa XWayland y solicita enviar eventos sintéticos de teclado y ratón (como xdotool) ahora se identifica por nombre, permitiendo saber qué aplicación lo solicita. Además, se puede ver una lista de aplicaciones con este permiso y revocarlo posteriormente.

• Se ha aplicado estilo visual de KDE al componente genérico MessageDialog de Qt, lo que corrige problemas de apariencia poco integrada en varios programas, incluyendo el diálogo de confirmación del widget de notas adhesivas.

• Se ha mejorado el comportamiento de Discover cuando se inicia sin conexión a internet.

• Se ha mejorado la forma en la que Discover comunica que una actualización de firmware ha sido programada para instalarse tras el siguiente reinicio.
• Se ha eliminado el efecto de “doble botón de retroceso” visible en el widget de redes al mostrar el código QR de una red.
• La función de brillo automático de pantalla ahora tiene en cuenta más puntos de datos, lo que mejora su respuesta y reduce cambios bruscos en entornos con iluminación variable.
• Los botones en la parte superior del panel del explorador de widgets ahora respetan la Ley de Fitts, permitiendo activarlos al llevar el puntero al borde de la pantalla y hacer clic.

• Se ha simplificado la notificación que indica que el teléfono conectado mediante KDE Connect tiene batería baja.
• Ahora se dispone de más de 25 segundos para seleccionar un color al usar el widget Selector de color, permitiendo más tiempo para tomar decisiones.

Frameworks 6.26

• Se ha mejorado la apariencia de la transición de fundido cruzado al cambiar entre páginas en muchas aplicaciones basadas en Kirigami.

Rendimiento y técnico de KDE

Plasma 6.6.5

• Se han corregido problemas de rendimiento en varias GPU NVIDIA introducidos por la versión 595 del controlador propietario.

Plasma 6.7

• Se ha añadido soporte para renombrar o mover la nueva carpeta estándar “Projects” que aparece en las carpetas de inicio de los usuarios.
• Se ha implementado la versión 2 del portal “Input Capture”.

Pronto en tu distribución KDE

Se espera que Plasma 6.6.5 llegue el martes el 12 de mayo de 2026, y Frameworks 6.26 el 8 del mismo mes. Aunque esto debería cambiar en algún momento, se espera que siga habiendo tres versiones de Plasma durante al menos todo 2026. Los planes futuros pasan por lanzar sólo dos versiones al año, para lo que saldría especialmente beneficiado Kubuntu.

Vía: Blog de KDE.

GNOME ha publicado su nota de novedades semanales, esta vez lo ocurrido del 24 de abril al 1 de mayo. Aunque de ayer tendrá el nombre del día y poco más, pues fue el día del trabajador en todo el mundo. Aún así, hay gente para la que su trabajo es muy importante o también un hobby, por lo que no todos paramos.

Eso sí, la lista de novedades no es muy extensa. Hay sospechosos habituales, como Parabolic, y también otros nuevos, tanto que sólo ofrecen la primera versión pública, como es el caso de la aplicación Gitte. Lo que sigue es la lista con todas esas novedades.

Esta semana en GNOME

• Newsflash ahora permite deslizar entre artículos. Esto cierra una de las solicitudes de función más antiguas que seguían abiertas.
• Casilda 1.2.4 ha sido lanzado. Esta versión incluye varias funciones nuevas como soporte de escalado fraccional, correcciones de errores y mejoras generales que hacen que empiece a sentirse como un compositor completo.

• Las versiones 0.11.0–0.12.7 de RustConn incorporan las tres mayores funciones desde el inicio del proyecto, además de una gran cantidad de mejoras impulsadas por el feedback de la comunidad.
  • Se ha incorporado sincronización en la nube. Ahora se pueden sincronizar configuraciones de conexión entre dispositivos y miembros del equipo a través de cualquier directorio compartido como Google Drive, Syncthing, Nextcloud, Dropbox o incluso una memoria USB. Incluye dos modos: sincronización por grupo (archivos .rcn por grupo con acceso Master/Import) y sincronización simple (fusión bidireccional en un solo archivo). Un monitor de archivos importa cambios automáticamente, y la nueva página de configuración muestra el estado, grupos sincronizados y archivos disponibles. La CLI añade comandos para estado, lista, exportación, importación y sincronización inmediata.
  • Se ha añadido un gestor de túneles SSH como ventana independiente para gestionar túneles de reenvío de puertos sin sesiones de terminal, incluyendo modos local, remoto y dinámico con inicio automático y reconexión. El soporte de host intermedio SSH se ha ampliado a conexiones RDP, VNC y SPICE, permitiendo tunelizar sesiones gráficas a través de un bastion host. Ctrl+T abre el gestor de túneles.
  • La gestión de pestañas ha sido completamente rediseñada en torno a AdwTabView. La vista general de pestañas (Ctrl+Shift+O) muestra una cuadrícula al estilo GNOME Web. La fijación de pestañas mantiene las importantes a la izquierda. Se añade un selector con búsqueda difusa en la paleta de comandos (%). El menú contextual incluye acciones para cerrar otras, izquierda, derecha, todas o no agrupadas.
  • Otros aspectos destacados incluyen temas de color de terminal personalizados con editor ANSI de 16 colores, barra de desplazamiento en terminal, zoom de fuente (Ctrl+Scroll), copia al seleccionar, modo Keep-Alive y verbose en SSH, proveedor Hoop.dev como undécimo Zero Trust, override de socket de agente SSH, “mouse jiggler” para RDP, monitor de actividad/silencio del terminal, comprobación de estado del host con autoconexión, reglas de resaltado con colores reales mediante Cairo y rediseño del diálogo de conexión siguiendo GNOME HIG.
  • El empaquetado ha crecido significativamente. RustConn está disponible como Flatpak en Flathub, Snap con confinamiento estricto, AppImage, paquetes .deb y .rpm mediante OBS (Debian 13, Ubuntu 24.04/26.04, Fedora 43/44, openSUSE Tumbleweed/Slowroll/Leap 16.0) y builds ARM64. También existen paquetes comunitarios para Arch Linux y FreeBSD, y una solicitud abierta para incluirlo en Debian.

• Field Monitor, el visor de escritorio remoto enfocado en acceder a máquinas virtuales, ha sido actualizado a la versión 50.0:
  • Soporte para múltiples monitores en conexiones SPICE.
  • Soporte para compartir dispositivos USB con sesiones SPICE mediante el portal XDG USB, incluso en Flatpak.
  • Las máquinas virtuales KVM/QEMU ahora pueden usar renderizado GPU acelerado por hardware si está habilitado.
  • Field Monitor ahora valida certificados del servidor y solicita confirmación si no son confiables automáticamente.
  • Varias correcciones en sesiones RDP y SPICE, incluyendo problemas de cursor y rendimiento general.
• Se ha publicado la primera versión pública de Gitte, una interfaz gráfica Git basada en GTK4/libadwaita escrita en Rust y construida sobre Relm4 y git2. Incluye:
  • Navegación de repositorios con pantalla inicial de repositorios guardados.
  • Visualización del árbol de trabajo, staging y unstaging de cambios, commits y edición de commits.
  • Lectura del historial de commits e inspección de diferencias por archivo.
  • Gestión de ramas, etiquetas, remotos y stashes.
  • Push y pull con remotos, con auto-fetch en segundo plano.

• Parabolic V2026.4.1 llega con numerosas correcciones de errores:
  • Corregido un problema donde algunos ajustes no se guardaban correctamente.
  • Corregido un problema donde descargas de listas con límite de resolución no tenían audio.
  • Corregido un problema donde vídeos verticales se descargaban con resolución incorrecta.
  • Corregido un problema donde descargas desde sitios con streams muxed fallaban.
  • Corregido un problema donde descargar un fragmento de un vídeo largo generaba resultados incompletos.
  • Corregido un problema donde descargas de fragmentos podían quedarse colgadas con aria2c.
  • Corregido un problema donde descargas de X/Twitter duplicaban el vídeo.
  • Corregido un problema donde deno no se podía actualizar en Linux.
  • Corregido un problema donde las cookies del navegador no se encontraban en Flatpak.
  • Corregido un problema donde Parabolic no iniciaba en KDE.
  • Corregido un problema donde no se abrían enlaces desde la extensión en Windows.

Y esto ha sido todo esta semana en GNOME.

Imágenes y contenido: TWIG.

En el artículo anterior de nuestro curso de programación en Python usando Linux (Enlace al final del artículo) comenzamos a hablar de los componentes que se usan para construir los programas. Aunque pueda parecer un tema excesivamente básico, son la base con la que pueden construirse cosas más complejas.

Habíamos definido a las variables como contenedores en los que pueden almacenarse todo tipo de datos no permanentes, aora continuaremos explorando cuáles son las mejores prácticas para utilizarlas.

Curso de programación en Python usando Linux

Más sobre las variables

Salvo la lista de palabras no permitidas que dimos en el artículo anterior, Python nos ofrece bastante flexibilidad a la hora de elegir nombres de variables. Incluso podemos tener nombres similares utilizando distintas combinaciones de mayúsculas y minúsculas. Sin embargo, es bueno disfrutar de esa libertad con un poco de autoregulación.

Teniendo en cuenta que nosotros u otra persona tengamos que revisar ese código para corregir errores y actualizarlo  es importante que utilicemos nombres que sean significativos y descriptivos de los datos que vamos a almacenar en ellos. Por ejemplo, si vas a almacenar marcas de auto lo ideal sería marca o marca_auto en lugar de por ejemplo una letra o el nombre de uno de los personajes de los Simpson’s.  Si el nombre de la variable va a ser largo, por ejemplo usando dos o más palabras, se pueden separar con guiones bajos o alternando mayúsculas y minúsculas: marca_auto o MarcaAuto. Si recuerdas el código de ejemplo de los artículos anteriores habrás observado que el nombre de algunas variables empezaban con «-» esto es una convención que indica que esas variables son para uso interno de la clase.

Tipos de datos

Aunque no es necesario declarar que tipos de datos va a almacenar una variable al principio del programa, si al momento de asignarles un valor se debe escribir la instrucción de manera específica según el tipo. Python trabaja con los siguientes tipos de datos:

Número entero (int)

Son números positivos y negativos sin parte decimal que pueden usarse para realizar operaciones aritméticas.

año = 2026

Número decimal (float)

Son números que contienen una parte fraccionaria separada para un punto. Se usan para reflejar valores con una mayor precisión:

Precio = 2.99

Cadena de caracteres (str)

Almacena conjuntos de letras. Son los datos que se usan para almacenar texto. Nota que el texto a almacenar a entre comillas

Nombre = "Diego"

Booleano (bool)

Este tipo de datos solo admite dos valores: Verdadero (True) o Falso (False)

es_mayor_ que = True

es_menor_que = False

Es posible hacer la conversión entre tipos de datos

Entero a decimal

entero = 25
decimal = float(entero)
Decimal a entero

decimal = 5.25
entero = int(decimal)

Conversión de números a cadena de caracteres

siglo= 21
mensaje = "Estamos en el siglo" + str(edad)

Conversión de cadenas numéricas a números

cadena_texto = "2025"
numero = int(cadena_numerica)

Conversión de booleano a formato numérico

Dijimos que los datos booleanos solo admiten dos valores:  verdadero (True) y Falso (0)

Es_verdadero = True
Es_falso = False
print(int(E_verdadero))
print(int(Es_falso))

Conversor de dato numérico a booleano

valor = 0
print(bool(valor))
valor = 1
print(bool(valor))

Operadores de comparación

Los operadores de comparación, como su nombre lo indica, permite comparar valores devolviendo un dato booleano (Verdadero o falso) Son:

• ==; Si, son dos signos iguales para no confundir con el de asignación de valores a las variables. Determina si dos expresiones son iguales
• !=: No igual que. Determina si dos valores no son iguales.
• >: Determina si el valor de la izquierda es mayor que el de la derecha.
• <: Determina si el valor de la izquierda es menor que el de la derecha.
• >=: Determina si el valor de la izquierda es mayor o igual que el de la derecha.
• <=: Comprueba si el valor de la izquierda es menor o igual que el de la derecha.

Además de valores núméricos Python puede comparar cadenas de caracteres comparando carácter por carácter  siguiendo un orden que se bassa en la codificación (ASCII o Unicode. Empieza de izquierda y derecha y para cuando encuentre diferencias o una de las dos se termine. La comparación diferencia entre mayúsculas y minúsuclas.

Operadores lógicos

Se usan para verificar el cumplimiento de varias condiciones

• And: Devuelve el valor True si se cumplen todas las condiciones. En caso de que alguna no se cumple devuelve el valor False.
• Or: Devuelve True si una de las condiciones se cumple y False si no se cumple ninguna de ellas.
• Not: A la inversa de And devuelve True si no se cumple ninguna de las condiciones.

Mostrando información

Con la instrucción print() podemos mostrar en pantalla los datos de variables o mensajes de texto incluidos en el código.  Los diferentes contenidos a imprimir se separan por comas.  Recuerda que el texto debe estar encerrado entre comillas.

Al final del texto se agrega un salto de línea y si se da la instrucción sin argumento se imprime una línea en blanco.

nombre = "Diego"
print("Hola, mi nombre es: ", nombre)

Es posible agregar un salto de línea en una parte determinada del mensaje a mostrar.

print("Hola, mi nombre es.\nDiego")

El carácter especial .\t añade una cantidad de espacios predefinidos antes del texto

print("Nombre:\tDiego\nApellido:\tGonzález")

\t es una forma básica pero no siempre efectiva de alinear el texto ya que la cantidad de espacios dependerá del sistema donde se corra el programa.

Es posible que en lugar de hacer un salto de línea al finalizar un mensaje se agregue otro carácter.

print("Diego,", end='/')
print("González")

Ingresando datos

Cuando se necesita que el usuario introduzca una información mediante el teclado se utiliza la función input() Esta función muestra un mensaje y detiene la ejecución del programa hasta que el usuairo ingresa la información pedida.

distribución = input("Introduce el nombre de tu distribución Linux preferida: ")
print("Tu distribución Linux preferida es", distribución)

Recuerda que la función input() trabaja con cadenas de caracteres por lo que será necesario convertir la entrada a otros formatos encaso de que se necesite realizar operaciones numéricas.

Podemos hacerlo con las siguientes líneas de código

edad = input("¿Cuál es tu edad?: ")
edad = int(edad)

Como vimos en artículos anteriores, también es posible ingresar datos por medio de archivos.

En el próximo artículo veremos como usar todos estos componentes creando funciones más complejas.

Estamos haciendo un pequeño curso de programación en Python usando Linux. Este lenguaje de programación multiplataforma es ideal para iniciarse en el mundo de la programación, y seguirse usando a medida que vayamos adquiriendo conocimientos avanzados porque también es útil para la creación de aplicaciones más complejas.

En la actualidad, Pyhton es el lenguaje preferido para el uso de aplicaciones en Ciencias de datos, Inteligencia Artificial e incluso la propia Microsoft lo está usando  para reemplazar su propio lenguaje de macros en la planilla de cálculos Excel

Curso de programación en Python usando Linux

Nos habíamos quedado en el post anterior con los parámetros del comando open() cuando se trabajan con archivos.  Dependiendo del  tipo de archivos es conveniente indicarle al intérprete de Python como debe actuar con los caracteres especiales que indican salto de línea.

open("archivo.txt", newline=None) Transforma \r\n y \r a \n (por defecto)
open("archivo.txt", newline="") No hace ninguna transformación
open("archivo.txt", newline="\n") Solo hace el salto de línea cuando detecta el caracter especial \n (Usado por Linux)
open("archivo.txt", newline="\r\n") Solo hace el sato de línea cuando detecta el caracter especial \r\n (Usado por Windows)

Para resumir los parámetros  de la instrucción open()

• • File: Indica el nombre del archivo (Si está en la misma carpeta) o la ruta donde encontrarlo.
  • Mode: Parámetro opcional, indica si el archivo se abre en modo de lectura, escritura, ambos y si se borrará el contenido cuando se escriba nuevo.
  • Buffering: Parámetro Opcional, determina el tamaño del buffer de memoria.

<li>Encoding: Parámetro Opcional, Indica la codificaicón del texto, por defecto se usa la del sistema operativo. Muy útil si se van a hacer aplicaciones para otros que utilicen caracteres especiales.

• Errors: Indica como actuar en caso de que se detecten errores de codificación. También es un parámetro opcional.
• Newline: Determina como manejar los saltos de línea. También es un parámetro opcinal.

Veamos el siguiente programa

class Sistemas:

Definimos la clase Sistemas que servirá para crear los objetos que representarán a los sistemas operativos.

def __init__(self, nombre, version, derivada):

Iniciamos el constructor y establecemos los parámetros.

self.nombre = nombre
self.version = version
self.derivada = derivada

Estás 3 líneas tomarán los valores a medida que ingresan y los almacenarán el el objeto.

def mostrar_info(self):

Establece cómo se mostrarán los datos

print(f"Nombre: {self.nombre}")
print(f"Versión: {self.version}")
print(f"Derivada: {self.derivada}")
print("-" * 20)

Imprime los parámetros y al final de cada grupo imprime guiones.

nombre = input("Nombre del sistema: ")
version = input("Versión: ")
derivada = input("Derivada: ")

Aquí se le indica al usuario que ingrese datos distribuciones.

with open("sistemas.txt", "a") as archivo:

Este comando comprueba si existe un archivo llamado sistemass.txt, lo crea si no existe y agrega los datos al final de los que están escritos.

archivo.write(nombre + "\n")
archivo.write(version + "\n")
archivo.write(derivada + "\n")

Imprime los datos almacenados con un salto de línea.

with open("sistemas.txt", "r") as archivo

Abre el archivo en modo de lectura-

lineas = [linea.strip() for linea in archivo.readlines()]

Esta instrucción lee todas las líneas del archivo y elimina los caracteres especiales que indican salto de línea.

sistemas = []

Crea la lista vacía donde se guardan los objetos que se reconstruyan.

for i in range(0, len(lineas), 3):

Genera series de números de tres en tres. Esto es porque se almacenan 3 parámetros por cada instancia del objeto sistemas operativos.

Supongamos que tenemos 3 sistemas (9 parámetros)

range(0, 9, 3) → 0, 3, 6

i=0 → líneas 0, 1, 2 → primer sistema
i=3 → líneas 3, 4, 5 → segundo sistema
i=6 → líneas 6, 7, 8 → tercer sistema

if i + 2 < len(lineas):

Esto es por seguridad. Se verifica que un grupo tenga 3 parámetros antes de hacer la lectura. Si no hay un grupo de 3 no hace la lectura.

Python dispone varias opciones para leer y escribir archivos.

Crea el objeto Sistemas

sistema = Sistemas()

Incorpora los datos de las líneas que corresponde

lineas[i],
lineas[i + 1],
lineas[i + 2]
Por ejemplo

i=0:
lineas[0] → «Ubuntu» → nombre
lineas[1] → «26.04» → version
lineas[2] → «Debian» → derivada

i=3:
lineas[3] → «Manjaro» → nombre
lineas[4] → «44» → version
lineas[5] → «Arch Linux»→ derivada

i=6:
lineas[6] → «Linux Mint» → nombre
lineas[7] → «22» → version
lineas[8] → «Ubuntu»→ derivada

sistemas.append(sistema)

Agrega el objeto recién creado a la lista Sistemas. El bucle finaliza cuando se incorporen todos los objetos reconstruidos del archivo.

for s in sistemas:

Recorre el archivo recién creado.

s.mostrar_info()

Llama al método para mostrar los parámetros de cada objeto.

Hasta ahora estuvimos tocando de oído usando instrucciones cuyo uso no tenemos del todo claro. Llegó el momento  de ocuparnos de ellos.

Operaciones matemáticas básicas con Python

En los programas creados en Python pueden usarse las siguientes operaciones matemáticas

• Suma: a = 5 + 3 Asigna a la variable el valor 8
• Resta: b = 10 – 2 Asigna a la variable el valor 8
• Multiplicación: c = 4 * 2 ¿A que no adivinas el valor de la variable?
• Division:  d = 5 /  3 Asigna a la variable el valor 1,6666…
• División sin decimales: e = 21 // 7 Da como resultado 3.
• Cálculo del resto de la división: f  =  5 % 3 Asigna a la variable el valor 2.
•  Potencia: g  =  2 ** 4 Le asigna a la variable el valor 16.

Es posible hacer operaciones más complejas pero será necesario introducir el concepto de módulo del que hablaremos más adelante.

Variables

Tanto en los programas que usamos como ejemplo como en la lista que dimos recién de operaciones matemáticas, usamos variables. Las variables son contenedores en el que se almacenan datos que pueden ser introducidos por el código o en forma externa, modificarse y mostrarse cuando se necesite.  A diferencia de otros lenguajes de programación, en Python no es necesario declarar previamente a que tipo pertenece cada variable antes de usarlas.

Una variable se declara así

Nombre = "Diego"

Donde nombre es el nombre de la variable y el texto entre comillas a la derecha del igual le asigna el valor Diego.

Es posible asignar el valor a distintas variables  en una sola línea de código

nombre, apellido, edad  = «Diego», «González», 55

Reglas para el nombre de las variables

• Caracteres permitidos: SI bien se pueden usar letras, signos de puntuación y guiones bajos, el nombre debe empezar siempre con una letra o un guión bajo. No importan si las letras son mayúsculas o minúsculas.
• Sensibilidad a mayúsculas y minúsculas: El sistema diferencia palabras escritas con mayúsculas o minúsculas por lo que deben escribirse exactamente igual a como fueron declaradas.
• Palabras reservadas: Existen una serie de palabras que no pueden usarse porque se las reserva el intérprete

Las palabra reservadas son:

False await else import pass None break except in raise True class finally is return and continue for lambda try as def from nonlocal while assert del global not with async elif if or yield match case
En el próximo artículo continuaremos con los componentes del lenguaje de programación Python

En esta serie de post del curso de programación en Python usando Linux decidimos probar con un enfoque diferente. En lugar de empezar conlos conceptos básicos  (los ladrillos, por llamarlo de alguna manera)  empezamos por el edificio completo para después ocuparnos de sus partes.

En este caso el edificio es el paradigma conocido como Programación Orientada a Objetos.  Para terminar con esta parte del curso analizaremos los conceptos claves  del paradigma aplicados a la programación en Python. Recuerda que el enlace al post anterior está al final del artículo.

Curso de programación en Python usando Linux

Conceptos clave de la Programación Orientada a Objetos aplicados a Python

Clase

Es la plantilla con la cuál se construyen los objetos. Se ocupa de definir cómo será un objeto y lo que puede hacer. Es algo así como una receta de cocina. Se define con el comando :

class Nombre_de_la_clase

Atributos

Son las características que describen a un objeto.  Actúan como variables pertenecientes exclusivamente a la clase.

Constructor

Es un método especial que se ejecuta en forma automática al crear un objeto, Se encarga de inicializar los atributos del mismo.
Métodos

Son funciones definidas dentro de una clase que determinan el comportamiento del objeto.

Herencia

Es la capacidad de una clase de tomar las características y comportamientos de otras que ya existen añadiendo y modificando lo que ya existen. La clase de la que se toman las características se llama clase padre y la que lo recibe, con una falta de originalidad enorme, clase hija.

Polimorfismo

Hablando de falta de originalidad, esta característica significa que clases diferentes pueden tener métodos con el mismo nombre pero con comportamientos diferentes
Manejando archivos en Python

En los ejemplos que proporcionamos anteriormente, la información se incluía dentro del código. Se trata de un método poco práctico ya que hay que modificarlo cada vez que haya que agregar o borrar una información. Por suerte, hay otras formas de hacerlo como la lectura de los datos dese un archivo.
Creamos un archivo de texto simple con el título sistema.txt y el contenido

Ubuntu

26.04

Debian

Ahora veamos el programa.

class Sistemas:
Definimos una clase con el nombre SIstemas como habíamos hecho antes.
def __init__(self, nombre, version, derivada):
Iniciamos el constructor automático que se ocupa de asignar los parámetros.
self.nombre = nombre
self.version = version
self.derivada = derivada
Con estas líneas se guardan los atributos recibidos como valores dle objeto.
def mostrar_info(self):
Define la forma cómo se mostrara la información de los atributos.
print(f"Nombre: {self.nombre}")
print(f"Versión: {self.version}")
print(f"Derivada: {self.derivada}")
Instrucciones para imprimir en pantalla los atributos del objeto. Las llaves insertan el valor de las variables dentro del texto.
with open("sistema.txt", "r") as archivo:
Este comando abre el archivo en modo de lectura y lo cierra una vez que se termina el bloque
lineas = archivo.readlines()
Lee todas las líneas de un archivo y las guarda en una lista. Hablaremos de las lsitas en archivos posteriores.
nombre = lineas[0].strip()
version = lineas[1].strip()
derivada = lineas[2].strip()
Accede a cada línea por su posición y elimina saltos de línea y espacios con el comando strip.
sistema = Sistemas(nombre, version, derivada)
Crea una instancia del objeto de la clase Sistemas con los parámetros que leyó del archivo.
sistema.mostrar_info()
Llama al método encargado de imprimir en pantalla
La función open()

La función open() viene predefinida dentro de Python y requiere los siguientes parámetros:

File

Es obligatorio y le indica al programa donde buscar el archivo. Si está dentro de la misma carpeta del programa solo se indica el nombre del archivo y la extensión. SI no es necesario también indicar la ruta de donde está almacenada.
open("archivo.txt") Cuando el archivo está en la carpeta actual.
open("carpeta/archivo.txt") Cuando el archivo está dentro de otra carpeta.
open("/home/usuario/archivo.txt") Se indica la carpeta dentro de la carpeta personal de un usuario específico.
open(3); Se indica un archivo por el identificador que le asigna el sistema operativo.
Mode
Es un parámetro opcional que indica la forma con la que se trabaja con el archivo.

• • r: Modo de solo lectura. Da error si el archivo no fue creado previamente.

<li>w: Escribe el archivo y lo crea si no está. Borra el contenido existente.

• a: Crea el archivo si no existe. SI hay contenido escribe al final de este.
• x: Crea el archivo. Da error si no existe.
• r+: Lee y escribe el archivo, da error si no se creo previamente.
• w+: Lee y escribe el archivo. Borra el contenido existente.
• a+: Lee y escribe al final del contenido.
• t: Es la opción por defecto, trabaja con cadenas de texto.
• b: Trabaja con bytes. Es ideal para el trabajo con imágenes o pdf.

buffering

Es el control de la memoria temporal antes de escribir un archivo. No es necesario especificarlo, pero en algunos casos puede se rútil.

• 0: Sin buffer, se escribe directo a disco. Ideal para trabajar con el modo b.
• 1; Es el modo por defecto.  Almacena el dato cargado hasta encontrar un salto de línea y entonces lo escribe en la variable. Se usa solo en el modo de texto.
• =: Despues del igual se establece un valor en bytes para indicar el tamaño que debe tener el buffer.
• -1: El sistema operativo determina el tamaño del buffer.

Algunos ejemplos

open("archivo.txt", buffering=0) No crea el buffer ya que estamos trabajando con el modo binario.
open("archivo.txt", buffering=1)  El buffer trabaja con saltos de línea
open("archivo.txt", buffering=4096) Establece un buffer de 4096 bytes
open("archivo.txt", buffering=-1) Utiliza el buffer por defecto del sistema operativo.

encoding

Establece la codificación de caracteres del proyecto. Si no se especifica se utiliza la del sistema.

errors

Otro parámetro opcional. Define que hacer cuando se encuentran errores de codificación.

• Strict: Indica un error cuando lo encuentra.
• Ignore: Omite los caracteres que no puede decodificar.
• Replace: Sustituye los caracteres no identificados por signos de pregunta.
• backslashreplace: Sustituye los caracteres que ignora por la secuencia \xNN

Newline

Otro parámetro opcional pero que puede resultar útil cuando se trabaja con archivos generados por diferentes sistemas operativos.  Un salto de línea es un carácter invisible que le indica al sistmea operativo que terminó una línea y comienza la siguiente.

Continuaremos desarrollando este tema y explicando nuevas instrucciones en el próximo artículo.

En los tiempos del humo generado por las empresas de Inteligencia Artificial y sus propagandistas, aprender programación sigue siendo más necesario que nunca. En esta cuarta parte del curso de programación en Python con Linux seguiremos explicando como entender el paradigma de Programación orientada a Objetos. Recuerda que el enlace a la lección anterior está al final del post.

Aunque los agentes y modelos de Inteligencia Artificial sean capaces de entender y escribir código, todavía sigue siendo necesario que un humano sea capaz de darles instrucciones detalladas de lo que tiene que hacer. Para esto no solo hay que entender el problema que se quiere resolver con la aplicación sino también diseñar la solución teniendo en cuenta las características del lenguaje.

Vamos a ver si dejamos en claro esto con una analogía.

Los obreros construyen los rascacielos. Pero, antes de empezar la construcción se necesitan arquitectos que diseñen los planos, ingenieros que hagan los cálculos estructurales y diseñen las conexiones eléctricas, de gas y agua.  Cuando el edificio esté terminado otras personas deberán determinar el diseño de interiores . Por supuesto que, tal vez trabajadores de experiencia podrían hacer un trabajo competente, siempre que no se presenten complicaciones. Pero, en la práctica nadie quiere apostar a eso.

La realidad es que el vibe coding da mejores resultados cuanto más detalladas son las instrucciones y, que grandes empresas han sufrido interrupciones de servicio y borrado bases de datos irreemplazables por agentes de Inteligencia Artificial demasiado emprendedores con instrucciones insuficientes.

Curso de programación en Python con Linux

Habíamos visto en los artículos anteriores que el modelo de Programación Orientada a Objetos se basa en  4 pilares: objetos, clases, métodos y atributos. Las clases son las plantillas donde se modelan los objetos o entidades sobre las cuales trabajamos. Esas plantillas indican los atributos que tendrán los objetos mientras que los métodos marcan el comportamiento del objeto.

A los diferentes elementos creados con el molde establecido en las clases se lo denominan instancias. Por ejemplo, dentro de la clase Sistemas Operativos tenemos las instancias: Linux, Windows, macOS. Ahora bien, es posible que nos interese crear clases que se diferencien poco de clases ya creadas. No es necesario volver a escribir código ya que podemos aprovechar una característica de la Programación Orientada a Objetos conocida como herencia.

Veamos el siguiente programa con una clase agregada.

El motivo por el cual no pego el código directamente en el artículo es, como ya expliqué, es que la plataforma que usamos para publicar el blog no soporta la indentación. Esta práctica consiste en agregar espacios o tabulaciones (nota lo de o tabulaciones ya que no pueden mezclarse) haciendo que el código sea más fácil de entender.

Con la indentación es más fácil estructurar el código de manera jerárquica diferenciando bloques del código como bucles, funciones o clases. Además, si no indentas adecuadamente los programas en Python no funciona.

Ahora vamos al análisis del programa línea por línea.

class Sistemas:

Como vimos, este programa crea la plantilla sobre la cuál se van a crear las instancias de sistemas operativos.

def __init__(self, nombre, version, derivada):

Acá estamos construyendo la clase. La primera parte es un método automatizado que se utiliza cada vez que se crea una. Lo que está entre paréntesis son los parámetros que va a tener el objeto. Self se usa siempre y hace referencia al objeto. En todos los casos va primero.  Los otros parámetros son los que establecimos en clases anteriores, el nombre de la distribución Linux, la versión  y de cuál distribuicón es derivada.

self.nombre = nombre
self.version = version
self.derivada = derivada

Estas líneas se usan para crear los atributos del objeto. Son variables específicas del objeto que actúan como variables dentro del mismo y los conservarán para cuando se necesiten.

def mostrar_info(self):

Este método define cómo se mostrará la información de los atributos del objeto. El parámetro self indica que solo debe usar los parámetros guardados como atributos.

print(f"Nombre: {self.nombre}")
print(f"Versión: {self.version}")
print(f"Derivada: {self.derivada}")

Estas 3 líneas indican que la forma de mostrar la información de los atributos es imprimiéndolas en pantalla.

class SistemaConPeso(Sistemas):

Acá es donde se modifica nuestro programa con respecto al anterior. Agregamos una nueva clase extendida construida a partir de la anterior. De ahí que al nombre de la clase se le agregue el nombre de la clase anterior entre paréntesis.

def __init__(self, nombre, version, derivada, peso):

Este es constructor de la clase hija, casi igual al que vimos antes pero agregando el parámetro peso.

super().__init__(nombre, version, derivada)

Para no repetir código le indicamos al programa con la instrucción super que la tarea de ocuparse de nombre, versión y derivada es de la clase padre.

self.peso = peso

Todavía teníamos que ocuparnos de guardar el atributo peso.

def mostrar_info(self):

Como de lo que se trata es de no escribir código de más, en lugar de crear una nueva función que muestre el dato adicional vamos a modificar la que ya teníamos.
super().mostrar_info()

Llama al método de la clase padre para establecer como deben mostrarse los atributos guardados en ella.
print(f"Peso: {self.peso}

Agrega la información sobre cómo deben mostrarse los datos de la clase actual.

sistema = SistemaConPeso("Linux Mint", "22", "Ubuntu", "3GB")

Crea el objeto donde se guardará la información con el nuevo parámetro agregado y lo guarda en la variable sistema.

sistema.mostrar_info()

Llama al método encargado de mostrar la información

Por supuesto, que este programa no tiene usos prácticos reales. No tendría ningún sentido tener que introducir los valores de los atributos en el código ya que se necesitaría un programador cada vez que es necesario modificar algo. Como vimos en el ejemplo del 3 en raya, Python puede recibir y guardar información ingresada por el usuario mediante el teclado. También puede hacerlo leyendo archivos o interactuadno con bases de datos.

Pero, tuvo su utilidad para hacer más claros conceptos claves de la programación orientada a objetos como clases, atributos, constructores, métodos, herencia y polimorfismo. Prometo que en el próximo artículo termino de hablar de la Programación Orientada a Objetos y empiezo a hablar de cómo se hacen las cosas en Python