Excalidraw es una herramienta para poder realizar diagramas como dibujados a mano en una pizarra blanca pero en tu navegador y además también colaborativa

Probando excalidraw (clic sobre la imagen para ampliar)

Muchas veces las mejores ideas surgen dibujando sobre una servilleta en un bar o en un retazo de papel. A veces es mejor dibujar diagramas o ideas a mano alzada para después ir perfilando y definiendo las cosas más adelante.

Y en época del auge del teletrabajo qué mejor que utilizar una “pizarra en blanco” virtual sobre la que ir perfilando a mano alzada tus ideas, planes, etc. Y mejor si permite colaborar y además es software libre. Eso es Excalidraw.

Excalidraw es un programa con el que podrás realizar diagramas de flujo o representar ideas de forma esquemática a mano alzada como si estuvieras delante de una pizarra, pero desde tu navegador web.

El código de Excalidraw está liberado bajo una licencia MIT, por lo que puedes utilizar su código que está en GitHub, y puedes instalarlo en un servidor propio o puedes utilizar una instancia de Excalidraw para probar la herramienta.

Excalidraw es muy básico en cuanto a qué puedes dibujar, pero a la vez creo que suficiente para expresar ideas, flujos de trabajo, bocetos, etc.

Puedes dibujar figuras geométricas, líneas, flechas, textos, y seleccionar diferentes tipos de trazos para estos elementos, diferentes colores, etc.

Tiene la opción de guardar lo dibujado en un formato propio para después si se quiere abrirlo con excalidraw, también se puede exportar como PNG o SVG o compartir el enlace del dibujo:

• https://excalidraw.com/#json=5723465818570752,4V3o69sQ4h-wZ1RFQF4pTg

Si utilizas la instancia de excalidraw el contenido es cifrado de extremo a extremo, por lo que nadie, ni siquiera en excalidraw puede saber qué contenido es el que se representa.

Y también se puede compartir el enlace para colaborar y que varias personas puedan modificar el dibujo de manera colaborativa, añadiendo o quitando y cada cual expresándose.

Está disponible en Español y muchos otros idiomas, por lo que además de ser intuitivo es sencillo de manejar gracias a los mensajes emergentes en un idioma propio!

¡¡Quizás tu próximo gran plan de dominación mundial sea con software libre y lo esboces con Excalidraw!!

Enlaces de interés

• https://github.com/excalidraw/excalidraw
• https://excalidraw.com/
• https://blog.excalidraw.com/

Introduction

YaST2 is a venerable project that has been around for more than 20 years now. It keeps evolving and, with every SUSE and openSUSE release, it takes several new features (and a couple of new bugs). Needlessly to say that, to some extent, YaST2 is showing its age. We are aware of it, and we have been working to tackle this problem. The successful rewrite of the storage layer, which brought many features, is an example we can feel proud of.

Now that the development of SLE 15 SP2 and openSUSE Leap 15.2 features is mostly done, we have started to look to AutoYaST. The purpose of this article is to present our initiative to modernize AutoYaST.

First of all, let’s make it clear: we do not plan to rewrite AutoYaST. What we want to do is:

• Fix several bugs and remove some known limitations.
• Improve the tooling around AutoYaST.
• Introduce a few features that can help our users.
• Work hard to improve code quality.

Although nothing is set in stone yet, this document tries to present some ideas we are considering. But they are just that, ideas. We have identified the main areas that we want to improve, and now we are trying to come up with a more concrete (and realistic) plan.

Creating a profile does not need to be hard

Perhaps one of the main complaints about using AutoYaST is that writing a profile can be tricky. The easiest way is to perform a manual installation and generate the profile from the command line or using the AutoYaST UI.

If you decide to go for the command line approach, yast2 clone_system generates an XML file containing all the details from the underlying system. The generated profile is quite long, and usually you want to make it shorter by removing unimportant sections. For instance, you do not need the full list of users (the corresponding packages creates them) or services.

The alternative is to use the AutoYaST UI, which is a tool that allows you to create and edit profiles, although it has several bugs that we need to fix.

As part of this modernizing AutoYaST initiative, we would like to make things easier when it comes to deal with profiles. We are considering a few options:

