K9mail es un cliente de correo electrónico para sistemas Android que realiza su tarea de una forma eficiente y eficaz y además es software libre

Desde hace años el cliente de correo electrónico que utilizo en mi dispositivo Android es K9mail. Por ser eficaz, por ser eficiente y por ser software libre.

Ya escribí un artículo sobre este cliente de correo electrónico:

• https://victorhckinthefreeworld.com/2020/06/03/k-9-mail-el-cliente-de-correo-de-software-libre-para-tu-android/

Ahora vuelvo a dedicarle un artículo para dar a conocer que el desarrollador de este software está pidiendo financiación para poder seguir con el proyecto de una manera más dedicada a desarrollarlo.

El desarrollador de K9mail, comunicaba en su blog oficial, que quien quisiera podía contribuir con el proyecto donando dinero. Eso le permitiría dedicarle más esfuerzo y recursos a desarrollar y mejorar su cliente de correo.

Sí, puedes descargar y utilizar este software de manera gratuita, así que ¿por qué ibas a pagar por su uso? Bueno, yo lo he hecho, porque desde hace años está instalado en mi dispositivo y me permite gestionar mis correos electrónicos de manera eficaz.

Me gusta la aplicación y estoy muy contento de utilizarla, así que decido pagar al desarrollador para que siga dedicándole su tiempo y esfuerzo. Pago por software gratuito, siempre que sea libre y en este caso muy contento de hacerlo.

Así que si llega al objetivo de 1000 € a la semana en donaciones eso le permitirá poder dedicarle más tiempo, integrar nuevas funcionalidades, actualizar el software y corregir errores. Y comer, pagar facturas y darse algún capricho…

Pero además del dinero, también por supuesto puedes colaborar con código, traduciendo, ayudando a resolver dudas en el foro…

Yo ya he hecho mi aporte, puedes utilizar Liberapay para donar demanera recurrente o una donación puntual. ¿Te animas tu también?

Enlaces de interés

• https://k9mail.app/2021/02/14/K-9-Mail-is-looking-for-funding
• https://github.com/k9mail/k-9
• https://liberapay.com/k9mail/donate
• https://f-droid.org/packages/com.fsck.k9/
• https://k9mail.app/

I’ve had a somewhat recent AMD Radeon RX 560 graphics card in my Mini-ITX PC for over a year already, and one long term interest I have would be to be able to enhance old videos. Thanks to Hackweek I could look at this as one of the things that I’ve waited to have time for. In recent years there have been approaches to use eg neural networks to do super resolution handling of photos and also videos, so that there would be more actual details and shapes than what would be possible via normal image manipulation. The only feasible way of doing those is by using GPUs, but unfortunately the way those are utilized is a bit of a mess, most of all because proprietary one vendor only CUDA is the most used one.

On the open source side, there is OpenCL in Mesa by default and Vulkan Compute, and there’s AMD’s separate open source ROCm that offers a very big platform for computing but also among else OpenCL 2.x support and a source level CUDA to portable code (including AMD support) translator called HIP. I won’t go into HIP, but I’m happy there’s at least the idea of portable code being thrown around. OpenCL standardization has been failing a bit, with the newest 3.0 trying to fix why the industry didn’t adopt 2.x properly and OpenCL 1.2 being the actual (but a bit lacking) baseline. I think the same happened a bit with OpenGL 1.x -> 2.x -> 3.x a long time ago by the way… Regardless if the portable code is OpenCL or Vulkan Compute, the open standards are now making good progress forward.

I first looked at ROCm’s SLE15SP2 installation guide - interestingly, it also installed on Tumbleweed if ignoring one dependency problem of openmp-extras. However, on my Tumbleweed machine I do not have Radeon so this was just install test. I was however surprised that even the kernel module compiled against TW’s 5.11 kernel - and if it would have not, there’s the possibility of using upstream kernel’s module instead.

