sábado, 4 de septiembre de 2021

Reseña de "Acelerar" La ciencia del desarrollo Lean y Devops

Cuando empiezas a adentrarte en el mundo Devops e investigas un poco, uno de los primeros autores que aparecerá en tu buscador es Gene Kim.

Entre los títulos de Kim, constan grandes referentes como "The Phoenix Project", "The Unicorn Project" y este "Acelerar" o "Accelerate" si lo buscáis en inglés y que es sobre el que os voy a escribir hoy.

Acelerar

En este libro participan, además, la Dra. Nicole Forsgren y Jez Humble; ambos son reconocidas figuras en el mundo Devops, la investigación y el SRE (Site Reliability Engineering) y, junto con el antes mencionado Gene Kim,  nos traen un libro de investigación donde nos presentan como medir el rendimiento de los equipos y en que enfocarse para obtener un rendimiento mayor en el desarrollo y entrega de software.

La estructura del libro.

Acelerar está estructurado en tres partes bien diferenciadas. En la primera parte, se presentara lo que encontraron en la encuesta. En primer lugar, explica por qué el rendimiento de la entrega de software es importante y cómo impulsar las tareas de medidas de rendimiento organizacional (como la rentabilidad, la productividad y la participación de mercado) además de las medidas no comerciales (como la eficiencia, la eficacia, la satisfacción del cliente y el logro).

En la segunda parte, resume la ciencia detrás de la investigación y aclara las decisiones de diseño que se toman y los métodos de análisis utilizados. Esto proporciona la base para los resultados que se describen en la mayoría de los textos. También identifican características clave que contribuyen al rendimiento de la entrega de software de una manera estadísticamente significativa y relevante. 

En la tercera parte, concluye con una explicación sobre la gestión del cambio organizacional. Este capítulo ofrece una visión en profundidad de cómo es seguir las capacidades y prácticas descritas en este libro, y lo que puede ofrecer a las organizaciones innovadoras.

Mi opinión.

"Acelerar" me ha resultado un libro muy revelador en cuanto a como medir el rendimiento de una organización. Es bastante probable que use muchos de sus preceptos en mi trabajo diario. Aunque la segunda parte me ha resultado bastante tediosa al presentar, en mi opinión, demasiados datos estadísticos y de evaluación. Entiendo que este capítulo es importante y le da validez al contenido del libro, yo lo utilizaría más como un recurso de referencia rápida que como de lectura continua.

En definitiva, "Acelerar" debería estar en la biblioteca de cualquiera que pretenda llevar a cabo una transformación en su organización con objetivo de aumentar el rendimiento del desarrollo de software.

Podéis adquirir el libro mediante mi enlace de afiliado y, de paso, ¡me ayudáis a continuar con el blog!

 





Compartir:

viernes, 1 de enero de 2021

Truco Kubernetes - 3 métodos para reiniciar tus pods

Digamos que uno de los pods de tu cluster está reportando un error. Dependiendo de las políticas de reinicio, Kubernetes podría intentar reiniciar automáticamente el pod y hacerlo funcionar de nuevo. Sin embargo, esto no siempre soluciona el problema.

Si K8s no puede arreglar el problema por si mismo, y no podemos encontrar el origen del error de manera inmediata, reiniciar el pod es la manera mas rápida de hacer que tu aplicación funcione de nuevo.

logo kubernetes

Podrás pensar que una solución es volver a arrancar el ciclo CI/CD de esa aplicación (si lo tienes), pero este puede ser un proceso mas lento de lo deseable y, en cualquier caso, no solucionaría el problema de base, así que a continuación te muestro 3 métodos para reiniciar rápidamente tus pods.

Método 1: Rolling Restart

Este es el método más rápido. Está disponible desde la 1.15 y consiste en decirle a tu K8s que reinicie un deploy concreto.

kubectl rollout restart deployment [deployment_name]
Kubectl rollout restart

Método 2: Utilizando variables de entorno

Otro método es establecer o modificar una variable de entorno para forzar el reinicio del pod y la sincronización de los cambios que has realizado

Por ejemplo, puedes cambiar la fecha de despliegue (deployment date)

kubectl set env deployment [deployment_name] DEPLOY_DATE="$(date)"
kubectl set env

Método 3: Escalar el número de replicas

Por último podemos usar el comando scale para cambiar el numero de replicas del pod con problemas. Establecerlo a 0 básicamente "apaga" el pod.

