Categoría: Programacion

En este artículo os proponemos una manera muy sencilla y a la vez fácil, de validar datos complejos. Para ello vamos a usar expresiones regulares.

¿Qué son las expresiones regulares?

Básicamente a la hora de validar datos, muchas personas optan por una validación muy laxa y luego si algo sale mal, la culpa es del usuario. Como todos sabemos el usuario, siempre presta atención y nunca mete datos incorrectos, así que para qué preocuparnos.

Hoy os proponemos usar expresiones regulares, que consisten en indicar, el patrón que deben tener los datos para ser válidos.

El concepto expresión regular, no está ligado a ningún lenguaje de programación en concreto, sino que es un concepto del área de la programación. Por lo que la mayoría de lenguajes lo suelen implementar o hay bibliotecas externas que nos permiten utilizarla.

Construyendo los patrones

Para construir los patrones, se hace uso de una simbología que tiene un significado especial, aquí os dejo una tabla con ella:

Por ejemplo con la siguiente expresión regular, podemos validar una IP:

^(([0-2][0-9][0-9]|[0-9][0-9]|[0-9])\.){3}(([0-2][0-9][0-9]|[0-9][0-9]|[0-9]))

Básicamente buscamos un bloque, formado por números del estilo a 2XX,1XX,XX,X siendo X cualquier número del 0 al 9, seguidos de un punto. Este bloque se repite tres veces y luego volvemos a usar el patrón de los números.

Leer más

Bienvenidos a esta entrada en la que intentaremos mostrar como se incluye en un ejemplo real, reconocimiento de voz en nuestras aplicaciones o cualquier otro software que desarrollemos por nuestra parte.

Para utilizar este tutorial, vamos a utilizar la API de Wit.ia una start-up de éxito, que hasta hace pocos días solo había llamado la atención al sector de los desarrolladores y a Facebook, quién la acaba de comprar.

Como funciona Wit.ia

Este servicio intenta, llevar el reconocimiento de voz de forma sencilla a cualquier plataforma y software que desarrollemos, ahora mismo soportan todos los dispositivos móviles, clientes webs, aplicaciones programas en C, nuestras Raspberry Pi etc.

Pero no sólo buscan reconocer las palabras que decimos y formar un frase, como otros muchos servicios, sino que intentan analizar esa frase y extraer datos de la misma. Por ejemplo, si nosotros le decimos “hay 50º en Madrid” el nos devolverá:

{
  "msg_id": "0b9d437c-cb85-4871-a1d6-993e51de6f26",
  "_text": "hay 50 grados en Madrid",
  "outcomes": [
    {
      "_text": "hay 50 grados en Madrid",
      "intent": "wit_location",
      "entities": {
        "temperature": [
          {
            "type": "value",
            "value": 50
          }
        ],
        "location": [
          {
            "value": "Madrid"
          }
        ]
      },
      "confidence": 0.58
    }
  ]
}

Como se puede ver, nos devuelve el texto, que le hemos dicho, como cualquier software de reconocimiento de voz. Pero luego también nos informa en “entities” de que hay dos entidades:

• temperatura, de la cual sabemos el valor, que es 50.
• localización de la cual sabemos el valor que es Madrid.
• Con una confianza en su predicción del 58% (esto es debido, a que casi no he entrenado el software).

Si queréis ver otro ejemplo, podéis ver el propio que ofrecen los autores del servicio.

Leer más

La idea que inspira este artículo es un pequeño desarrollo, que estoy realizando para nuestras Raspberry Pi y que espero que pronto os lo pueda contar en esta comunidad. Todo surge mirando las alternativas que hay ya creadas por otros autores, de sistemas de monitorización, de nuestras pequeñas placas.

Programación adaptada al dispositivo

Cuando uno piensa en programar, una de las cosas que debería tener muy presente, es el dispositivo que está desplegando nuestra solución. Por ejemplo:

• En ordenadores de consumo, deberíamos maximizar el rendimiento aunque esto suponga que la aplicación tenga un consumo mayor.
• En dispositivos móviles deberíamos maximizar la eficiencia y adaptarnos a las características de cada uno para evitar consumos innecesarios.

Esto me lleva a preguntar, cuando nos ponemos a programar, ¿programamos adaptándonos al dispositivo? y la respuesta en muchos casos es negativa.

En el caso que nos ocupa, hay varios sistemas ya programados de monitorización y cuando uno los prueba, se da cuenta que consumen entre un 10-15% de la CPU de nuestras Raspbery Pi. Hay que decir que nuestra placa, no es lo que se dice potente y sus recursos son limitados, así que se debería prestar un cuidado especial en evitar consumos superfluos.

Programación poco adaptada a la Raspberry Pi

Como bien decíamos, esta placa no cuenta con los recursos de un ordenador de escritorio (incluso hay móviles con más potencia que ella), pero entonces, por qué hacemos cosas como:

Leer más

La semana anterior hablábamos sobre Zeal, el programa con el que conseguir la documentación necesaria para programar. Siguiendo en esa línea, hoy os vengo a hablar de Doxygen, un programa con el que documentar tu código muy rápido.

Doxygen

Doxygen es el programa que nos va a permitir generar una documentación completa y profesional de cualquiera de nuestros proyectos y en cualquier de los lenguajes que utilicemos. Da igual que seamos más de Java, que de C que de PHP. Todos los proyectos que queramos distribuir o guardar para uso personal, deben estar bien documentados.

Documentar, ese proceso pesado y odiado

Seamos realistas, a nadie nos gusta documentar nuestro código y mucho menos generar esos grandes manuales de varias decenas de hojas donde explicamos cada una de las funciones y cómo funciona nuestro código. Por estas cosas, muchos proyectos personales se quedan sin documentar e incluso algunos proyectos comunitarios carecen de una buena.

La cosa cambiaría si hubiera una manera simple, rápida y poco costosa de realizar todo este proyecto.

Escribiendo el código para Doxygen

Para que Doxygen pueda generar la documentación es necesario, escribir algunos comandos dentro de nuestro código, para que él lo entienda.

Este es un pequeño código de ejemplo, de una parte de un programa mío.

/**
* @file queue.c
* @Author ganchito55
* @date 28/9/2014
* @brief Queue implementation
*/

#include 
#include 
#include 
#include "queue.h"

/**
* @brief Create a Queue
* @param Queue pointer
* @return 0 if all run ok, -1 for no enough memory
*/
int createQ(Queue *q){
Node *n;
    if((n=malloc(sizeof(Node)))==NULL){
        fprintf(stderr,"Error: no enough memory");      
        return -1;
    }
    n->next=NULL;
    strcpy(n->info,"FRONT");
    q->back=n;
    q->front=n;
    return 0;
}
/**
* @brief Is a Queue empty 
* @param Queue pointer
* @return 0 if empty, -1 no empty 
*/
int emptyQ(Queue *q){
    if(q->front==q->back){
        return 0;
    }
    else{
        return -1;
    }
}

Si sois observadores veréis que hay una sintaxis muy concreta en los comentarios. Esta sintaxis es la que utilizará Doxygen.

Leer más

El otro día hablábamos de cómo crear algoritmos y de la manera en la que deben evolucionar, para ir mejorando su comportamiento. Hoy queremos proponeros un acercamiento más a este mundo de la algoritmia usando como base las matemáticas.

La algoritmia y las matemáticas

La algoritmia como ciencia, está basada principalmente en las matemáticas, ya que son con estas herramientas con las que podemos medir el comportamiento de un algoritmo u orden de un algoritmo. Pero las matemáticas muchas veces aportan grandes recursos para realizar o mejorar algoritmos.