Over at the Radeon machine side, I installed ROCm without problems. Regardless of that SDK, many real world applications for video enhancing are still CUDA specific so would at minimum require porting to portable code with HIP. These include projects like DAIN, DeOldify etc. However, there are also projects using OpenCL and Vulkan Compute - I’ll take video2x as an example here that supports multiple backends, some of which support OpenCL (like waifu2x-converter-cpp) or Vulkan (like realsr-ncnn-vulkan). I gave the latter a try on my Radeon as it won the CVPR NTIRE 2020 challenge on super-resolution.

I searched my video collection far enough back in time so that I could find some 720p videos, and selected one which has a crowd and details in distance. I selected 4x scaling even though that was probably a time costly mistake as even downscaling that 5120x2880 video probably wouldn’t be any better than 2x scaling to 2560x1440 and eg downscaling that to 1920x1080. I set up the realsr-ncnn-vulkan and ffmpeg paths to my compiled versions, gave the 720p video as input and fired way!

And waited. For 3.5 hours :) Noting that I should probably buy an actual highend AMD GPU, but OTOH my PC case is smallish and on the other hand the market is unbearable due to crypto mining. The end result was fairly good, even if not mind blowing. There are certainly features it handles very well, and it seems to clean up noise a bit as well while improving contrast a bit. It was clearly something that would not be possible by traditional image manipulation alone. Especially the moving video seems like higher resolution in general. Maybe the samples I’ve seen from some other projects out there have been better, then OTOH my video was a bit noisy with movement blur included so not as high quality as would be eg a static photo or a video clip tailored to show off an algorithm.

For showing the results, I upscaled a frame from the original 1280x720 clip to the 4x 5120x2880 resolution in GIMP, and then cropped a few pieces of both it and the matching frame in the enhanced clip. I downscaled them actually then to 1440p equivalent crop. Finally, I also upscaled the original frame to FullHD and downscaled the enhanced one to FullHD as well, to be more in line what could be one actual desired realistic end result - 720p to 1080p conversion while increasing detail.

The “1440p equivalent” comparison shots standard upscale vs realsr-ncnn-vulkan.

The FullHD scaling comparison - open both as full screen in new window and compare.

Now that we learned how truly magnificent ActiveSupport::Notifications is in the previous post, let's explore a RubyGem Chris, others and me have built around this: influxdb-rails. Together with even more awesome Software Libre, it will help you to deep dive into your Ruby on Rails application performance.

Application Performance Monitoring (APM)

I'm not sure we have to discuss this at all anymore, but here is why I think I need application performance monitoring for my Ruby on Rail apps: I'm an expert in using the software I hack. Hence I always travel the happy path, cleverly and unconsciously avoid the pitfalls, use it with forethought of the underlying architecture. Because of that, I usually think my app is fast: perceived performance.

It's not what you look at that matters, it's what you see. – Henry David Thoreau

That is why I need someone to correct that bias for me, in black and white.

Free Software APM

The good folks at Rails bring the instrumentation framework. InfluxData deliver a time series database. Grafana Labs make a dashboard builder. All we need to do, as so often, is to plug Software Libre together: SUCCE$$!

InfluxDB + Grafana == 🧨

I assume your Rails development environment is already running on 127.0.0.0:300. Getting InfluxDB and Grafana is a matter of pulling containers these days. You can use this simple docker-compose configuration for running them locally.

# docker-compose.yml
version: "3.7"
services:
  influx:
    image: influxdb:1.7
    environment:
      - INFLUXDB_DB=rails
      - INFLUXDB_USER=root
      - INFLUXDB_USER_PASSWORD=root
      - INFLUXDB_READ_USER=grafana
      - INFLUXDB_READ_USER_PASSWORD=grafana
    volumes:
      - influxdata:/var/lib/influxdb
    ports:
      - 8086:8086
  grafana:
    image: grafana/grafana:7.4.5
    ports:
      - 4000:3000
    depends_on:
      - influx
    volumes:
      - grafanadata:/var/lib/grafana
volumes:
  influxdata:
  grafanadata:

A courageous docker-compose up will boot things and you can access Grafana at http://127.0.0.1:4000 (user: admin / password: admin). To read data from the InfluxDB container in Grafana, leave the /datasources InfluxDB defaults alone and configure:

URL: http://influx:8086
Database: rails
User: grafana
Password: grafana