kubectl scale deployment [deployment_name] --replicas=0

Posteriormente podemos aumentar este número de replicas para hacer que el pod se arranque de nuevo.

kubectl scale deployment [deployment_name] --replicas=1
kubectl scale deployment

En conclusión

Kubernetes es un sistema extremadamente útil, pero como cualquier otro sistema, no está libre de fallos.

Cuando ocurren problemas, puedes utilizar uno de los tres métodos enumerados anteriormente para que tu aplicación funcione de manera rápida y segura sin cerrar el servicio para los clientes.

Después de reiniciar los pods, tendrás tiempo para encontrar y solucionar la verdadera causa del problema.

¿conoces algún otro método para reiniciar los pods? Compártelo aquí debajo junto con cualquier duda que te surja.

Compartir:

miércoles, 23 de diciembre de 2020

Truco JavaScript - 5 métodos para convertir cadenas a números que no sabías

Hoy toca un poquito de JavaScript y he pensado que sería interesante mostraros algunas técnicas utilizadas en JS para convertir cadenas en números.

Convertir cadenas a números.

JavaScript provee funciones para transformar fácilmente cadenas a numero primitivos.

  • .parseInt() con una cadena como primer argumento y una base opcional sobre la que quieres convertir la cadena. Siempre devuelve un entero.
  • .parseFloat() desde una cadena devuelve un número en coma flotante equivalente.
  • Math.floor() se utiliza para redondear un flotante al entero más cercano redondeando a la baja.
  • Math.ceil() similar al anterior pero redondeando al alza.
  • Operador unario añadiendo un signo positivo + antes de la cadena, se convertirá en número si el formato es correcto.
  • Multiplicación por 1 si multiplicamos una cadena por 1, esta se convierte en un número 
Seguramente conocías algunos de estos métodos y otros (como me pasó a mi con Math.floor y Math.ceil) te habrán sorprendido, pero pasemos a los ejemplos

.parseInt()

let str = '353';
let fltStr = '353.56';
let binStr = '7';
let nanStr = 'hola';
parseInt(str);       // 353
parseInt(fltStr);    // 353
parseInt(binStr, 2); // 111 (Binario)
parseInt(nanStr);    // NaN (Not a Number)

.parseFloat()

let str = '100';
let fltStr = '100.21';
let nanStr = 'bye';
parseFloat(str);    // 100
parseFloat(fltStr); // 100.21
parseFloat(nanStr); // NaN

Math.floor()

let str = '100';
let fltStr = '99.89';
let nanStr = 'bye';
Math.floor(str);    // 100
Math.floor(fltStr); // 99
Math.floor(nanStr); // NaN

Math.ceil()

let str = '100';
let fltStr = '100.21';
let nanStr = 'bye';
Math.ceil(str);    // 100
Math.ceil(fltStr); // 101
Math.ceil(nanStr); // NaN

Operador unario

let str = '100';
let fltStr = '100.21';
let nanStr = 'greetings';
+str    // 100
+fltStr // 100.21
+nanStr // NaN
+'1000' // 1000
+10.25  // 10.25

Multiplicar por 1

let str = '100';
let fltStr = '100.21';
let nanStr = 'greetings';
str * 1;      // 100
fltStr * 1;   // 100.21
nanStr * 1;   // NaN
'2000' * 1;   // 2000
'102.15' * 1; // 102.15



Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter facebook.


Compartir:

martes, 22 de diciembre de 2020

ODroid Go Super. Nueva ODroid "Switch" con Ubuntu.

Ya se ha anunciado la nueva ODroid Go Super, una "pequeña" vuelta de tuerca a lo que es ODroid Go Advance.

A muchos nos encanta el aspecto de Nintendo Switch. El cómo se siente en las manos es muy satisfactorio para la mayoría de los que la hemos probado. Si eres de los que les gusta este feeling, pero prefieres jugar en Linux, esta pequeña maravilla te va a encantar.

ODroid-Go Super

Esta mañana del 22 de diciembre podíamos leer el siguiente anuncio en el foro de odroid del que os dejamos este pequeño extracto traducido...

Anunciamos ODROID-Go en 2018 para celebrar nuestro décimo cumpleaños. En diciembre de 2019, anunciamos ODROID-Go Advance (OGA).

Ahora es el momento de presentar un nuevo dispositivo de juegos para desarrolladores para 2021.