• Improve AutoYaST UI quality.
• Provide a set of templates you can base on: minimal, hardening, etc.
• Optionally, do not export the default options, making the profile shorter.
• Implement a wizard that can guide you through the process of creating a profile from scratch (selecting the product, the list of add-ons, the filesystem type, etc.). It could also offer a CLI:

$ yast2 autoyast_profile --product SLES-15.2 \
  --addons sle-module-basesystem,sle-module-development-tools \
  --regcode XXXX \
  --filesystem btrfs

Integrated profile validation

One of the advantages of using XML is that we can rely on the existing tools to validate the profile. The AutoYaST Guide documents the usage of xmllint and jing for that. As part of this initiative, we would like to integrate the validation within the installation process. So one of the first things that AutoYaST would do is checking whether the profile is valid or not.

However, this kind of validation does not detect logical problems. Some of them are easy to find by just analyzing the profile, and we could consider adding some additional checks. But there is another whole category of problems that you cannot anticipate. For instance, consider that you want to reuse a partition that does not exist. And that brings us to the next topic: error reporting.

Better error reporting

If something unexpected happens during the installation, AutoYaST reports the issue. The user can decide whether a problem should stop the installation or not depending on its severity. Obviously, in some cases, the installation is simply not possible and AutoYaST aborts the process.

Error reporting infrastructure can be improved. For instance, it would be nice to group related messages and show them at once, instead of stopping the installation several times. Fortunately, during the storage layer rewrite, we introduced a mechanism that enables us to do that. Now it is a matter of extending its API and using it in more places.

Another nice feature could be to allow filtering the messages not only by its severity but by its module as well (e.g., partitioning warnings only), offering more control on error reporting. And the new code would enable us to do that.

Getting rid of the 2nd stage

Depending on the content of the profile, the installation would be finished after the first reboot. In the past, SUSE and openSUSE installation took place in two phases known as stages, but that it is not true anymore for the manual installation. However, AutoYaST still requires that in some cases. For instance, if you use the <files> section, AutoYaST copies the files after rebooting.

We plan to move everything we can to the 1st stage, skipping the 2nd stage entirely. We will keep the 2nd stage, though, because third party modules could use it as an extension point. But YaST2 core modules should avoid it.

To be honest, it sounds easier than it is (there are some corner cases to consider), and we are still checking whether it is technically possible.

Introducing dynamic profiles

In some situations, it is desirable to modify a profile at runtime. For instance, let’s consider that you want to install several machines with different software selections. The profiles would be almost identical, so it does not make sense to keep one for each machine.

AutoYaST already offers two mechanisms for that: rules and classes and pre-install scripts.

The first one is a feature that, for some reason, remains relatively unknown. It allows to combine several XML files depending on a set of rules which are applied at runtime. Although it is quite powerful, their specification is really verbose and the merging process can be rather confusing in some cases.

Alternatively, pre-install scripts are widely used. You can then rely on the classical Linux tools (sed, awk, etc.), or Python, or Perl, or Ruby… well, you cannot use Ruby, but that is something we will fix. :sweat_smile:

However, we have been thinking about making things even easier by allowing to embed Ruby (ERB) in AutoYaST profiles:

<?xml version="1.0" encoding="utf-8"?>
<partitioning config:type="list">
  <drive>
    <!-- vda, sda, ... -->
    <device><%= script("find_root_device.sh") -%></device>
    <use>all</use>
  </drive>
</partitioning>

<%= include_file("https://example.net/profiles/software-#{node["mac"]}.xml") %>
    
<% if arch?("s390x") -%>
<dasd>
  <!-- dasd configuration -->
</dasd>
<% end -%>

Please, bear in mind that it is just an example, and we do not even know whether this feature makes sense to you. Does it?

Conclusions

After reading this document, there is a chance that you have comments or new ideas to discuss. And we would love to hear from you! So you can reach the YaST team through the yast-devel or opensuse-autoinstall mailing lists or, if you prefer, we are usually at #yast channel at Freenode.

Finally, we would like to thank everyone that got involved in the discussions (e.g., The (near) future of AutoYaST and AutoYaST tools: feedback wanted) and our colleagues at SUSE for providing feedback and ideas.

openSUSE akan mengadakan openSUSE Virtual Summit pada 1 Mei. Semua waktu pada jadwal adalah Waktu UTC. Acara akan akan berlangsung di opensuse.reqmagic.com. Anda dapat mendaftar di events.opensuse.org pada 30 April.