Las fórmulas matemáticas, progresiones o patrones matemáticos, son ampliamente estudiados en matemáticas y en muchas ocasiones se obtienen métodos más o menos sencillos, para calcular exactamente el problema que queremos resolver, sin tener que realizar un cálculo “a ojo” o por “fuerza bruta”.

La suma de los n primeros números

Gauss, uno de los más importantes matemáticos de la historia, descubrió una sencilla fórmula para sumar los n primeros número de una sucesión, el problema es el siguiente:

Queremos saber cual es la suma de todos los números entre 1 y 100, es decir la siguiente cuenta: 1+2+3+4+5…..+99+100

Hacer la cuenta en papel, tiene su trabajo, pero realizar en un ordenador es muy simple, basta con un bucle for y una variable donde vamos acumulando la suma. Pero y cuando no había ordenadores cómo realizaban este tipo de cuentas, la respuesta es utilizando una fórmula de Gauss:

Gauss pensó, bueno si hago parejas 1+100=101 , 2+99=101, 3+98=101 todas las parejas suman 101 y si hay 100 valores entonces tengo 50 parejas, luego el resultado es 101*50=5050. la fórmula es sencilla:

(A1+An)*n/2  siendo A1 el primer término, An el último, y n el número de casos.

Con esto os invito a buscar, antes de realizar nuestros algoritmos si hay una fórmula exacta con la que obtener directamente la cantidad, pues es el método más optimizado para calcularlo. Si hacemos una pequeña comparación vemos que utilizando la fórmula hacemos 3 operaciones aritméticas, mientras que utilizando nuestro bucle for estamos haciendo más de 100 operaciones aritméticas.

Leer más

Hacía tiempo que no dedicábamos una entrada específica relacionada con el mundo de la programación. Hoy vamos a hablar sobre los algoritmos, las distintas maneras de crearlos y los comportamientos de unos frente a otros.

Podríamos resumir el término algoritmia, como la ciencia que estudia los algoritmos, tanto su creación como su análisis. Para conseguir mejoras y seleccionar el más efectivo para cada tarea.

La algoritmia : la base de un buen programa

Muchos usuarios cuando empezamos a programar, utilizamos la típica frase de “lo importante es que funcione”, claro que es importante que el programa funcione. Pero si hay cuatro programas que cumplen con el objetivo, seguramente los cuatro no afronten el problema de la misma manera.

Para resolver un problema, se pueden utilizar múltiples métodos y algoritmos ya creados, aunque normalmente estos los tenemos que utilizar como base para crear nuestro algoritmo. El algoritmo debe ser refinado tanto como sea posible para agilizar el tiempo que tarde en ejecutarse nuestro programa.

Por ejemplo, si partimos de un programa que gestione facturas con unas 1000 líneas de código, no hay que buscar la optimización línea por línea, sino mirar que parte es la que tarda más tiempo, por ejemplo la ordenación y afrontar esta parte del programa, buscando mejorar su algoritmo. Hay algunos algoritmos que son difícilmente mejorables y otros que simplemente no se pueden mejorar, pero la mayoría de ellos suelen tener mejoras muy interesantes.

La creación de un algoritmo : un sencillo problema

Supongamos el problema: quiero que me hagas una lista de los números múltiplos de 4 y de 5 al mismo tiempo que hay en el rango 1-1.000.000

Lo primero que piensa un usuario, principalmente si es novato es utilizar el típico método de fuerza bruta:

#include <stdio.h>
#include <stdlib.h>
 
int main(){
int i;
int flag=0;
    for(i=1;i<1000001;i++){
        if(i%4==0){
            flag=1;
        }
        if(i%5==0 && flag==1){
            printf("%d\n",i);
        }
    }

return 0;
}

Este es el típico ejemplo de “pero si ya funciona, para que lo voy a mejorar”. Lo importante es que este sistema hace 3.000.000 comparaciones, por cada número compara si es múltiplo de 4 y si es de 5 y si cumple las dos condiciones, lo muestra.

Leer más