Hemos actualizado el diseño del hardware OGA y lo llamamos OGS (ODROID-Go Super).

El tamaño de la pantalla LCD cambió de 3,5 pulgadas a 5 pulgadas con una cubierta de vidrio templado. La resolución cambió de 480x320 a 854x480 píxeles.

Sabemos que muchos fanáticos de los juegos retro quieren una pantalla con una relación de aspecto de 4:3, pero no pudimos encontrar ningún fabricante de LCD que pueda construir una pantalla de 4 a 5 pulgadas con una relación de 4:3.

La capacidad de la batería también ha aumentado alrededor de un 30%. El OGA tenía una batería de 3000 mAh, mientras que este nuevo OGS tiene una batería de 4000 mAh.

Puede jugar juegos continuamente durante varias horas dependiendo del brillo de la luz de fondo.

Además, se realizaron otros cambios importantes de hardware. Agregamos un segundo joystick analógico y botones de volumen dedicados.

El OGS ahora viene preensamblado en nuestra fábrica en lugar de ser un kit ensamblado de bricolaje.

Dado que no hay una conectividad inalámbrica incorporada, se mejoró la compatibilidad con un USB WIFI + BT.

Finalmente, la ranura para tarjetas micro-SD ha cambiado a tipo push-push (expulsión de resorte) de push-pull.



ODroid Go Super es una versión más grande y potente del ODroid Go Advance, una computadora de mano de 3.5 pulgadas creada por ODroid en 2019, y el nuevo modelo es claramente mejor en varios aspectos.

Tiene una pantalla LCD más grande de 5 pulgadas que funciona a 854 × 480 píxeles (lamentablemente no 4: 3 como los aficionados a los juegos retro tienden a preferir), una batería grande de 4000 mAh (más tiempo de juego) y dos joysticks analógicos en comparación con la Advance que solamente contaba con 1.

Dejando a un lado esas diferencias, el Super está construido alrededor del mismo procesador Rockchip RK3326 ARM Cortex-A35 de cuatro núcleos y gráficos ARM Mali-G31 MP2 que la pequeña Advance. Del mismo modo, también se combina con un "modesto" (pudiéramos decir "escaso") 1 GB de memoria DDR3. También hay una cantidad insignificante de almacenamiento interno para albergar el cargador de arranque y el sistema operativo.

A tenor de lo anterior, podemos ver claramente que este dispositivo está lejos de ser el Linux más potente que pudieras llevar en tu bolsillo. Con todo, recuerda que ha sido diseñada para jugar a juegos de videoconsola antiguos y no los últimos lanzamientos. Habrá que esperar a finales de enero para poder comprobar como rinde con los distintos emuladores incluidos en su EmulationStation corriendo sobre Ubuntu 20.04 LTS.


Características principales:

  • Pantalla de 5 pulgadas con resolución 854x480
  • Batería de 4000mAh
  • Doble stick analógico
  • Ubuntu 20.04 LTS con EMulationStation como frontend
  • 1 gb DDR3L
  • Control de volumen dedicado
  • Soporte para dongle WIFI y BT mejorado. Wifi y BT no incluidos.
  • Procesador RockChip RK3326(Quad-Core ARM Cortex-A35 1.3GHz)
  • GPU Mali-G31 Dvalin
  • Almacenamiento SPI Flash(16Mbytes Boot), Micro SD Card slot(UHS-1 Capable interface)
  • Precio aproximado 80$ (portes e impuestos no incluidos)


Compartir:

lunes, 21 de diciembre de 2020

Principales cambios de diseño previstos para GNOME 40

Los grandes cambios en la forma en que los usuarios de GNOME Shell abren y administran aplicaciones y espacios de trabajo están llegando a GNOME 40, que se lanzará la próxima primavera.

Se planean varios cambios importantes en la experiencia del usuario y el diseño, todos con el objetivo de mejorar la forma y función de la "Activities Overview", también conocido como el espacio de trabajo bajo demanda al que se accede haciendo clic en el botón de texto "Actividades" en la barra superior de GNOME Shell.

Después de meses de exploración del diseño y 6 ejercicios de investigación de usuarios separados […] el equipo de GNOME Shell tiene un diseño actualizado para Activities Overview”, explica Allan Day, diseñador de experiencia de usuario en Red Hat y líder de diseño de GNOME.

Y el nuevo diseño es espectacular.