influxdb-rails: 🪢 things together

The influxdb-rails RubyGem is the missing glue code for making your app report metrics into the InfluxDB. Plug it into your Rails app by adding it to your bundle.

bundle add influxdb-rails
bundle exec rails generate influxdb

The next time you boot your Rails dev-env it will start to measure the performance of your app. Now comes the interesting part, interpreting this data with Grafana.

Understanding Ruby on Rails Performance

Every time you use your dev-env, influxdb-rails will write a plethora of performance data into InfluxDB. Let's look at one of the measurements so you get an idea of what's going on. You remember the ActiveSupport::Notification called process_action.action_controller from the previous post? Rails sends this message every time an action in your controller has finished. It includes performance data for this action.

You should know this from somewhere: development.log! It contains the same information.

Started GET "/things" for 127.0.0.1 at 2021-03-25 15:20:14 +0100
...
Completed 200 OK in 5ms (Views: 4.1ms | ActiveRecord: 0.1ms | Allocations: 3514)

ThingsController#index took 5ms to finish overall, 4.1ms of those 5 in rendering, 0.1ms in querying the database. You find the same data for every request you make in your InfluxDB. Head over to http://127.0.0.1:4000/explore and let Grafana plot it for you.

Only want to see how your views are performing? Change the field from controller to view. Magic 🪄 But this is only one out of many different ways to look at this measurement. All of the panels below use this one measurement and the data it brings to visualize controller actions.

And this is only one measurement, influxdb-rails reports around a dozen. Now I could send you off your way to learn about ALL. THE. SOFTWARE. involved, but that would be mean wouldn't it?

Ruby on Rails Dashboards

We, the Free Software community, are in this together! We collaborate on Ruby on Rails. We work together to make InfluxDB better. We cooperate to improve Grafana. Why not do the same for the dashboards to visualize Rails performance data? Let's collaborate! That is why we have build a couple of dashboards you can import. Just copy and paste the URLs into your Grafana.

• Ruby On Rails Performance Overview: Ruby On Rails Performance Overview
• Performance insights into individual requests: Ruby On Rails Performance per Request
• Performance of individual actions: Ruby On Rails Performance per Action
• HTTP Request Health: Ruby On Rails Health Overview
• ActiveJob Insights: Ruby on Rails ActiveJob Overview
• A list of the slowest requests: Ruby on Rails Slowlog by Request
• A list of the slowest actions: Ruby on Rails Slowlog by Action
• A list of the slowest queries: Ruby on Rails Slowlog by SQL

Play a little, I will tell you about all the nitty gritty details in the last post of this series: Let's build Software Libre APM together

Este año he estado más atento, y es que las vacaciones de fallas me han venido estupendo para centrarme un poco en el blog y prestarle la atención que se merecía. Y es que hoy 24 de marzo de 2021 KDE Blog cumple 13 años de publicación constante (la promesa de un artículo al día no se ha incumplido nunca) y sigue siendo mi forma de pagar a la Comunidad todo lo que me ha dado.

KDE Blog cumple 13 años

Todo se remonta a hace más de 10 años cuando decidí que una parte de mi vida la iba a dedicar a ayudar a los demás en su migración hacía el Software Libre y a reportar cómo solucionaba los problemas del día a día.

¿Y cómo pensé hacerlo? Dado que no sabía programar y que me venía muy grande el diseño o la traducción, decidí que haría lo mejor que sabía hacer: enseñar.

Y como en aquella época estaban de moda las bitácoras personales, decidí escribir un blog donde explicaría mis vicisitudes en este nuevo sistema de sistemas operativos GNU/Linux que llevaba un escritorio libre conocido por aquel entonces como KDE.

Lo he dicho muchas veces, cuando empecé no sabía casi nada, de hecho pienso que fui muy atrevido ya que en mi cabeza no existían conceptos bien formados de Comunidad, kernel, beta, Release Candidate, escritorio vs distribución, etc, de tal forma los errores que cometí fueron apoteósicos, … pero nadie murió por ello y me sirvió para ir creciendo y aprendiendo.

