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:

lunes, 31 de octubre de 2016

¿Qué es un ataque DDoS? ¿Cómo podemos evitarlo?

El Viernes 21 de Octubre de 2016 se produjo el mayor y más importante ataque DDoS de los últimos años. El ataque fue dirigido hacia los servicios DynDNS y dejo fuera de combate a decenas de web y servicios como por ejemplo Twitter, Reddit, Github, Amazon, Spotify



Lo grave del asunto es que el ataque al parecer fue perpetrado gracias a una vulnerabilidad existente en dispositivos IoT (Internet de las cosas), como son los electrodomésticos conectados a la red.


¿Que es un ataque DDos?

Vayamos por partes;  Un ataque de denegación de servicio (DoS) es un ataque dirigido hacia una red o sistema de computadoras que provoca que el mismo deje de responder a los usuarios. Esto ocasiona que el sistema esté fuera de línea el tiempo que dura el ataque más el tiempo de restablecimiento del sistema que suele oscilar entre 20 minutos y varias horas en el peor de los casos.

El caso que nos ocupa es una ampliación de este ataque y sus siglas DDoS corresponden a ataque de denegación de servicio distribuido o Distributed Denial of Service, en el que el ataque se lleva a cabo desde cientos o miles de puntos diferentes hacia el mismo objetivo.



Existen diferentes tipos de ataque, pero básicamente se trata de enviar un flujo tal de peticiones que el sistema no puede atenderlas por lo que acaba tirando el servicio por seguridad. Otros ataques pueden suponer interrupciones de componentes físicos de red o incluso alteración de las tablas de enrutamiento.


¿Por qué es tan popular el ataque DDoS?

Los ataques DDoS se han vuelto muy populares debido a que el objetivo no tiene por que tener ninguna vulnerabilidad, ya que son ataques de infraestructura. Por esto cualquiera podría comprar un pack de ataque DDoS por unos 150€ y mantener fuera de línea a un rival de League of Legends por ejemplo (Sí, esto ha pasado). Ojo, antes he mencionado que se ataca desde cientos o miles de ordenadores y es que estos ordenadores sí que suelen estar afectados por alguna clase de vulverabilidad (como Mirai en el internet de las cosas) o malware.


¿Qué se busca con los ataques DDoS?

Aquí debemos tener en cuenta los tipos de ataque; estos pueden ser personalizados, los cuales no tienen mucha repercusión mediática y suelen buscar un objetivo concreto (dejar fuera de línea a un rival o tirar el servidor del examen de la universidad) o globales, los cuales buscan una gran repercusión mediática, suelen estar reivindicados por organizaciones o grupos hacktivistas y sirven para que el mundo les preste atención.

¿Como podemos evitar los ataques DDoS?

No se puede… sin más, hoy en día es imposible evitar este tipo de ataques debido a que las causas son los propios mecanismos de seguridad de nuestras infraestructuras informáticas. Hace unos años podríamos pensar que si todos nuestros ordenadores estuvieran libres de malware, no podrían pertenecer a botnets (redes de ordenadores zombies controlados por un mismo malware y que son capaces de perpetrar ataques DDoS dirigidos) y entonces sería mucho más complicado realizar estos ataques pero, ay amigos, bienvenidos al internet de las cosas.


El internet de las cosas y Mirai.

Actualmente no son pocos los hogares que disponen de más de un ordenador conectado a internet sin siquiera darse cuenta. ¿Tienes una SmartTv? ¿un frigorífico conectado a internet? ¿Un ebook, tablet, videoconsola? ¿Quizá tengas una de esas nuevas bombillas inteligentes o un Chromecast? ¿Una camara IP? Podría seguir así mucho rato pero aunque no tengas nada de esto, seguro que tienes un router en casa ¿verdad? ¿Le has cambiado la contraseña? :D
¿Por que os cuento esto? Bueno, todos esos artículos son susceptibles de ser participes en la mayor botnet jamás creada, Mirai.

Mirai es capaz de convertir sistemas Linux en bots controlados remotamente y además ni siquiera necesita crackearlos ya que la mayoría de nosotros no se preocupa de cambiar la contraseña genérica de estos dispositivos. Mirai puede afectar a impresoras, camaras de vigilancia o routers caseros y hay poco que podamos hacer.



Este es un problema que tiene difícil solución y quizá sería un buen momento para plantearnos si realmente necesitamos tantos dispositivos inteligentes o sería más sensato usar nuestra inteligencia y dejar de ser tan cómodos.

Y tú. ¿Tienes muchos aparatos conectados a internet?

Compartir:

jueves, 27 de octubre de 2016

Truco C# - Eliminar / Matar procesos Windows por nombre o id

En este post os voy a enseñar una manera sencilla de eliminar procesos concretos por nombre o id mediante programación.