Simak pembicara dari Indonesia, diantaranya

1. Anak Agung Bagus Arya Wiradarma – IT Risk Management Based on ISO 31000 and OWASP Framework using OSINT (Case Study: Election Commission of X City).
2. Estu Fardani – Introduction Podman for Beginner.
3. Kukuh Syafaat – Translating Open Source Apps.

Hi,

The SUSE Linux Enterprise Team is acknowledging the openSUSE community needs for a better and transparent collaboration with SUSE. We have now a momentum to think and be different.

The symbiosis between SUSE Linux Enterprise and openSUSE is real, we share so much more than just code, we use the same tools like Open Build Service, openQA, similar maintenance processes, people (Release Managers, contributors, etc) and more.

We might have been a bit quiet in the past but that doesn’t mean we didn’t evolve; over the years, we have created more bonds like Package Hub, foster our contribution with SLE Factory First Policy for SUSE employees and our Technology Partners, be more accessible during our development phase with the SLE Public Beta Program, just to name a few examples.

But now we have a momentum to accelerate, especially with regard to being more transparent with our defects and feature requests for the benefit of the openSUSE distribution and community. So we heard you, and today we want to clarify and improve processes, for all of us, and give some inputs on SUSE internal discussions about kicking out the so called “closed doors”.

So without further ado, here is our action items:

• Refresh and create openSUSE wiki pages for processes clarification
  • Luboš Kocman has already started with documenting the process in place for retrieving SLE Feature Requests and his plan is to present a real and better feature process for external contributors by October or sooner.
  • We will also review and improve “how to contribute , openSUSE Leap development phase” to clarify and formalize information that existed for years, but was not documented.
  • Create new page about our “SLE Factory First Policy”, and potential maintenance and quality assurance topics.
• Talk more openly about openSUSE and SLE relationship,
  • “Current and Future strategy for openSUSE Leap” and “Jump! Current state and upcoming changes” during openSUSE virtual summit.
  • Upcoming topic in the “How SUSE Builds its Enterprise Linux Distribution” blog post.
  • A talk about “relationship in between SLE and openSUSE” at the Virtual SUSECon.
• Find the proper way to open our bugzilla.suse.com
  • SUSE is fully committed to protect our customers and partners private data hosted in our tool like Bugzilla. They trust us with their highly sensitive data, so we approach this topic very seriously. However thanks to the full handover of the Bugzilla instances from MicroFocus to SUSE, we now have full control over Bugzilla thus we can now discuss how to change our processes internally to combine data privacy and openness.
  • A group has been formed (Vincent Untz, Anna Maresova and Vincent Moutoussamy) to drive this project internally and will be in charge of discussing the proposal with all stakeholders including the openSUSE community of course.
• Special attention to openSUSE 15.2 (and future) Leap bug reports
  • Last but not least, Luboš Kocman, openSUSE Leap Release Manager, is committed to review, triage openSUSE Leap 15.2 bugs and feature requests (create a bug for openSUSE Leap 15.2), and escalate to SLE Product and Release Manager.

We believe this is an exciting and ambitious plan, and we hope to share more concrete information as soon as possible.

In the mean time, do not hesitate to engage with the presenters of “openSUSE and SLE” talks, Luboš obviously, and feel free to comment or send us your feedback here in this thread.

Stay tuned, stay home, stay safe and stay green.

The SUSE Linux Enterprise Team

Ya he hablado de esta serie de charlas online que cada noche se están realizando HackLab Almería. En este caso os invito a asisitir a la ponencia «Escribir con Markdown + Pandoc, segunda parte» que será realizada por mi amigo Rubén Gómez este jueves 30 de abril. ¿Quieres más detalles? Sigue leyendo.

Escribir con Markdown + Pandoc, segunda parte

Desde mediados del pasado mes de marzo, la HackLab Almería, con las etiquetas de #gentequehacecosas y #YoMeQuedoEnCasa, está organizando una serie de vídeos de más o menos una hora de duración en la que nos están presentando o explicando multitud de proyectos libres.De esta forma ya llevan unas 25 charlas realizadas y puestas a disposición de todos los usuarios en su canal de Youtube.