El equipo de escritorio de GNOME ha compartido imágenes conceptuales de los cambios propuestos. Estas ilustran el cambio en el posicionamiento espacial que los desarrolladores sienten que se requiere para ofrecer una "navegación y orientación intuitivas".

Un escritorio vacío es lo primero que ven los usuarios en una instalación básica de GNOME Shell; recuerde: Ubuntu incluye una versión personalizada. No hay señales visibles, salvo los íconos en la barra superior, sobre dónde iniciar aplicaciones o cómo administrar las ventanas. Un usuario tiene que "descubrir" el botón Actividades, que también alberga el tablero, y trabajar el resto desde allí.

GNOME 40 mejora un poco esta introducción.

 


En lugar de un escritorio en blanco, GNOME 40 recibe a los usuarios con el modo Actividades, que está repleto de un (nuevo) conmutador de espacio de trabajo horizontal, un (nuevo) tablero horizontal (o barra de favoritos), además de una barra de búsqueda visible.

Cuando se abre una aplicación (o se hace clic en un espacio de trabajo), la pantalla se "acerca" para colocar al usuario frente a su tarea / espacio de trabajo seleccionado. La pantalla Actividades es accesible en cualquier momento, como ahora.

Cuando se abren varias aplicaciones, se ve así:


Los cambios clave:

·         Los espacios de trabajo están organizados horizontalmente

·         Las ventanas de las aplicaciones tienen íconos para ayudar con la identificación

·         El tablero es horizontal, despojado en la parte inferior

·         Soporte para fondos de pantalla por espacio de trabajo

La interacción sigue siendo tan rica como ahora; los usuarios pueden arrastrar y soltar ventanas de aplicaciones entre espacios de trabajo (y presumiblemente crear nuevos espacios de trabajo bajo demanda). Los títulos de las ventanas aparecerán al pasar el mouse.

La cuadrícula "Aplicaciones" se inicia haciendo clic en el icono de cuadrícula en el tablero. Pero, como gran parte de la interfaz de usuario, ahora pagina horizontalmente. Los desarrolladores de GNOME han creado conscientemente una coherencia de navegación que se mantiene fiel a lo largo de toda la interfaz de usuario de conmutación de aplicaciones. Izquierda / derecha para moverse, arriba / abajo para hacer la transición.

Otras funciones, como la búsqueda a medida que escribe, el acceso a los proveedores de búsqueda, el reordenamiento de aplicaciones y las carpetas de aplicaciones personalizables, permanecen intactas.


Me tranquiliza ver que el tablero permanece presente en estas nuevas maquetas. En el pasado, la discusión sobre el diseño de GNOME sugirió que el dock estaba listo para ser eliminado. Un movimiento tan audaz hacia la UX sería controvertido, pero los usuarios descontentos, como ahora, podrían adaptar la experiencia de GNOME Shell para satisfacer sus propias necesidades y preferencias a través de extensiones.

Dicho esto, faltan algunas funciones: en las maquetas donde las aplicaciones están abiertas, notará que NO se presentan en el tablero como aplicaciones en ejecución, es decir, con un punto de estado. ¿Significa esto que Dash ahora se está convirtiendo en una barra de favoritos y no en una forma de administrar aplicaciones en ejecución?

System76 aparentemente estuvo involucrado en la investigación que dio como resultado este plan GNOME 40. Esto no es una sorpresa ya que System76 envía una versión modificada del escritorio GNOME Shell en Pop OS, una distribución que ha ganado muchos aplausos por sus alteraciones y complementos, y por su flujo de trabajo centrado en el usuario avanzado.

GNOME 40 se lanzará en marzo de 2021. Los cambios de diseño que se ven aquí están destinados a esa versión, pero no se garantiza que se distribuyan. Las cosas pueden, naturalmente, cambiar a medida que se produce el desarrollo y la implementación.

Pero si todo va según lo planeado, la experiencia de Actividades rediseñada que se muestra aquí podría aparecer en Ubuntu 21.04 'Hirsute Hippo', que se lanzará a mediados de abril de 2021.

 

Enlace a la noticia original en inglés

Compartir:

martes, 29 de noviembre de 2016

Truco Java - Establecer formato moneda en columna JTable

Hoy os voy a mostrar como poner el formato moneda (currency) en un campo de vuestra JTable.

De la misma manera que en el truco anterior, nos crearemos una clase dentro del paquete componentes de nuestra aplicación heredando de DefaultTableCellRenderer.