Para poder hacer uso de este truco vamos a necesitar añadir System.Diagnostics a nuestro programa ya que haremos uso de la clase Process. Una vez hecho esto vamos a definir 3 métodos, uno para matar procesos por su id de proceso y dos que irán por nombre de proceso; el primero eliminará la primera ocurrencia y el segundo eliminará todos los procesos con el mismo nombre (el proceso "Chrome" puede ser un buen ejemplo para probarlo).

Matar tarea por Id.

 
        private void KillTaskById(int taskid)
        {
            try
            {
                Process proceso = Process.GetProcessById(taskid);
                proceso.Kill();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }


Matar tarea por Nombre. Primera ocurrencia.

         private void KillTaskByName(string taskName)
        {
            try
            {
                Process[] procesos = Process.GetProcessesByName(taskName);
                procesos[0].Kill();
            } 
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }


Matar tarea por Nombre. Todas las ocurrencias.

 
        private void KillAllTasksByName(string taskName)
        {
            try
            {
                foreach (Process proceso in Process.GetProcessesByName(taskName))
                {
                    proceso.Kill();
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }


Probadlo y dejar en los comentarios que os ha parecido.

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

miércoles, 26 de octubre de 2016

Truco C# - Listar todos los servicios de un webservice

Hacía ya mucho tiempo que no posteaba nada, mas por falta de tiempo que por otra cosa, pero hoy os traigo una nueva entrada con un truco para C#.

Si habéis leido el título ya intuireis de que va el truco de hoy. Se trata, ni más ni menos de cómo obtener la lista de servicios publicados en un webservice.

Para que el método funcione lo único que necesitais es la url de un descriptor de webservice (acabará en ?wsdl o ?singleWSDL) para pasarla como parametro al método GetWsdlMethods que os describo a continuación.


 
        private string[] GetWsdlMethods(string wsdlUrl)
        {
            List<string> services = new List<string>();

            try
            {
                XmlTextReader myStreamReader = new XmlTextReader(wsdlUrl);

                ServiceDescription wsdl =
                   ServiceDescription.Read(myStreamReader);

                txtMethods.Clear();

                foreach (PortType pt in wsdl.PortTypes)
                {

                    services.Add(string.Format("PortType {0}", pt.Name));
                    services.Add("\r\n----------------------------------------");
                    foreach (Operation op in pt.Operations)
                    {
                        services.Add(string.Format("\r\n{0}", op.Name));
                    }
                }
            }
            catch
            {
                services.Add("ERROR READING WDSL URL");
            }

            return services.ToArray();
        }




Probadlo y dejar en los comentarios que os ha parecido.

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

jueves, 25 de agosto de 2016

Cómo bloquear / desactivar / eliminar los anuncios de Skype



Todos los que usamos Skype nos hemos acostumbrado a convivir con los anuncios que la aplicación nos muestra pero, ¿sabíais que se pueden desactivar de una manera muy sencilla? Sigue leyendo y te explico cómo.


Compartir:

jueves, 30 de junio de 2016

Truco Java - Uso de ListIterator

Hoy más que un truco os voy a poner un ejemplo de utilización de la clase ListIterator
ListIterator es un iterador secuencial que posibilita recorrer listas en cualquier sentido. Hay que tener presente que la posición de un iterador no representa ningún valor real de la lista, siempre estará entre dos elementos, al principio o al final.



En el ejemplo vamos a recorrer un Array de cadenas extrayendo los valores numéricos y posteriormente recorriendo la lista hacia adelante y hacia atrás.

 
package TrucosIExpression;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.ListIterator;

/**
 *
 * @author InvalidExpression
 */
public class Truco1 {

    /**
     * Metodo que extray todos los valores numéricos de un array de cadenas
     * y lo devuelve en un ArrayList
     * @param cadenas String[] .
     * @return ArrayList con valores numericos extraidos.
     */
    public ArrayList extraerNumeros(String[] cadenas) {
        if (cadenas == null) {
            throw new IllegalArgumentException("Parámetro erroneo.");
        } else {
            ArrayList arrayCadenas = new ArrayList();
            arrayCadenas.addAll(Arrays.asList(cadenas));
            ListIterator listaIterador;
            listaIterador = arrayCadenas.listIterator();
            while (listaIterador.hasNext()) {
                String cadena = (String) listaIterador.next();
                try {
                    Integer numero = new Integer(cadena);
                } catch (NumberFormatException e) {
                    listaIterador.remove();
                }
            }
            return arrayCadenas;
        }
    }

    /**
     * Metodo main.
     *
     * @param args String[] args.
     */
    public static void main(String[] args) {
        Truco1 trucoIterator = new Truco1();
        String[] cadenas = {"SILLA","5", "1", "4", "MESA", 
                            "8", "ZAPATO", "CERVEZA", "10", "12"};
        ArrayList arrayNumeros = trucoIterator.extraerNumeros(cadenas);
        ListIterator iterador = arrayNumeros.listIterator();
        //Recorremos de principio a fin con hasNext
        while (iterador.hasNext()) {
            System.out.println(iterador.next());
        }
        //Recorremos desde el final hasta el principio.
        while (iterador.hasPrevious()) {
            System.out.println(iterador.previous());
        }
    }
}


El resultado de la ejecución de este pequeño programa en NetBeans sería el siguiente:


Si necesitáis más información sobre ListIterator podéis encontrarla aquí.

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

martes, 28 de junio de 2016

Truco Delphi - Enviar emails usando el servicio Gmail de Google

En el truco de hoy os voy a enseñar como podéis enviar correos electrónicos desde vuestra aplicación Delphi mediante vuestra cuenta Gmail.


Para ello vamos a hacer uso de los componentes Indy disponibles en cualquier versión de RAD Studio (en el truco se utiliza la versión XE8 pero está testeado en XE5 también).

Vamos a crearnos una función SendGMail con el siguiente código:
  
procedure SendGmail(pUsuario, pPassword, pAsunto, pCuerpo, pDestino : string);
var
  Smtp : TidSMTP;
  ManejadorSSL : TidSSLIOHandlerSocketOpenSSL;
  Mensaje: TIdMessage;
begin
  ManejadorSSL := TIdSSLIOHandlerSocketOpenSSL.Create(nil);
  with ManejadorSSL do
  begin
   Destination := 'smtp.gmail.com:587';
   Host := 'smtp.gmail.com';
   MaxLineAction := maException;
   Port := 587;
   SSLOptions.Method := sslvTLSv1;
   SSLOptions.Mode := sslmUnassigned;
   SSLOptions.VerifyMode := [];
   SSlOptions.VerifyDepth := 0;
  end;

  Smtp := TIdSMTP.Create( nil );

  with Smtp do
  begin
    IoHandler := ManejadorSSL;
    Host := 'smtp.gmail.com';
    Port := 25;
    Username := pUsuario;
    Password := pPassword;
    UseTLS := utUseExplicitTLS;
  end;

  Mensaje := TIdMessage.Create(nil);
  with Mensaje do
  begin
    Clear;
    Subject := pAsunto;
    Body.Text := pCuerpo;
    Recipients.Add;
    Recipients.Items[0].Address := pDestino;
  end;

  Smtp.Connect;
  if smtp.Connected then
  begin
    smtp.Send(Mensaje);
    smtp.Disconnect;
  end;

  FreeAndNil(Smtp);
  FreeAndNil(Mensaje);
  FreeAndNil(ManejadorSSL);

end;
 

Y ya está, solamente tendremos que llamar a esta función con los parámetros relativos a nuestra cuenta para enviar nuestro correo.

En lugar de crear los objetos dinámicamente, podéis pegar objetos directamente desde la paleta de componentes en vuestro formulario y ahorraros el create; si lo hacéis dinámicamente no olvidéis incluir en el uses las referencias necesarias:

 uses
  [...] IdMessage, IdIOHandler, IdIOHandlerSocket, IdIOHandlerStack,
  IdSSL, IdSSLOpenSSL, IdBaseComponent, IdComponent, IdTCPConnection,
  IdTCPClient, IdExplicitTLSClientServerBase, IdMessageClient, IdSMTPBase,
  IdSMTP,IdAttachmentFile,IdGlobal;
 

Observaréis que falta la opción de adjuntar algún archivo, pero eso lo vamos a dejar para futuros trucos.

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

Compartir:

jueves, 23 de junio de 2016

Truco Delphi - MessageBox organizados y personalizados.

Si eres, o has sido, programador Delphi, seguramente te has encontrado muchas aplicaciones donde se utiliza la función Showmessage, MessageBox o Messagedlg o incluso todas a la vez de manera desorganizada y no unificada.


En este truco/post os voy a mostrar como organizar vuestros mensajes de aplicación en una única unidad y como personalizarlos con vuestros propios iconos sin necesidad de crear formularios específicos para ellos.

Mi recomendación es que utilicéis siempre MessageBox, por dos motivos:
  1. MessageBox es una función de la Api de Windows, por tanto, los textos de los botones estarán localizados al idioma del sistema.
  2. Permite una mayor personalización y control de los mensajes mostrados.
En toda aplicación suelen utilizarse, al menos, tres tipos de mensajes de diálogo con el usuario; Mensajes de error, mensajes de aviso y mensajes de pregunta.

Mi recomendación es que os creéis una unidad donde agrupéis todos esos mensajes de manera que podáis utilizarlos en toda la aplicación, por ejemplo algo así:


unit UDialogos;

interface

uses Windows;

procedure MensajeError(owner: HWND; p_texto :string);
procedure MensajeAviso(owner: HWND; p_texto :string);
function Pregunta(owner: HWND; p_texto, p_titulo: string) : boolean;

implementation

procedure MensajeError(owner: HWND; p_texto :string);
begin
  MessageBox(owner, pchar(p_texto), 'Error',
               MB_ICONERROR or MB_OK or MB_TASKMODAL)
end;

procedure MensajeAviso(owner: HWND; p_texto :string);
begin
  MessageBox(owner, pchar(p_texto),'Aviso',
               MB_ICONINFORMATION or MB_OK or MB_TASKMODAL )
end;

function Pregunta(owner: HWND; p_texto, p_titulo: string) : boolean;
begin
  result := MessageBox(owner, pchar(p_texto), pchar(p_titulo),
               MB_ICONQUESTION or MB_YESNO or MB_TASKMODAL) = IDYES
end;

end.



De esta manera tendremos todos los mensajes localizados en una unidad de nuestra aplicación y a nuestra disposición para cuando los necesitemos.

Es importante utilizar correctamente el parámetro "owner" de esas funciones y pasárles siempre el "Handle" del formulario que llama a la función ("Self.Handle") para que los diálogos sepan delante de quién deben mostrarse.

Si no os gustan los iconos por defecto que muestra Windows, siempre podéis utilizar los vuestros utilizando "MB_USERICON", pero en este caso deberéis utilizar la función MessageBoxIndirect.

Supongamos que tenemos un icono en los recursos de nuestra aplicación llamado 'ICONICO' y que queremos mostrarlo en un mensaje de dialogo concreto, escribiríamos lo siguiente:

  
procedure MensajePersonalizado(owner: HWND; p_texto, p_titulo :string);
var
  flags : uint;
  MsgPars: TMsgBoxParams;
begin
  flags := MB_USERICON or MB_OK or MB_DEFBUTTON1 or MB_TASKMODAL;

  //Establecemos los parámetros
  with MsgPars do
  begin
    cbSize := SizeOf(MsgPars);
    hwndOwner := owner;
    hInstance := Sysinit.hInstance;
    lpszText := PChar(p_texto);
    lpszCaption := pchar(p_titulo );
    dwStyle := flags;
    lpszIcon := 'ICONICO'; //Nuestro icono en los recursos
    dwContextHelpId := 0;
    lpfnMsgBoxCallback := nil;
    dwLanguageId := LANG_NEUTRAL;
  end;

  MessageBoxIndirect(MsgPars);

end;




Una última consideración sobre utilizar MB_OKCANCEL o MB_YESNO. Cualquier flag que incluya OK y/o CANCEL responderá a las teclas "Intro" para el OK y "Escape" para el CANCEL, es decir, si utilizáis MB_YESNO, "intro" y "escape" no funcionarán, si utilizáis MB_OKCANCEL, si que lo harán.

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

martes, 21 de junio de 2016

¿Qué pasaría si todo el mundo fuese capaz de programar? Estamos a punto de averiguarlo.


Podemos estar entrando en una era en la que cualquiera es capaz de hacer programas, a pesar de que no sepan programación – al menos no de la manera en la que la mayoría nosotros lo entendemos ahora mismo.

He empezado a jugar con una aplicación para iPad llamada Ready, que permite a los más pequeños hacer pequeños juegos, aplicaciones sencillas, y proyectos digitales creativos. Utiliza una sencilla interfaz “drag-and-drop” (arrastra y suelta) para crear objetos, cambiar sus propiedades, y hacer que interactúen entre ellos o con el usuario.


Crear una pelota, proporcionarle “físicas” para que responda a la gravedad; convertirla en goma para que “rebote” sobre las superficies; hacer una barra que se mueva de izquierda a derecha con los cursores; construir un muro de bloques que desaparecen cuando son golpeados por la pelota y listo… tenemos un Arkanoid de toda la vida.

Lo que WYSISWYG (lo que ves es lo que obtienes) hizo por la creación de documentos, lo hacerReady por la programación. Pero los efectos podrían ir más allá que el mero ahorro de tiempo.

Programación Drag-and-Drop

Ready realmente es un escritorio de Unity, el motor de juego multiplataforma que a su vez está basado en C y C++. Al permitir a los niños desarrollar juegos simplemente utilizando drag-and-drop e interfaces if/then, Ready sitúa a jóvenes desarrolladores un nivel por encima de lo que podríamos considerar como código “real” – pero sigue permitiéndoles crear desde cero.

Yendo más allá, imagino que los usuarios, con el tiempo, serán capaces de profundizar lo suficiente para crear sus propios objetos y elementos – quizá incluso ofreciéndolos a otros en un mercado digital. Piensa en un Minecraft, pero construido desde el principio para ser una plataforma creativa completamente abierta.


Las buenas ideas son más valoradas que el buen código.

Jugar con estas herramientas hace que me pregunte si, dentro de poco, todos nosotros estaremos desarrollando de esta manera. ¿Podría "Ready" y otros escritorios similares hacer por la programación lo que hizo Photoshop por las imágenes o Word por la creación documental?. Si lo hace, entonces la creación de aplicaciones por “no-programadores” con buenas ideas podría ser inminente. Aunque el código puede no ser tan elegante ni optimizado como si un desarrollador lo escribiera desde cero, este tipo de aplicaciones serían válidas como prototipos.


Cuanto más fáciles sean los ordenadores, más se alejan los usuarios de ser programadores.


Un conjunto configurable de elementos y objetos como "Ready" puede que no tenga en cuenta las infinitas posibilidades y nuevas innovaciones de la codificación pura, pero la mayoría de los programas actualmente no usan ese tipo de innovación de todos modos. Pensemos en Uber. Una aplicación GPS enlazada a una aplicación de cobros enlazada a una aplicación de citas. Y los nuevos programadores no van a intentar crear nada tan robusto como una plataforma de intercambio de ficheros global ni nada parecido.

Antes de que los más puristas empecéis a atacar el concepto de una programación que se dirige más hacia PowerPoint que hacia Python, consideremos por un momento que podríamos decir lo mismo sobre cualquier lenguaje de programación. Después de todo C++ o cualquier lenguaje de alto nivel, pasa a través de un compilador para convertirse en algo que la mayoría de nosotros es incapaz de leer. Y el programa en sí mismo se asienta sobre un sistema operativo, y lenguaje ensamblador, e instrucciones máquina, y arquitectura basada en chips… Puedes considerarte a ti mismo un desarrollador de software competente sin haber bajado jamás a ese nivel de comprensión.

Créeme, yo me encuentro entre los puristas, resentidos por la aparición del Mac y otras interfaces que parecían diseñadas intencionadamente para hacer la computación “más fácil” simplemente distanciando a los usuarios de las funciones básicas. Microsoft hizo que invocásemos a “the wizard” (el mago), como si fuera algo misterioso que las aplicaciones y sus extensiones acabasen en el directorio correcto. Cuanto más fáciles sean los ordenadores, más se alejan los usuarios de ser programadores. Echo de menos mi fichero autoexec.bat



Más que un simple ahorro de tiempo.


Ready” me hace pensar que la simplificación de las interfaces de usuario puede, finalmente, ofrecer algo distinto a un simple distanciamiento del código: el poder. La gratificación instantánea de construir algo en “Ready” proporciona esa sensación de poder – casi como ser el autor de Hypercard en los primeros días de Macintosh o construir un sitio en WordPress cuando mi ambición y necesidades superan claramente mis habilidades. Hay un plug-in de WordPress para casi todo lo que puedo querer hacer en mi sitio.

Una cosa es cierta, si la gente no tiene que escribir código, puede que nunca entiendan cómo funcionan realmente las cosas. Estarán limitados por las posibilidades ofrecidas por los creadores de las plataformas, a través de las cuales ensamblarán componentes prefabricados en aplicaciones y otras experiencias digitales.

Del mismo modo que dimos la bienvenida a los usuarios de AOL al Internet real, “Ready” y otras aplicaciones, pueden hacer entrar a legiones de “desarrolladores civiles” en la industria de los juegos y las aplicaciones. Con la democracia viene un poco de embrutecimiento. No van a ser maestros en programación, pero tampoco son maestros en música los compositores que escriben las canciones de las bandas de garaje. Esta puede ser la realidad creativa “mash-up” hacia la que vamos. (El mashup es un género musical que consiste en la creación de un nuevo tema mediante la combinación de fragmentos (loops), instrumentos concretos, pistas vocales (a cappellas) y pistas instrumentales a cachitos o enteras de otros temas anteriormente ya realizados por otros). Hay mucho que aprender si quieres estar al día. Yo era bueno en Pascal, pero hoy en día los lenguajes de programación son muy duros y puede que no compense lo suficiente aprenderlos.

Este puede ser el momento en que finalmente entramos en la era de “Bandas de Garage” de la creación de aplicaciones y juegos. Las cosas pueden ponerse complicadas, pero también serán menos comerciales, brillantes y funcionalmente opacas.

A pesar de todo, en un mundo en el que escribir código se ha convertido en una habilidad rara y valiosa, una plataforma como “Ready” permite a las masas experimentar el poder de la creación.

Esa experiencia, por si misma, puede ser más importante que cualquiera de las aplicaciones que creemos. Cambia la manera en la que percibimos el panorama digital en el que gastamos gran parte de nuestras vidas. Ahora mismo todo es software creado por otros, pero con las herramientas correctas, podría ser el software que imaginemos y creemos por nosotros mismos.

Estoy listo para eso.


Artículo por: Douglas Rushkoff. Traducido y adaptado por: Miguel Montero Gámez.


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

lunes, 20 de junio de 2016

Truco Delphi - Ocultar icono de nuestra aplicación en barra de tareas

Hoy toca un truco rápido, fácil y para toda la familia que consiste en ocultar el icono de nuestra aplicación de la barra de tareas en Delphi.

¿Para que sirve esto? Bueno, eso depende; imaginad que necesitáis hacer una aplicación iconizada en el área de notificaciones (Al lado del reloj) y que queréis que cuando se muestre no aparezca el icono en la barra de tareas (igual que el reloj de Windows por ejemplo).

Para ello solamente tendremos que anular la función CreateParams de la clase TForm para codificar nosotros mismos lo que necesitamos de la siguiente manera:
 
TfrmPrincipal = class(TForm)
  private
    { Private declarations }
  protected
    procedure CreateParams(var Params: TCreateParams); override;
  public
    { Public declarations }
  end;

procedure TfrmPrincipal.CreateParams(var Params: TCreateParams);
begin
  inherited;
  Params.ExStyle := Params.ExStyle and not WS_EX_APPWINDOW;
  Params.WndParent := Application.Handle;
end;


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

viernes, 17 de junio de 2016

Truco Java - Añadir imágenes a un JTable desde un campo Blob en MySQL

Hoy hemos realizado una encuesta a través del twitter del blog preguntandoos sobre que lenguaje queríais el siguiente truco y ha ganado JAVA.

Por suerte estoy realizando un master de JAVA ahora mismo y a diario me surgen problemas y dudas que voy solventando y que, seguramente, sean las mismas que tengáis vosotros si estáis empezando con este lenguaje.

En el truco que nos ocupa hoy os voy a enseñar cómo solucioné la cuestión de mostrar un campo de imagen (tipo BLOB en MySQL) en un JTable.


Os pondré el código que rellena la tabla y luego os destacaré un par de secciones que son las que considero más importantes.

Este es el código en cuestión:

    /**
     * Procedimiento LlenarTabla
     * Utilizando el procedimiento modeloImagen.listImagen,
     * se rellena la tabla pasada por parametro.
     * @param tablaImagenes
     * @throws java.sql.SQLException
     * @throws java.io.IOException
     */
    public void LlenarTabla(JTable tablaImagenes) throws SQLException, IOException{
        DefaultTableModel modeloTabla = new DefaultTableModel() {
            @Override //Redefinimos el método getColumnClass
            public Class getColumnClass(int column){
                switch(column) {
                    case 0: return Object.class;
                    case 1: return Object.class;
                    case 2: return Object.class;
                    case 3: return ImageIcon.class;
                    default: return Object.class;
                }
            }
        };
        //Establecemos el modelo correspondiente en la JTable
        tablaImagenes.setModel(modeloTabla);
        
        //Añadimos las columnas correspondientes
        modeloTabla.addColumn("ID IMAGEN");
        modeloTabla.addColumn("ES CATEGORIA");
        modeloTabla.addColumn("DESCRIPCION");
        modeloTabla.addColumn("IMAGEN"); //Esta es la columna [3], es la que
                                         //nos interesa que sea una imagen.
                
        Object[] columna = new Object[4];
        
        ArrayList<imagen> listaImagenes = modeloImagenes.ListarImagenXEsCategoria("","");
        
        int numRegistros = listaImagenes.size();
        
        for (int i = 0; i < numRegistros; i++) {
            columna[0] = listaImagenes.get(i).getIdImagen();
            columna[1] = listaImagenes.get(i).getEsCategoria();
            columna[2] = listaImagenes.get(i).getDescripcion(); 

            //Transformamos el campo blob en ImageIcon
            Blob blob = listaImagenes.get(i).getImagen();
            int blobLength = (int) blob.length();  
            byte[] bytes = blob.getBytes(1, blobLength);
            blob.free();
            BufferedImage img = ImageIO.read(new ByteArrayInputStream(bytes));
            ImageIcon icon = new ImageIcon(img); 
            
            //Añadimos la imagen a la columna correspondiente
            columna[3] = icon;
            
            //Añadimos la fila al modelo
            modeloTabla.addRow(columna);
            
            //Establecemos el alto de la fila                                   
            tablaImagenes.setRowHeight(i, icon.getIconHeight());    
        }
        
   } 



No voy a entrar en el detalle de cómo recupero los datos de MySQL ni de cómo se define la clase Imagen (si queréis el código podéis pedírmelo en los comentarios y os lo facilitaré), pero sí quiero que prestéis atención a este código:

         DefaultTableModel modeloTabla = new DefaultTableModel() {
            @Override //Redefinimos el método getColumnClass
            public Class getColumnClass(int column){
                switch(column) {
                    case 0: return Object.class;
                    case 1: return Object.class;
                    case 2: return Object.class;
                    case 3: return ImageIcon.class;
                    default: return Object.class;
                }
            }
        };


Ese fragmento de código define el modelo que utilizará el objeto JTable y sobre el hemos de redefinir el método getColumnClass para que, en la columna [3] nos devuelva un ImageIcon, que es lo que queremos mostrar.

Otra parte importante del código, y que seguro que muchos ya conocéis, es el encargado de convertir el campo BLOB en un ImageIcon.
  
            //Transformamos el campo blob en ImageIcon
            Blob blob = listaImagenes.get(i).getImagen();
            int blobLength = (int) blob.length();  
            byte[] bytes = blob.getBytes(1, blobLength);
            blob.free();
            BufferedImage img = ImageIO.read(new ByteArrayInputStream(bytes));
            ImageIcon icon = new ImageIcon(img); 
            

Con estos sencillos pasos podemos obtener el resultado deseado.

Resultado final en una aplicación SWING

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

jueves, 16 de junio de 2016

Truco Delphi - Alternar colores de filas en DBGrid

Hoy os presento un pequeño truco que hará que vuestros DBGrids luzcan mucho mejor añadiendo unas pocas lineas de código.

Lo que tratamos de conseguir es que nuestro DBGrid presente las filas con colores alternos y además que la fila seleccionada se resalte también de manera alterna.


Para conseguir este objetivo debemos escribir la función GridDrawColumnCell como sigue:


procedure TfrmPrincipal.GridDrawColumnCell(Sender: TObject; const Rect: TRect;
  DataCol: Integer; Column: TColumn; State: TGridDrawState);
const
  RowColors: array[Boolean] of TColor = (clSilver, clWhite);
  RowSelectedColors: array[Boolean] of TColor = (clHotLight, clHighlight);
var
  OddRow: Boolean;
begin
  if (Sender is TDBGrid) then
  begin
    OddRow := Odd(TDBGrid(Sender).DataSource.DataSet.RecNo);
    if (gdSelected in State) then
      TDBGrid(Sender).Canvas.Brush.Color := RowSelectedColors[OddRow]
    else
      TDBGrid(Sender).Canvas.Brush.Color := RowColors[OddRow];
    TDBGrid(Sender).DefaultDrawColumnCell(Rect, DataCol, Column, State);
  end;
end;


Este procedimiento lo podemos poner en el formulario donde esté el DBGrid o bien en una unidad aparte y luego importarla con el comando Uses. Si incluimos el procedimiento en el formulario, es importante hacerlo como procedimiento de clase:

 TfrmPrincipal = class(TForm)

    { Otros métodos y propiedades del formulario }

    procedure GridDrawColumnCell(Sender: TObject; const Rect: TRect;
                                 DataCol: Integer; Column: TColumn; State: TGridDrawState);
  private
    { Private declarations }

  public
    { Public declarations }
  end;



De esta manera podremos seleccionar el DBGrid y asignar el procedimiento al evento OnDrawColumnCell.


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

miércoles, 15 de junio de 2016

Truco Delphi - Prevenir la ejecución de más de una instancia de nuestra aplicación (I)


Hace ya bastante tiempo que no posteo, pero eso no quiere decir que me haya olvidado de vosotros.
Como no dispongo de mucho tiempo para continuar con el curso de Lazarus y postear de forma asidua los artículos que tenía previstos, voy a empezar a postear pequeños tips y códigos de ejemplo para resolver pequeños problemas que me surgen en el día a día.

Hoy quiero mostraros como hacer que vuestra aplicación no se ejecute más de una vez, pero, en lugar de manteniendo la instancia más antigua, haciendo que la nueva instancia tome el control, es decir, que la nueva ejecución sustituya a la antigua.

Para ello nos vamos a basar en el procedimiento de WinApi GetCurrentProcessId, que nos dará el id de proceso del programa que estamos ejecutando y en el objeto TApplication para obtener el ExeName que será el que buscaremos.



Básicamente lo que pretendemos es terminar cualquier proceso que se llame como el nuestro, pero que no sea el nuestro :D


Añadimos el siguiente código en el evento OnCreate de nuestro formulario principal.

procedure TfrmPrincipal.FormCreate(Sender: TObject);
begin
  FProcessID := GetCurrentProcessId;
  FExeName   := ExtractFileName(Application.ExeName);
  
  CerrarInstancias;
end;

Este es el código que recorrerá todos los procesos de Windows y eliminará las instancias que existan de nuestra aplicación excepto la actual.

procedure TfrmPrincipal.CerrarInstancias;
const
  PROCESS_TERMINATE = $0001;
var
  ContinueLoop: BOOL;
  FSnapshotHandle: THandle;
  FProcessEntry32: TProcessEntry32;
begin
  FSnapshotHandle := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  FProcessEntry32.dwSize := SizeOf(FProcessEntry32);
  ContinueLoop := Process32First(FSnapshotHandle, FProcessEntry32);


  while Integer(ContinueLoop) <> 0 do
  begin

      if ((UpperCase(ExtractFileName(FProcessEntry32.szExeFile)) =
          UpperCase(FExeName)) or
          (UpperCase(FProcessEntry32.szExeFile) =
          UpperCase(FExeName)))  and
         (FProcessEntry32.th32ProcessID <> FProcessID)
      then
      begin
        TerminateProcess(OpenProcess(PROCESS_TERMINATE,
                                    BOOL(0),
                                    FProcessEntry32.th32ProcessID),
                                    0);
      end;

       ContinueLoop := Process32Next(FSnapshotHandle, FProcessEntry32);
  end;
  CloseHandle(FSnapshotHandle);

end;

Mas adelante pondré otras maneras de prevenir la ejecución de más de una instancia de nuestras aplicaciones.
Compartir:

jueves, 31 de marzo de 2016

Hola Mundo multilingüe

¡Hola Mundo!

Aprovechando que he implementado SyntaxHighLighter en el blog, vamos a hacer un repaso por la mayoría de lenguajes de programación haciendo lo primero que debería hacer todo programador que empieza con un nuevo lenguaje de programación; el programa "Hola Mundo"

Espero que os guste el formato. A partir de ahora empezaré a incluir entradas con tips de programación en diferentes lenguaje y rutinas interesantes para que las tengamos todos a mano.

ColdFusion

<html>
<head>
<title>Test</title>
</head>
<body>

  <cfset message = "¡Hola Mundo!">
  <cfoutput>#message#</cfoutput>

</body>
</html>

C#

using System;
namespace HelloWorld
{
    class Hello 
    {
        static void Main() 
        {
            Console.WriteLine("¡Hola Mundo!");           
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

C++

#include <iostream>
 
int main()
{
  std::cout << "¡Hola Mundo!" << std::endl;
  return 0;
}

Delphi/Pascal

program Hello;
begin
  writeln ('¡Hola Mundo!');
  readln
end.

JavaScript

<!DOCTYPE HTML>
<html>
<body>

  <p>Header...</p>

  <script>
    alert('¡Hola Mundo!')
  </script>

  <p>...Footer</p>

</body>
</html>

Java
public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("¡Hola Mundo!");
    }

}

Perl

  #!/usr/bin/env perl

  use v5.10.0;
  use warnings;
  use strict;

  say "¡Hola Mundo!";

Php

<html>
<head>
<title>Test</title>
</head>
<body>

 <?php
  $message = "¡Hola Mundo!";
  echo $message;
 ?>

</body>
</html>

PowerShell

$strString = "¡Hola Mundo!"
write-host $strString

Python

print("¡Hola Mundo!")

Ruby

puts '¡Hola Mundo!'

Visual Basic

Module Hello
  Sub Main()
      MsgBox("¡Hola Mundo!")  
  End Sub
End Module

Compartir:

lunes, 28 de marzo de 2016

Juegos para programar: Lightbot: Code Hour

Hace ya varias semanas desde la última entrada y varias más desde el primer artículo sobre "Juegos para programar". Lo cierto es que he estado bastante ocupado con el Master de Java, Semana Santa, Vacaciones, etc... pero aquí estamos de nuevo para volver a bloguear más a menudo.


LightBot: Code Hour

Hoy os traemos un juego que hará las delicias de los pequeños y no tan pequeños. Se llama LightBot: Code Hour. Este pequeño juego es gratuito y nos ofrece una secuencia de puzzles que irán creciendo en dificultad y que nos acercarán a temas tan propios de la programación como los procedimientos y los bucles.


¿En que consiste?

El juego consiste en dirigir nuestro LightBot hacia una serie de cuadrículas azules, distribuidas por un tablero, y encendiendo una bombilla sobre ellos. La gracia del asunto es que tenemos un número máximo de acciones que podemos llevar a cabo para acabar cada una de las fases.



Tendréis la posibilidad de seleccionar el idioma que queráis (entre ellos el español) y el género de vuestro LightBot.

El juego puede resultar algo corto, pero si tenemos en cuenta que es gratuito y a quién va dirigido, no me cabe duda de que será muy interesante para los más pequeños.



Otras versiones

Si os quedáis con ganas de más, tenéis disponibles dos versiones adicionales de LightBot, una de 4 a 8 años y otra para edades de 9 en adelante. Desafortunadamente estas versiones ya son de pago y su precio oscila entre los 2,99€ y los 3,18€ dependiendo de la versión y la plataforma.

Además tenéis una versión de navegador a la que podéis acceder desde aquí y jugar gratuitamente


Espero que os haya gustado este post y que me dejéis en los comentarios si queréis que hable sobre algún juego concreto que consideréis interesante para esta temática y lo incluiré sin problemas.

Compartir:
Con la tecnología de Blogger.

BoosterBlog

BoosterBlog
BoosterBlog

Timeline Twitter

Seguidores

Seguidores