Y siguen, porque este jueves 30 de Abril a las 21:00, a través de uno de los mejores servicios de videollamada OpenSource que existe, Jitsi se va a realizar una nueva charla, esta vez a cargo de Rubén @Razlobo Gómez Antolí.

Como es habitual, no es necesaria instalación ninguna ni inscripción previa; solo abre el navegador que más te guste y abre el siguiente enlace:

https://meet.jit.si/hacklabalm_markdown_pandoc2

Además, y para evitar saturación en la sala Jitsi, se habilitará la retransmisión en directo a través de youtube.

¿De qué va la charla?

Simplemente vemos las notas de la ponencia donde nos explican que para quienes no lo sepan:

«Markdown se ha convertido en el lenguaje de marcas de moda gracias a su facilidad de aprendizaje y su utilización en varias plataformas de control de versiones y en creadores de espacios web.

Pero Markdown, gracias a la utilización de la herramienta Pandoc, se puede convertir en un lenguaje de creación de todo tipo de documentos con posibilidades de distintos formatos de salida: pdf, epub, odt, html…

Markdown y Pandoc es una pareja ganadora, pero, además, se pueden integrar otras utilidades como puede ser el lenguaje estadístico Gnu/R que nos permite realizar documentos reutilizables o informes automatizados.

Tras una primera charla de introducción, en esta segunda seguimos por donde nos quedamos y añadimos nuevas cosas a hacer con nuestros documentos, como cambiar la maquetación del documento, obtener distintas salidas desde el mismo documento o explicar acerca de la documentación reproducible.»

Aprovecho para comentar que ese día también se realizará otra charla, titulada «DDD con Node.js es posible» a cargo de Konstantin Knyazev que por supuesto también os invito asistir.

Más información: HackLab Almería Documentos con Markdown y padoc |AlmeríaJS abril (on-line): DDD con Node.js es posible

La utilidad exa para la línea de comandos de GNU/Linux es una forma más visual y más colorida de listar los archivos de una carpeta como reemplazo al conocido comando ls

exa vs ls (clic sobre la imagen para ampliar)

Supongo que cuando estás en la línea de comandos de GNU/Linux uno de los comandos más utilizados es ls (o algún alias que tengas configurado) para listar los archivos que están en una carpeta de tu equipo.

Pero hoy quiero darte a conocer una herramienta para la consola de GNU/Linux llamada exa, que hace eso exactamente, mostrar el contenido de una carpeta, pero de una manera algo diferente.

La utilidad exa estáescrita en Rust y disponible para varias distribuciones de GNU/Linux como openSUSE, Arch, Fedora o Gentoo y está publicada bajo una licencia MIT.

Exa, muestra la salida de manera predeterminada ya coloreada. Así es más sencillo de un vistazo diferenciar archivos de carpetas y distintos tipos de archivos entre sí.

Además también diferencia por colores los permisos de los archivos y el usuario al que pertenecen. Otra cosa interesante es que a la hora de mostrar la fecha de modificación lo hace en el formato dd/MM/AAAA y no al modo anglosajón.

Además si estás en una carpeta que contiene un repositorio de Git, exa también muestra información sobre el estado del archivo.

También tiene la opción de poder mostrar tus archivos en un “árbol” tal como hace el comando tree, pero el tree propio de exa sigue mostrando la información de todos los archivos. Simplemente ejecuta

exa --tree

Pero además de la configuración predeterminada, también se pueden añadir otras informaciones a los datos que muestra exa, como el número de enlaces que posee un archivo, fechas de creación o de último acceso a los archivos, el grupo de usuario al que pertenece un archivo, etc

Como extra, te recomiendo que crees un alias en tu sistema como el siguiente:

alias exa="exa --long --header --git"

Para que de manera predeterminada muestre el formato largo, el texto con la cabecera encima de cada columna, y si estás en un repo de Git muestre información de cada archivo.

Te animo a que pruebes esta utilidad en tu sistema como reemplazo a ls y verás que quizás no quieras volver atrás…

Enlaces de interés

• https://the.exa.website/
• https://github.com/ogham/exa

I started using Emacs in 1995, and since then I have been carrying a .emacs that by now has a lot of accumulated crap. It is such an old configuration that it didn't even use the modern convention of ~/.emacs.d/init.el (and it looks like a newer Emacs version will allow .config/emacs as per the XDG standard... at last).

