Tal y como estaba previsto en el calendario de lanzamiento de los desarrolladores, hoy martes 22 de junio la Comunidad KDE ha comunicado que ha sido lanzada la segunda actualización de Plasma 5.22. Una noticia que aunque es esperada y previsible es la demostración palpable del alto grado de implicación de la Comunidad en la mejora continua de este gran entorno de escritorio de Software Libre.

Lanzada la primera actualización de Plasma 5.22

No existe Software creado por la humanidad que no contenga errores. Es un hecho incontestable y cuya única solución son las actualizaciones. Es por ello que en el ciclo de desarrollo del software creado por la Comunidad KDE se incluye siempre las fechas de las actualizaciones.

De esta forma, el martes 22 de junio ha sido lanzada la segunda actualización de Plasma 5.22, la cual solo trae (que no es poco) soluciones a los bugs encontrados en esta semana de vida del escritorio y mejoras en las traducciones. Es por tanto, una actualización 100% recomendable.

Más información: KDE

Las novedades básicas de Plasma 5.22

Aún tengo pendiente el resumen de las novedades pero he aquí la lista preliminar de ellas.

• Grandes mejoras visuales, donde destaca la nueva funcionalidad de transparencia adaptativa: esto significa que el panel y los widgets que contiene serán agradablemente translúcidos por norma general, aunque se volverán completamente opacos si existen ventanas maximizadas para evitar cualquier distracción.
• Nueva pantalla de inicio de las Preferencias del Sistema donde además de las acciones más habituales que solemos hacer los usuarios tendremos el acceso a los módulos que más utilizamos.
• Mejoras en las actualizaciones en diferido, útiles para algunos usuarios, no tanto para otros, y que como es habitual en esta versión se han pulido para contentar a todos.
• Los widgets de la Bandeja del sistema (situados normalmente en la parte inferior derecha del panel) son mucho más consistentes en aspecto y también más útiles
• Mejoras en KWin, Wayland, el lanzador de «todo» Kunner y, por supuesto, en las notificaciones.

Más información: KDE

使用 Xournal 在 PDF 簽名 in openSUSE Leap 15.2  小記