Como todos lo años, y este año especialmente, quiero agradecer el capote que me ofreció maslinux (aka Pedro) cuando cometí un desliz sin mala intenciones y se me echó encima toda una comunidad de usuarios de una web potente de la época. Muchas gracias Pedro.

Y, como es habitual, me gusta recordar la declaración de intenciones de KDE Blog:

[24 de marzo de 2008]
«Hola a todos y todas: Hoy se inaugura KDE Blog un nuevo blog en el inmenso e infinito mundo de los blogs. El objetivo de este blog es múltiple: ayudar a los principiantes en el mundo Linux, informar sobre el mundo KDE, (el entorno de escritorio bajo Linux) y fomentar el uso del Software Libre.»

A pesar de la doce años pasados, la idea principal sigue válida aunque los artículos van cambiando de temática porque cada vez es más difícil hacer entradas explicando cómo hacer las cosas o solucionar problemas, lo cual es positivo, y cada vez más voy dedicando el blog a eventos y podcast.

Y es que cada vez más gente utiliza GNU/Linux y el Software Libre cada vez tiene una alta calidad (está a la altura y supera al privativo en muchos aspectos) aunque sigo opinando que el gran salto solo se dará cuando los dispositivos que compre la gente ofrezcan GNU/Linux por defecto.

Mientras tanto, el KDE Blog blog seguirá siendo mi granito de arena en la promoción del Software Libre y de la Comunidad KDE.

Los años siguen siendo complicados pero se mantienen las entradas diarias

Esto se repite año a año ya que igual que el 2020 mis obligaciones familiares, académicas y laborales me dejan poco tiempos para poder dedicarlo al blog. No obstante, este año me he organizado mejor y apenas tengo problemas para poder escribir… en mis tiempos vacacionales suelo redactar lagunas entradas que me alivian en épocas más estresantes.

De esta forma, sigo publicando de forma diaria sin demasiadas dificultades ya que el entorno no deja de ofrecerme decenas de eventos, colaboraciones, podcast y servicios, los cuales debo admitir que parece que han aumentado en estos tiempos pandémicos.

En cuento a mis actividades fuera del blog quisiera destacar que:

• Sigo en la junta de KDE España como secretario.
• Soy nuevo miembro de la Asociación de usuarios de GNU/Linux València.
• He vuelto a participar en los podcast de KDE España de forma directa aunque mis labores se han reorientado a darle un toque visual a los mismos, y sigo encargado de publicarlos en los diferentes medios.
• Sigo atento en el Grupo de Telegram de Cañas y Bravas. ¡Somos casi de 600 pero sigues faltando tú!).
• Y me encargo, con menor intensidad de la deseada, de las redes sociales de la organización.

A lo largo de estos 13 años he ido publicando entradas conmemorativas que podéis seguir en la siguiente etiqueta, en las cuales se resumen muy bien los sentimientos y la historia del blog, y como este año no tengo tiempo y apenas han cambiado os invito a leer para no repetirlo.

Renovación de votos

Los votos no cambian, al parecer he llegado a un momento de estabilidad, y mi compromisos con la Comunidad KDE se mantienen:

• KDE Blog sigue teniendo cuerda para muchos años,
• Sigo estando ilusionado con el proyecto KDE y en su difusión.
• Sigo abierto a todo tipo de colaboraciones (¿quieres ayudar a publicar en el blog? ¿Encargarte de la parte social? ¿Mejorar las entradas? Mándame un correo [bortega@kde_espana.org] y hablamos)
• Y para finalizar decir que me siento orgulloso de pertenecer a un movimiento cuyo objetivo es compartir su conocimiento en pro de una evolución más rápida de la humanidad, que se concreta en pertenecer a una Asociación de Software Libre como KDE España.

Así que:

¡Muchísimas gracias a todos por seguirme!

Veamos los registros numerados que dispone el editor Vim y cómo poder usar esta gran herramienta al editar

El editor Vim dispone de 10 tipos de registros que almacenan ciertos textos en una u otras circunstancias.