I have wanted to change my Emacs configuration for some time, and give it all the pretty and modern toys.

The things that matter the most to me:

• Not have a random dumpster in ~/.emacs if possible.
• Pretty colors.
• Magit.
• Rust-mode or whatever the new thing is for rust-analyzer and the Language Server.

After looking at several examples of configurations that mention use-package as a unified way of loading packages and configuring them, I found this configuration which is extremely well documented. The author does literate programming with org-mode and elisp — something which I'm casually interested in, but not just now — but that way everything ends up very well explained and easy to read.

I extracted bits of that configuration and ended up with the following.

Everything in ~/.emacs/init.el and with use-package

;; Initialize package system

(require 'package)

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

(package-initialize)
;(package-refresh-contents)

;; Use-package for civilized configuration

(unless (package-installed-p 'use-package)
  (package-install 'use-package))
(require 'use-package)

(setq use-package-always-ensure t)

~/.emacs.d/custom.el for M-x customize stuff

;; Set customization data in a specific file, without littering
;; my init files.

(setq custom-file "~/.emacs.d/custom.el")
(load custom-file)

Which-key to get hints when typing command prefixes

;; Make it easier to discover key shortcuts

(use-package which-key
  :diminish
  :config
  (which-key-mode)
  (which-key-setup-side-window-bottom)
  (setq which-key-idle-delay 0.1))

Don't pollute the modeline with common modes

;; Do not show some common modes in the modeline, to save space

(use-package diminish
  :defer 5
  :config
  (diminish 'org-indent-mode))

Magit to use git in a civilized fashion

;; Magit

(use-package magit
  :config
  (global-set-key (kbd "C-x g") 'magit-status))

Move between windows with Shift-arrows

;; Let me switch windows with shift-arrows instead of "C-x o" all the time
(windmove-default-keybindings)

Pretty colors

I was using solarized-dark but I like this one even better:

;; Pretty colors

(use-package flatland-theme
  :config
  (custom-theme-set-faces 'flatland
   '(show-paren-match ((t (:background "dark gray" :foreground "black" :weight bold))))
   '(show-paren-mismatch ((t (:background "firebrick" :foreground "orange" :weight bold))))))

Nyan cat instead of scrollbars

;; Nyan cat instead of scrollbar
;; scroll-bar-mode is turned off in custom.el

(use-package nyan-mode
  :config
  (nyan-mode 1))

Move buffers to adjacent windows

;; Move buffers between windows

(use-package buffer-move
  :config
  (global-set-key (kbd "<C-S-up>")     'buf-move-up)
  (global-set-key (kbd "<C-S-down>")   'buf-move-down)
  (global-set-key (kbd "<C-S-left>")   'buf-move-left)
  (global-set-key (kbd "<C-S-right>")  'buf-move-right))

Change buffer names for files with the same name

;; Note that ‘uniquify’ is builtin.
(require 'uniquify)
(setq uniquify-separator "/"               ;; The separator in buffer names.
      uniquify-buffer-name-style 'forward) ;; names/in/this/style

Helm to auto-complete in grand style

(use-package helm
 :diminish
 :init (helm-mode t)
 :bind (("M-x"     . helm-M-x)
        ("C-x C-f" . helm-find-files)
        ("C-x b"   . helm-mini)     ;; See buffers & recent files; more useful.
        ("C-x r b" . helm-filtered-bookmarks)
        ("C-x C-r" . helm-recentf)  ;; Search for recently edited files
        ("C-c i"   . helm-imenu)
        ("C-h a"   . helm-apropos)
        ;; Look at what was cut recently & paste it in.
        ("M-y" . helm-show-kill-ring)

        :map helm-map
        ;; We can list ‘actions’ on the currently selected item by C-z.
        ("C-z" . helm-select-action)
        ;; Let's keep tab-completetion anyhow.
        ("TAB"   . helm-execute-persistent-action)
        ("<tab>" . helm-execute-persistent-action)))

Ripgrep to search in grand style

;; Ripgrep

(use-package rg
  :config
  (global-set-key (kbd "M-s g") 'rg)
  (global-set-key (kbd "M-s d") 'rg-dwim))

(use-package helm-rg)

Rust mode and Language Server

Now that RLS is in the process of being deprecated, it's getting substituted with rust-analyzer. Also, rust-mode goes away in favor of rustic.

;; Rustic, LSP

(use-package flycheck)

(use-package rustic)

(use-package lsp-ui)

(use-package helm-lsp
  :config
  (define-key lsp-mode-map [remap xref-find-apropos] #'helm-lsp-workspace-symbol))

Performatively not get distracted

;;; Show a notification when compilation finishes

(setq compilation-finish-functions
      (append compilation-finish-functions
          '(fmq-compilation-finish)))

(defun fmq-compilation-finish (buffer status)
  (when (not (member mode-name '("Grep" "rg")))
    (call-process "notify-send" nil nil nil
          "-t" "0"
          "-i" "emacs"
          "Compilation finished in Emacs"
          status)))

Stuff from custom.el

The interesting bits here are making LSP work; everything else is preferences.

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(column-number-mode t)
 '(custom-safe-themes
   (quote
    ("2540689fd0bc5d74c4682764ff6c94057ba8061a98be5dd21116bf7bf301acfb" "bffa9739ce0752a37d9b1eee78fc00ba159748f50dc328af4be661484848e476" "0fffa9669425ff140ff2ae8568c7719705ef33b7a927a0ba7c5e2ffcfac09b75" "2809bcb77ad21312897b541134981282dc455ccd7c14d74cc333b6e549b824f3" default)))
 '(delete-selection-mode nil)
 '(lsp-rust-analyzer-display-chaining-hints t)
 '(lsp-rust-analyzer-display-parameter-hints nil)
 '(lsp-rust-analyzer-macro-expansion-method (quote rustic-analyzer-macro-expand))
 '(lsp-rust-analyzer-server-command (quote ("/home/federico/.cargo/bin/rust-analyzer")))
 '(lsp-rust-analyzer-server-display-inlay-hints nil)
 '(lsp-rust-full-docs t)
 '(lsp-rust-server (quote rust-analyzer))
 '(lsp-ui-doc-alignment (quote window))
 '(lsp-ui-doc-position (quote top))
 '(lsp-ui-sideline-enable nil)
 '(menu-bar-mode nil)
 '(package-selected-packages
   (quote
    (helm-lsp lsp-ui lsp-mode flycheck rustic rg helm-rg ripgrep helm-projectile helm buffer-move nyan-mode flatland-black-theme flatland-theme afternoon-theme spacemacs-theme solarized-theme magit diminish which-key use-package)))
 '(rustic-lsp-server (quote rust-analyzer))
 '(scroll-bar-mode nil)
 '(scroll-step 0)
 '(tool-bar-mode nil))
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 )

Results

I am very happy with rustic / rust-analyzer and the Language Server. Having documentation on each thing when one moves the cursor around code is something that I never thought would work well in Emacs. I haven't decided if I love M-x lsp-rust-analyzer-inlay-hints-mode or if it drives me nuts; it shows you the names of function arguments and inferred types among the code. I suppose I'll turn it off and on as needed.

Some days ago, before using helm, I had projectile-mode to work with git checkouts and I was quite liking it. I haven't found how to configure helm-projectile to work; I'll have to keep experimenting.

Inicio una serie sobre los cambios en las aplicaciones que han llegado este mes. Empiezo con las novedades Dolphin de abril de 2020, el gestor de ficheros más potente, versátil y funcional que puedes tener en tu escritorio, ya sea libre (GNU/Linux) o privativo (Windows/Mac).

Las novedades Dolphin de abril de 2020

Lo he dicho muchas veces pero lo repetiré mil más. ¡Qué suerte tiene la gente que no ha probado Dolphin que no se sienten inútiles al utilizar otro explorador de ficheros!

Y es que por configuración, funcionalidades, flexibilidad y eficiencia creo que no hay mejor gestor de ficheros que Dolphin. Y encima los desarrolladores no dejan de mejorarlo y afinarlo en cada versión.

Hoy me complace compartir con vosotros el listado de mejoras que ha recibido este gestor de archivos de KDE en su última gran actualización de abril de 2020, y de paso me pongo yo al día realizando las correspondientes pruebas.

• Mejorada la interacción con los sistemas de archivos remotos, como recursos compartidos Samba y servidores SSH. De esta forma ahora es posible empezar a ver películas almacenadas en lugares remotos sin necesidad de descargarlas primero, ya que se transmiten directamente desde la nube al reproductor multimedia a través de Dolphin. Probado y confirmado que funciona a la perfección.
• Optimizada la conexión con recursos compartidos Samba de Windows y así poder aprovecharse de todos los servicios que ofrecen. Ahora se pueden descubrir estos recursos mediante el protocolo «WS-Discovery» que usan las versiones modernas de Windows y así poder integrar su equipo Linux de un modo transparente en una red de Windows. Esto no lo he podido probar ya que no tengo dispositivos Windows.
• Nueva funcionalidad  «Duplicar», que permite seleccionar uno o más archivos o carpetas y crear un copia instantánea (sin borrar los originales) con el botón derecho y pulsando en pulsando «Duplicar aquí». También se puede utilizar Crtl + D. Parece una tonterías, pero ahorra tres pasos, optimizando el tiempo de trabajo.

• Añadida la búsqueda de archivos no solo por su nombre o por su contenido, sino también por sus etiquetas. Lo he probado poniendo mis primeras etiquetas.
• Soporte integrada de archivos 7Zip. De esta forma se puede navegar por estos archivos comprimidos como si se tratara de carpetas del sistema de archivos.
• Acceso rápido a a aplicaciones de búsqueda externas como KFind, mediante la creación de un enlace.
• Añadida el acceso rápido de teclado Ctrl + Mayúsculas + F4 para mover el foco desde y hacia el panel de terminal.  Es decir, mueve el puntero al terminal o lo saca de él al pulsar la combinación. Muy útil.

Más información: KDE

Veamos cómo comprobar que un archivo .iso que hemos descargado no ha sufrido manipulaciones por parte de terceros y que se ha descargado correctamente

A la hora de descargar una  distribución de GNU/Linux para instalarla en nuestro equipo, es importante comprobar que dicha ISO no ha sido manipulada por terceros y que en el proceso de descarga no ha sufrido ningún problema.

En este caso voy a comprobar que la recién salida ISO de Ubuntu Focal Fossa 20.04 está correcta, es la que los desarrolladores publicaron y no ha sufrido problemas durante la descarga.

Para realizar estas comprobaciones, necesitaremos tener instalado gpg en nuestro sistema operativo y descargar tanto el archivo ISO como el archivo con la suma de verificación y la firma de ese archivo todo disponible desde aquí.

¿Qué es cada cosa?

• El archivo ISO es la propia imagen del sistema operativo que instalaremos y que debemos comprobar que es íntegra
• El archivo SHA256SUM es un archivo en el que se incluyen la suma de verificación de dicha ISO
• El archivo SHA256SUM.gpg es la firma de ese archivo por parte de los desarrolladores de Ubuntu que certifica que ese archivo de suma de verificación es legítimo.

Pasos a seguir

1.- Descargar el archivo .iso y las sumas de verificación junto con la firma de ese archivo de las sumas de verificación.

2.- Comprobar que el archivo de suma de verificación está firmado por quien dice que es y no está falsificado ejecutando el comando

gpg --keyid-format long --verify SHA256SUMS.gpg SHA256SUMS

2.1.- Si no tenemos la clave pública deberemos importarla. Copiamos la clave y la importamos por ejemplo desde el servidor de claves de Ubuntu

gpg --keyid-format long --keyserver hkp://keyserver.ubuntu.com --recv-keys 0xD94AA3F0EFE21092

Deberá darnos un resultado de firma correcta:

Firma correcta de "Ubuntu CD Image Automatic Signing Key (2012) <cdimage@ubuntu.com>"

3.- Comprobar que la ISO coincide con la suma de verificación

sha256sum -c SHA256SUMS

Deberá darnos un mensaje de que la suma de verificación coincide:

ubuntu-20.04-desktop-amd64.iso: La suma coincide

Es importante realizar estos pasos para comprobar que la ISO es legítima, que coincide con la suma de verificación y que este archivo está firmado y certificado contra modificaciones por los desarrolladores de Ubuntu.

Si tienes correcciones y sugerencias utiliza los comentarios del blog para complementar la información.

Aquí te dejo un vídeo con el proceso. El vídeo está alojado en archive.org en formato webm

También está disponible en YouTube para quien prefiera esta plataforma

https://www.youtube.com/watch?v=dIhuqGDhG9w