Voici le scénario le plus plausible :Vous êtes un développeur et de temps en temps devez soit tester un script/programme sur du Linux. Soit que vous n’avez pas les budgets pour bâtir autant de distributions nécessaires ou le MCO est contraignant. La bonne nouvelle : On peut installer WSL sous Windows 10. En effet, WSL (Windows […]

The post ssh & WSL 2 & openSUSE 15.3 et autres distributions Linux appeared first on Cybersécurité, Linux et Open Source à leur plus haut niveau | Network Users Institute | Rouen - Normandie.

Quiero compartir en el blog un par de complementos de zsh que me resultan muy útiles

En un artículo anterior, ya pudiste leer sobre cómo instalar zsh en openSUSE y cómo configurarlo añadiendo un tema y complementos desde el framework llamado oh my zsh!:

• https://victorhckinthefreeworld.com/2021/06/21/instalar-la-shell-zsh-en-opensuse/

Hoy quiero daros a conocer un par de complementos que no están en oh my zsh! pero que para mí son muy útiles. Veamos cuales son y cómo instalarlos.

Resaltado de sintaxis

Una de las cosas que echaba de menos de la shell Fish, es su resaltado de sintaxis. Me parece una funcionalidad muy útil.

Esto consiste, en que mientras estamos escribiendo un comando en la terminal, el comando se colorea de verde si está correctamente escrito y en rojo si no existe o hemos cometido un error al escribirlo.

Zsh no dispone de ese resaltado de sintaxis, pero tiene un complemento, que no está en oh my zsh!, que podemos instalar para tener esa funcionalidad.

Para ello nos colocamos en nuestra carpeta ~/.oh-my-zsh/plugins/ y ejecutamos lo siguiente, para clonar el código desde el repositorio en GitHub:

git clone git@github.com:zsh-users/zsh-syntax-highlighting.git

Sugerencias automáticas

Otra funcionalidad que me gusta mucho, es que zsh me sugiera comandos que ya he escrito. Así es más fácil y rápido acceder a rutas de carpetas a las que ya he estado, porque zsh me lo sugiere y con una tecla lo puedo ejecutar, sin necesidad de escribir de nuevo todo el comando.

En la misma carpeta de plugins clonaremos el código del complemento, mediante el comando:

git clone git@github.com:zsh-users/zsh-autosuggestions.git

Con este complemento, según vamos escribiendo un comando, si ya lo hemos ejecutado antes, se nos mostrará una sugerencia. Si queremos aceptar la sugerencia por completo, pulsaremos sobre la flecha del cursor hacia la derecha.

Con esto el complemento volverá a escribir todo y simplemente deberemos dar a Enter para ejecutar el comando.

Si solo queremos aceptar parte de la sugerencia, pulsaremos la tecla Control y la flecha hacia la derecha y se irán activando partes de la sugerencia, cuando queramos cambiar algo, simplemente escribiremos lo que deseemos cambiando la sugerencia y ya está.

Activar los complementos

Con lo descrito anteriormente, solo hemos clonado los repositorios en nuestro equipo, pero no los hemos activado, para ello editaremos el archivo .zshrc y buscaremos la cadena de texto plugins=(

A los complementos ya configurados dentro de los paréntesis, ahora deberemos añadir los dos anteriores. Escribimos los nombres: zsh-syntax-hightlighting y zsh-autosuggestions dentro del paréntesis y eso es todo.

Cerramos y volvemos a abrir nuestra terminal y ya podremos disfrutar de estas dos herramientas que nos harán trabajar en la terminal más sencillo y más rápido.

¡Después de esto, no querrás una terminal que no lo tenga activado!

Enlaces de interés

• https://github.com/zsh-users/zsh-syntax-highlighting

• https://github.com/zsh-users/zsh-autosuggestions

In an alternate universe, we still have 320x240px displays.

Disponibilizo a versão do openSUSE Leap 15.3 na AWS. Além de multiúso, completa estável e fácil de usar. Destina-se a usuários, desenvolvedores, administradores, e qualquer profissional que deseja os recursos openSUSE no servidor.

Disponibilizado proporcionando total compatibilidade com os pacotes binários do SUSE Linux Enterprise 15 Service Pack 3 (SP3), o openSUSE Leap 15.3 facilita a migração se necessário para o SUSE Linux Enterprise Server (SLES) de maneira quase imediata.

Vale o destaque para os pacotes de Inteligência Artificial (AI) como Grafana, ONNX, Prometheus, PyTorch e TensorFlow Lite, e o kernel Linux 5.3.18 que é totalmente mantido pela SUSE e com suporte ao hardware embarcados Raspberry Pi 4.

Esta distribuição atende usuários iniciantes, experientes e ultra geeks, em resumo, é perfeito para todos! Sugestões em cabelo@opensuse.org, Link da imagem AMI aqui: http://aws.amazon.com/marketplace/pp/B097HB12CP

Veamos cómo cambiar la shell a zsh en la distribución de GNU/Linux openSUSE

Cada vez doy un uso más intensivo de la terminal para muchas tareas. Y ya hace tiempo probé Fish como shell:

• https://victorhckinthefreeworld.com/2020/02/12/fish-la-shell-para-linux-amigable-e-interactiva/

Estaba contento con sus características de facilitar muchas tareas y ser muy visual en muchos casos. Me gustaba sobre todo su resaltado de sintaxis y sus sugerencias de comandos, basándose en el historial.

Pero hace un tiempo, decidí volver a bash. Y fue realmente cuando me dí cuenta de lo que echaba de menos ese par de funcionalidades y otras pequeñas opciones gráficas.

Así que decidí probar otra de las opciones, en este casó me decanté por una shell compatible con bash y que además incluye un buen montón de complementos que puedes utilizar para hacerla todavía más extensible.

Instalar zsh

Para instalarla en mi openSUSE, la puedes buscar en YaST o puedes instalarla desde la terminal con zypper mediante el comando:

zypper in zsh

Reemplazar bash por zsh

Una vez que ha acabado la instalación cambiaremos nuestra shell actual por la recién instalada zsh, para ello ejecutaremos el comando:

chsh -s /bin/zsh

Configurar el emulador de terminal Konsole

Como utilizo Konsole como emulador de terminal, además tuve que configurarlo para que abriera zsh. Para ello, clic derecho en una parte vacía de la terminal y editamos el perfil actual.

Y en la pestaña General en el apartado ejecutar orden, cambiamos a: /bin/zsh. Aplicamos los cambios y ya está.

Expandiendo zsh con oh my zsh!

Y al igual que Fish tenía la posibilidad de expandir las posibilidades con complementos y temas creados por la comunidad, con oh my Fish!

• https://victorhckinthefreeworld.com/2020/03/09/extiende-las-posibilidades-de-tu-shell-fish-con-oh-my-fish/

Zsh también tiene un framework con el que tener a mano un buen montón de temas y complementos para expandir más las posibilidades de zsh, llamado oh my zsh! Lo podemos instalar con una simple línea de comando:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/robbyrussell/oh-my-zsh/master/tools/install.sh)"

Clonará el repositorio en nuestro equipo dentro de la ruta ~/.oh-my-zsh y que se irá actualizando de manera automática periódicamente, para disfrutar de las mejoras y actualizaciones que lleguen al repositorio comunitario alojado en GitHub.

Cambiando el tema y añadiendo complementos en zsh

Ya que tenemos todo instalado, la verdad es que el tema predeterminado del prompt de zsh la verdad es que no me gusta mucho. Lo primero que he hecho es cambiar el tema y utilizar uno llamado “agnoster”

Para cambiar el tema, vamos a editar el archivo .zshrc de nuestro /home.

Lo abrimos y buscamos la cadena ZSH_THEME=” y cambiamos el texto dentro de las comillas para dejarlo de esta manera

ZSH_THEME="agnoster"

Pero antes de cerrar el archivo, vamos a añadir algún complemento. Los complementos están dentro de la carpeta ~/.oh-my-zsh/plugins y ahí en cada carpeta existe un archivo README que te indica qué hace el complemento, como podéis comprobar, la lista es extensa.

Si como yo, utilizas openSUSE (o SUSE) te recomiendo el complemento suse, que añade varios alias interesantes para la gestión de zypper desde la terminal.

Yo te recomiendo añadir git, suse, history y fzf (este requiere tener instalado el paquete fzf en tu equipo) para empezar. Para ello, en el mismo archivo, buscamos la cadena plugins=( y dentro del paréntesis añadimos los complementos que queramos, quedando así:

plugins=(git history suse fzf)

Si queremos añadir más complementos, los añadiremos dentro del paréntesis. Como ves los nombres van separados por espacios o también puedes utilizar saltos de línea, pero nunca otros símbolos como comas o barras, etc.

Como extra, también te aconsejaría añadir tus alias que estuvieras utilizando en bash. Simplemente copia tus alias y pégalos en el mismo archivo, quizás en la parte final del archivo, para que estén todos ordenados.

Ya podemos guardar los cambios en nuestro archivo. Cerrar la terminal y volver a abrirla para disfrutar de un zsh renovado y con nuevo aspecto.

Yo tengo un par de complementos más añadidos, pero ese quizás sea material para otro artículo… ¡Permanece a la escucha!

Conclusión

Si lees esto y te animas a darle una oportunidad a zsh como reemplazo a tu shell actual, espero que salgas satisfecho o satisfecha con el cambio, puedes compartir tus opiniones en los comentarios.

Enlaces de interés

• https://zsh.sourceforge.io/
• https://ohmyz.sh/
• ochobitshacenunbyte.com/que-es-zsh-y-como-utilizar-sus-temas-y-complementos/
• https://wiki.archlinux.org/title/Zsh_(Español)

Hoy es lunes, han finalizado los dos días de charlas del gran evento de la Comunidad KDE, y mientras esperamos al resumen del Dot de ayer, es un buen momento para comentar el programa social de Akademy 2021 en línea: manualidades, retos, juegos sociales y videojuegos son las prepuestas que nos esperan.

Programa social de Akademy 2021 en línea

Evidentemente una Akademy es ante todo un punto de encuentro entre los desarrolladores y es por eso que no se debe descuidar la parte social del mismo, aunque sea más complicado que menos debido a su modalidad en línea.

De esta forma los organizadores del evento han pensado y propuesto varias actividades para que sea posible acercarse al máximo al principal propósito de una Akademy. Las propuestas son las siguientes:

• Taller de Origami: Aprende a hacer figuras con papel.
  • Miércoles 23 a las 7:00 y 21:00 UTC.
• Pub Quiz: Concurso son reglas aleatorias y puntos inventados. El protagonista es nuestro escritorio.
  • Jueves 24 a las 21:00 UTC.
• Tiempo de juego: Únete a tus compañeros de Akademy en 3 juegos en los que competirás contra ellos, pero también tendrás la oportunidad de conoceros.
  • Lunes 21: 7:00 y 21:00 UTC
  • Martes 22 : 7:00 y 21:00 UTC
  • Jueves 24: 7:00 UTC
  • Viernes 25: 7:00 UTC
• SuperTuxKart: no podía faltar esta maravilla de la diversión y competición.
• Skribbl.io: dibuja y adivina lo que dibujan.
• Garticphone.com: más juegos de dibujo,

Evidentemente, os invito a visitar la página social para conocer los detalles de las propuestas.

¿Cómo participar en Akademy 2021 en línea?

Aprovecho para animaros a participar en las tres modalidades existentes:

Mira las ponencias y participa: Necesitarás una cuenta Matrix para ver las charlas y participar en el debate. Esto es diferente de tu cuenta de KDE Identity. Ten en cuenta que es posible que se te solicite que habilite la función Spaces en Matrix. Por favor, hazlo para disfrutar de la conferencia.

Sigue las salas como oyente en directo (Sala 1 y Sala 2): No necesitas nada, simplemente accedes a una página web con vídeo incorporado.

Sigue las ponencias por Youtube: Igual que el anterior pero con la posibilidad de verlo en diferido. Se trata de las emisiones en bruto por este canal, Seguramente en un futuro estarán en PeerTube.

Más información: Akademy 2021 | Social Events Akademy 2021

¿Qué es Akademy?

Para los que no lo sepan, Akademy es el evento de la Comunidad KDE que aúna en una gran conferencia todo tipo de simpatizantes de KDE como desarrolladores, diseñadores, usuarios, traductores, promotores, ideólogos, etc.

Allí se reunirán de forma virtual por segundo año consecutivo a lo largo de una semana para compartir charlas, ponencias, talleres, eventos sociales online y, en definitiva, para trabajar juntos.
Es una gran semana que sirve para unir más fuerte los lazos que unen nuestra Comunidad, así como para crear nuevos que se mantendrán gracias a las listas de correo, canales irc o Sprints.

Seguimos con el gran evento de la Comunidad KDE echando un vstazo al día 2 de Akademy 2021 en línea. No busquéis el día 1 porque al ser un día de introducción no se ha realizado resumen en el dot.

Día 2 de Akademy 2021 en línea

Ayer fue el primer día grande de Akademy 2021 en línea que se está celebrando del 18 al 25 de junio. Y digo que fue el primer gran día porque fue el primero en que tuvimos la oportunidad de ver una gran cantidad de charlas.

El resumen de esta jornada ya está publicado en la página de noticias de la Comunidad KDE, comúnmente conocida como el Dot y que se afana por ofrecernos noticias frescas, y más esta semana.

De esta forma os invito a leer toda la crónica que se ha publicado allí, donde quisiera destacar la intervención de Aleix Pol tanto como Presidente de KDE e.V. que hizo de presentador del ponente invitado Patricia Aas, co-fundadora de TurtleSec y desrrolladora de C++, y como ponente con su charla sobre el Objetivo Principal de la Comunidad «All about the apps»

Aprovecho para animaros a participar en las tres modalidades existentes:

Mira las ponencias y participa: Necesitarás una cuenta Matrix para ver las charlas y participar en el debate. Esto es diferente de tu cuenta de KDE Identity. Ten en cuenta que es posible que se te solicite que habilite la función Spaces en Matrix. Por favor, hazlo para disfrutar de la conferencia.

Sigue las salas como oyente en directo (Sala 1 y Sala 2): No necesitas nada, simplemente accedes a una página web con vídeo incorporado.

Sigue las ponencias por Youtube: Igual que el anterior pero con la posibilidad de verlo en diferido. Se trata de las emisiones en bruto por este canal, Seguramente en un futuro estarán en PeerTube.

Más información: Akademy 2021 | Akademy 2021 Día 2

¿Qué es Akademy?

Para los que no lo sepan, Akademy es el evento de la Comunidad KDE que aúna en una gran conferencia todo tipo de simpatizantes de KDE como desarrolladores, diseñadores, usuarios, traductores, promotores, ideólogos, etc.

Allí se reunirán de forma virtual por segundo año consecutivo a lo largo de una semana para compartir charlas, ponencias, talleres, eventos sociales online y, en definitiva, para trabajar juntos.
Es una gran semana que sirve para unir más fuerte los lazos que unen nuestra Comunidad, así como para crear nuevos que se mantendrán gracias a las listas de correo, canales irc o Sprints.

Recently, I was trying to learn how the io.Reader interface works in Go and implement my own custom reader. Before implementing a custom Reader let’s understand what they are.

Readers: What are they?

Readers are interfaces or classes that are implemented in various programming languages. Usually, readers take in an input interface that can usually be represented as an array and a length. The reader returns another stream that is usually a cut to the length of the original input. Readers are implemented in various programming languages as following:

• Java: readers are implemented by the interface java.io.Reader that implements read(char[], int, int) and close().
• C++: readers are implemented by the istream where the read function is depicted as follows istream& read (char* s, streamsize n);
• Go: readers are implemented by the io.Reader interface which has Read(p []byte) error.

In the above examples, readers in various programming language do the same thing; they read from the input stream and make a copy of the same into the char / byte array that is provided to the Read function.

Implementing custom Reader in Go

In this example, we will implement a reader that will add the capitalize the characters in the resulting byte array to which we want to copy the result into.

Note: This may or may not be suitable for production but is an example. I have also not seen examples of modifying the string.

Readers in Go need to implement the following language

type Reader interface {
	Read(p []byte) (n int, err error)
}

We will use 2 ways to implement the reader:

• By natively implementing the Read function.
• Using an already existing reader (strings.Reader)

Native implementation of the Read function

package main

import (
	"bytes"
	"fmt"
	"io"
	"log"
	"time"
)

// CapitalizeReader is a reader that implements io.Reader
// It read the bytes from a particular position and returns the number
// of bytes that are read. If an error is thrown, all the errors are thrown
// as it is.
type CapitalizeReader struct {
	b []byte
	i int
}

// Read implements the function for CapitalizeReader.
// p is the []byte where the data is copied to.
// n is the number of bytes that are read and if there is an error it is
// returned along with the bytes that are read.
func (cr *CapitalizeReader) Read(p []byte) (n int, err error) {
	// By default, the size of the
	// if the number of bytes are less than the bytes to be read, then we assign it.
	var l int = len(p)
	if len(cr.b)-cr.i < len(p) {
		l = len(cr.b) - cr.i
	}
	var t []byte = cr.b[cr.i : cr.i+l]
	n = copy(t, cr.b[cr.i:])
	cr.i += n
	t = bytes.ToUpper(t)
	n = copy(p, t)

	// If the bytes read is less than the length of input byte slice, return the number of bytes
	// and io.EOF; it is different from Go's byte reader implementation where it will copy everything
	// and always return 0, io.EOF in the next implementation.
	// Ref: https://golang.org/src/bytes/reader.go?s=1154:1204#L30
	if l < len(p) {
		return n, io.EOF
	}
	return n, nil
}

// NewCapitalizeReader takes in a string and returns a reader.
// Store string as a slice of bytes so that we can read bytes
// and uppercase it on read.
func NewCapitalizeReader(s string) *CapitalizeReader {
	return &CapitalizeReader{b: []byte(s), i: 0}
}

func main() {
	str := "hello world"
	cr := NewCapitalizeReader(str)

	fmt.Println("length of the string: ", str, " is ", len(str))
	var b = make([]byte, 2)

	for {
		time.Sleep(200 * time.Millisecond)
		n, err := cr.Read(b)
		fmt.Println(n, "\t", n, "\t", string(b[:n]))
		if err != nil {
			if err == io.EOF {
				break
			}
			log.Fatal(err)
		}
	}
	bytes.NewReader()
}

Using an already existing reader (strings.Reader)

The below example explains how to use an underlying Reader. Go does this quite often. For example, we have the LimitReader (https://golang.org/pkg/io/#LimitedReader). The LimitReader accepts a Reader and assigns this reader as the underlying reader. Once a set number of bytes are reached, it will return an EOF even if the underlying reader has not reached an EOF. This example uses strings.Reader as the underlying Reader.

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"log"
	"strings"
	"unicode"
)

// CapitalizeReader is a reader that implements io.Reader
// The underlying reader is a strings.Reader that is used to 
// read the bytes from a particular position and returns the number 
// of bytes that are read. All the errors are thrown
// as it is. 
type CapitalizeReader struct {
   // sr is the underlying reader to use the reading operations for.
	sr       *strings.Reader
   // offset is the index from where the string is read into the given []byte slice
	offset int64
}

// Read implements the function for CapitalizeReader
// p is the []byte where the data is copied to.
// n is the number of bytes that are read and if there is an error it is 
// returned along with the bytes that are read.
func (cr *CapitalizeReader) Read(p []byte) (n int, err error) {
   // create a new array where modifications will be made
	var t = make([]byte, len(p))
	n, err = cr.sr.ReadAt(t, cr.offset)
    // track the offset by number of bytes that were read
	cr.offset = cr.offset + int64(n)
	t = bytes.ToUpper(t)
    // copy to the provided array only when all the operations are done.
   //  io.Reader interface explicitly specifies that p should not be held by Read.
	copy(p, t)
    return
}

// NewCapitalizedReader takes in a string and returns a reader.
// offset is set to 0 as that is we want to read from.
func NewCapitalizeReader(s string) *CapitalizeReader {
	return &CapitalizeReader{sr: strings.NewReader(s), offset: 0}
}

func main() {
	str := "hello world"
	cr := NewCapitalizeReader(str)

	fmt.Println("length of the string: ", str, " is ", len(str))
	var b = make([]byte, 2)

	for {
		n, err := cr.Read(b)
        // Notice that we read by slice b[:n] even in the case of error
        //  This is because io.EOF can happen we can still have a byte that is read and 
        //  it is easy to miss it out.
		fmt.Println(n, "\t", n, "\t", string(b[:n]))
		if err != nil {
			if err == io.EOF {
               // exit gracefully with in case of io.EOF
				break
			}
           // For all other errors exit with a non-zero exit code.
			log.Fatal(err)
		}
	}
}

Summary

1. Readers have a similar interface in various programming languages.
2. Readers in Go can be implemented natively by implementing the Read(p []byte) (int, eror) method for any struct.
3. Readers in Go can also have a backing or an underlying reader that can be used to implement a new reader. This new reader can be limit or enhance the capability of the underlying reader. An example of this is the LimitReader in Go