1. El registro sin nombre ("").
2. Los registros numerados ("0-9).
3. El registro de pequeñas eliminaciones ("-).
4. Los registros nominales ("a-z).
5. El registro de solo lectura (":, ".,y "%).
6. El registro de archivo alternativo ("#).
7. El registro de expresiones ("=).
8. Los registros de selección ("* y "+).
9. El registro de agujero negro ("_).
10. El registro del último patrón de búsqueda ("/).

En este artículo vamos a fijarnos en los registros numerados que dispone el editor Vim. Vamos a conocerlos y saber cómo utilizarlos mientras editamos con Vim.

Este artículo es una nueva entrega del curso “improVIMsado” que desde hace meses vengo publicando en mi blog sobre el editor Vim y que puedes seguir en estos enlaces:

• https://victorhckinthefreeworld.com/tag/vim/
• https://victorhck.gitlab.io/comandos_vim/articulos.html

Los registros numerados almacenan ciertos textos que copiamos o borramos. Vamos a ver cómo funcionan. Cabe diferenciar en los registros numerados el registro 0 y los registros del 1 al 9.

Podemos consultar los textos almacenados en los registros numerados (entre otros registros que dispone Vim y que si os apetece veremos en otras ocasiones) ejecutando el comando:

:reg

Primero vamos a repasar los registros numerados. Y después veremos cómo podemos usarlos.

El registro numerado 0

El registro 0 almacena el último texto copiado, ya sea un único caracter (yl), una palabra (yiw), línea (yy), etc. El texto nuevo copiado sustituirá al anterior, pero mientras no copiemos otro texto, nuestro texto copiado estará disponible en este registro.

Los registros numerados del 1 al 9

Cuando borramos una línea (dd) o cuando cambiamos una línea (cc) ese texto queda almacenado en los registros numerados del 1 al 9. Y los distintos textos se almacenan como si fueran una pila.

Es decir, el primer texto se almacena en el registro 1, cuando borramos otra línea, el texto del registro 1 pasa al 2 y el nuevo texto se almacena en el registro 1. Y así de manera consecutiva hasta el registro 9.

Cómo utilizar los registros numerados.

Ya hemos visto qué se almacena en cada registro numerado. El 0 sería el registro de copia, y del 1 al 9 las líneas borradas y cambiadas que se van almacenando progresivamente.

Esos textos almacenados los podemos utilizar para pegarlos tantas veces como deseemos.

Para pegar esos textos, cualquiera de ellos del 0 al 9, estando en el modo normal de Vim podemos ejecutar:

"xp

Donde las comillas dobles se refieren al registro, la x la sustituiremos por el número de registro que queremos pegar y la p la acción. Si usamos la p pega el texto después del cursor. Si usamos la P antes del cursor.

Por ejemplo, si queremos pegar el contenido del registro 2, sería:

"2p

Una curiosidad, si después de ejecutar esa acción usamos el comando del punto, Vim en la repetición del comando incrementará el registro utilizado.

Es decir en el ejemplo anterior que hemos pegado el registro 2, si ahora repetimos la acción usando el punto, Vim pegará el registro 3, si lo repetimos pegará el registro 4, etc…

Pero también podemos utilizar los registros estando en el modo insertar, en vez de usar las comillas dobles, deberemos hacerlo con la combinación de teclas Ctrl-r n. Donde n sería el número de registro que queremos pegar.

Espero que esta explicación haya sido aclaratoria del modo de utilizar los registros y os sea útil a la hora de mejorar vuestra experiencia usando el edito Vim.

¿Conocías esta funcionalidad? ¿Os ha resultado útil? ¿Queréis que escriba sobre los otros registros? Usad los comentarios para dar vuestra opinión.

One of the lesser known parts of Rails core is the ActiveSupport instrumentation framework. ActiveSupport::Notifications includes all the things you need to implement pub-sub in Rails. Pub-Sub is a software architecture where you publish (send) a message without being specific about who should receive it. Fire and forget.

Receiving a message, and doing something with it, "just" requires you to subscribe to it. Because the publisher doesn't need to know about the subscribers (as they are decoupled), this provides nice opportunities for organization and scale.

Let's explore the joyful shenanigans of this.

Publish & Subscribe

There is an instrumentation message emitted from ActionController that includes interesting data about the things happening in your controller action. Let's explore this.

If you don't have a Ruby on Rails app at hand, just setup a minimal one with rails new --minimal

Add this code into an initializer

# config/initializers/instrumentation_subscriber.rb

# What happens in ActionController?
module ActionController
  class InstrumentationSubscriber < ActiveSupport::Subscriber
    attach_to :action_controller

    def process_action(message)
      Rails.logger.debug "Instrumentation #{message.name} Received!"
    end
  end
end

Boot the app (rails server), visit http://127.0.0.0:3000 and you'll see the new log lines in your development.log. So what? What's the difference to calling Rails.logger in an action or callback inside your controller? Why is ActiveSupport::Notifications fabulous?

ActiveSupport::Notifications Scales

First, as explained in the intro, the main advantage is that the publisher is decoupled from the subscriber. For instance, you can have more than one subscriber listening to process_action.action_controller.

# config/initializers/slowlog_subscriber.rb

module ActionController
  class SlowlogSubscriber < ActiveSupport::Subscriber
    attach_to :action_controller

    def process_action(message)
      return if message.duration <= 10

      controller_location = [message.payload[:controller], message.payload[:action]].join("#") # -> ThingsController#something
      Rails.logger.debug "#{controller_location} was slow (#{message.duration}ms)" 
    end
  end
end

You are free to organize this however you want. Decouple publisher/subscriber in different files, chronological or even in different threads.

# config/initializers/poor_mans_background_job_subscriber.rb

module ActionController
  class PMBGJSubscriber < ActiveSupport::Subscriber
    include Concurrent::Async

    attach_to :action_controller

    def process_action(message)
      async.background_job(message)
    end

    def background_job(message)
      # ...do something expensive with the message in a thread
      sleep(60)
    end
  end
end

Activesupport::Notifications Is Everywhere Today

Second, and you probably already guessed this from the example, what makes this most awesome are the ready made messages that are already published today.

Rails for instance uses ActiveSupport::Notifications to publish close to 50(!) different instrumentation events that include data about your application. Data ranging from the HTTP status code of your requests, over which partials were rendered, to more esoteric measurements like the byte range attempted to be read from your ActiveStorage service. Check the instrumentation guide for all the dirty secrets.

ActiveSupport::Notifications Is Easily Extendible

Last but not least, you can not only listen to messages others publish, you can publish messages to yourself.

ActiveSupport::Notifications.instrument "cool_thing_happened.my_app", {some: :data} do
  MyApp.do_cool_thing(true)
end

Okay, you're convinced I hope! Now what do people do with ActiveSupport::Notifications out in the world?

Application Health/Performance Monitoring

Ever wondered how your metrics get to Sentry, New Relic, Datadog or Skylight? You guessed it, via ActiveSupport::Notifications.

Now if the main work, publishing tons of messages through a pub-sub architecture, is already done by Rails, surely there are non-SaaS (a.k.a. Software Libre) options to display this data, right? Turns out there are not. While evaluating options for some of my projects (especially Open Build Service) we came across this gap and started to fill it.

How, why and where? Read on in the next part of this series: Measure twice, cut once: App Performance Monitoring with influxdb-rails

Hoy toca hablar de formación. Quiero presentaros los Cursos Linux gratuitos de Antonio Sánchez Corbalán, una oportunidad de seguir aprendiendo más sobre los sistemas GNU/Linux. Dentro de su catálogo nos podremos encontrar tanto cursos para principiantes como para iniciados en este mundo libre.

Cursos Linux gratuitos de Antonio Sánchez Corbalán

Tuve el gusto de conocer a Antonio Sánchez el pasado 5 de marzo, en la emisión de un programa de Somos Tecnológicos de José Picón en Radio Bétera, que evidentemente pondré al final del artículo.

En este programa, en el que además estuvo presente David Marzal, conocí a un profesional en lo que refiere a la creación, desarrollo y mentorización ya que parte de su trabajo es el mantenimiento de diversos cursos Linux que podemos ver en su web: A. Sánchez Corbalán.

El mismo se define como «LPI Trainer Partner y profesor de informática desde hace más de 15 años.» y nos ofrece un catálogo de cursos variado, teniendo en su listado tanto cursos gratuitos como de pago e incluso certificados.

De momento podemos elegir entre:

• Comandos de Linux. Aprende desde cero (GRATUITO)
• Shell Bash de Linux: comandos para el manejo de texto (GRATUITO para lectores del blog)
• Comandos Linux: desde cero hasta programar Shell Script
• LPI Linux Essentials (Certificado)
• Curso LPic-1 Administrador de sistemas Linux (Certificado)

Los cursos siempre se componen de tres elementos básicos: vídeos explicativos, ejercicios prácticos y la posibilidad de tutorías personalizadas con lo que nunca te podrás sentir perdido.

Además, Antonio Sánchez nos ofrece también un blog donde nos habla de nociones de programación y aspectos variados del sistema GNU/Linux, una forma más de seguir aprendiendo de la mano de un maestro.

Y como lo prometido es deuda, aquí abajo podéis escuchar el programa de Somos Tecnológicos de Radio Bétera donde se entrevista al creador y mantenedor de los cursos.

El comando split es una de las herramientas de coreutils del sistema GNU con kernel Linux

El comando split sirve para dividir un archivo grande en varios archivos pequeños. Podemos realizar esa división por número de líneas, por tamaño u otras opciones.

Este artículo está inspirado por el artículo escrito por Solene para su blog, que puedes leer en este enlace.

Split está disponible para sistemas GNU/linux gracias a Torbjorn Granlund y Richard M. Stallman. Y disponible en los GNU coreutils, por lo que seguro está disponible en tu distribución.

La funcionalidad es el poder dividir un archivo grandes en varios más pequeños. Bien divididos por líneas o por tamaño de archivo. El uso básico sería:

split archivo.txt

De manera predeterminada y sin más configuraciones divide el archivo en archivos de 1000 líneas cada uno. Archivos que comienza por x y después dos letras comenzando por aa y continuando por ab, ac, etc… Pero por supuesto podemos cambiar ese comportamiento.

Podemos dividir el archivo en archivos de 100 líneas cada uno mediante:

split -l 100 archivo.txt

También podemos dividir el archivo grande en archivos más pequeños y cada uno de un tamaño determinado, por ejemplo 10 Megas:

split -b 10M archivo.txt

Podemos hacer que nuestros archivos divididos no terminen con letras como hemos visto (aa, ab, ac) si no que vayan numerados empezando por el 0. Para ello utilizamos la opción -d:

split -d -b 10M archivo.txt

Pero quizás queremos que no sean números de dos dígitos, si no de 2 o más, para ello añadimos la opción -a y el número de dígitos que queremos:

split -a 3 -d -b 10M archivo.txt

También podemos cambiar el nombre x que le pone el comando split por un prefijo que nosotros determinemos. Para ello escribimos nuestro prefijo detrás del nombre del archivo. En este caso sustituiremos la x por logs_

split -a 3 -d -b 10M archivo.txt logs_

Quizás queremos dividir nuestro archivo no en líneas o no por tamaño, si no simplemente porque queremos forzar el comando para que lo divida en un número determinado de archivos. Para ello usaremos la opción -n y lo dividiremos en 5 partes:

split -n 5 archivo.txt log_

Con todo esto y mucho más podemos utilizar el comando split en GNU/Linux para dividir archivos, pero ¿y si queremos volver a unir los archivos en uno solo?

Para eso utilizamos el comando cat. Por ejemplo, si tenemos los 5 archivos divididos en una carpeta, que se llaman xaa, xab, xac, xad, aae y los queremos unir en un archivo llamado log.txt:

cat xa* > log.txt

Podemos comprobar que el archivo generado es idéntico al que utilizamos originalmente para dividirlo mediante la suma de verificación que nos genera el comando sha256sum

sha256sum archivo.txt log.txt

Y los valores que nos de, deberán ser idénticos.

Espero que te haya resultado interesante. Tienes más opciones con el comando csplit. Te recomiendo que leas la documentación de ambos y escojas el que más te interese.