import java.awt.Component;
import java.text.NumberFormat;
import javax.swing.JLabel;
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;

public class CurrencyCellRenderer extends DefaultTableCellRenderer {
 
    private static final NumberFormat FORMAT = NumberFormat.getCurrencyInstance();

    @Override
    public final Component getTableCellRendererComponent(JTable table, Object value,
            boolean isSelected, boolean hasFocus, int row, int column) {
        final Component result = super.getTableCellRendererComponent(table, value,
                isSelected, hasFocus, row, column);
        if (value instanceof Number) {
            setHorizontalAlignment(JLabel.RIGHT);
            setText(FORMAT.format(value));
        } else {
            setText("");
        }
        return result;
    }
}

La utilización es similar al caso TimestampCellRenderer:

public void LlenarTabla(JTable tablaListadoVentas, boolean inicializar) {
        DefaultTableModel modeloTabla = new DefaultTableModel (){
            @Override //Establecemos todas las celdas como no editables
            public boolean isCellEditable(int row, int column) {               
                return false;
            }            
        };
        
        tablaListadoVentas.setModel(modeloTabla);
        
        modeloTabla.addColumn("Venta");
        modeloTabla.addColumn("Id. Cliente");
        modeloTabla.addColumn("Nombre");
        modeloTabla.addColumn("Id. Empleado");
        modeloTabla.addColumn("Nombre");
        modeloTabla.addColumn("Fecha y hora");
        modeloTabla.addColumn("Nº Artículos");
        modeloTabla.addColumn("Importe Total");                        
        
        Object[] columna = new Object[8];       
        
        tablaListadoVentas.getColumnModel().getColumn(5).setCellRenderer(new TimestampCellRenderer());
        tablaListadoVentas.getColumnModel().getColumn(7).setCellRenderer(new CurrencyCellRenderer());


Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.
Compartir:

jueves, 3 de noviembre de 2016

Truco Java - Establecer formato fecha y hora en columna JTable

El truco que os traigo hoy es producto de una necesidad que me surgió durante la elaboración del proyecto del curso de Java que estoy haciendo. La necesidad vino cuando necesité establecer formato fecha/hora a un campo de un JTable que contenia un valor Timestamp obtenido de MySQL.



Lo que tenemos que hacer es crearnos una clase (en mi caso estas clases las meto siempre en un paquete llamado "componentes" para tenerlo todo organizado) que herede de DefaultTableCellRenderer y posteriormente utilizarla en nuestra columna de JTable.

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import javax.swing.table.DefaultTableCellRenderer;

public class TimestampCellRenderer extends DefaultTableCellRenderer {

    DateFormat formatter = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");

    public TimestampCellRenderer() {
        super();
    }

    public void setValue(Object value) {
        if (formatter == null) {
            formatter = DateFormat.getDateInstance();
        }
        setText((value == null) ? "" : formatter.format(value));
    }
}


En la linea SimpleDateFormat podemos establecer el formato de fecha y hora que nosotros necesitemos. Se me ocurre como mejora añadir un parametro al constructor para poder pasar la cadena de formato por ejemplo.

La utilización es sencilla: Suponiendo que nuestro JTable se llame tablaListadoVentas y una vez establecido el modelo de la misma:

    public void LlenarTabla(JTable tablaListadoVentas, boolean inicializar) {
        DefaultTableModel modeloTabla = new DefaultTableModel (){
            @Override //Establecemos todas las celdas como no editables
            public boolean isCellEditable(int row, int column) {               
                return false;
            }            
        };
        
        tablaListadoVentas.setModel(modeloTabla);
        
        modeloTabla.addColumn("Venta");
        modeloTabla.addColumn("Id. Cliente");
        modeloTabla.addColumn("Nombre");
        modeloTabla.addColumn("Id. Empleado");
        modeloTabla.addColumn("Nombre");
        modeloTabla.addColumn("Fecha y hora");
        modeloTabla.addColumn("Nº Artículos");
        modeloTabla.addColumn("Importe Total");                        
        
        Object[] columna = new Object[8];       
        
        tablaListadoVentas.getColumnModel().getColumn(5).setCellRenderer(new TimestampCellRenderer());



Si tienes cualquier duda o comentario recuerda que puedes exponerlo aquí o bien mediante nuestro twitter y facebook.
Compartir:
Con la tecnología de Blogger.

BoosterBlog

BoosterBlog
BoosterBlog

Timeline Twitter

Seguidores

Seguidores