MVA y la aplicación del blog

Desde hace tiempo he estado usando (de manera muy intermitente) la plataforma de MVA para aprender más sobre el desarrollo de aplicaciones para las plataformas de Microsoft. He de decir que es bastante buena, y es que más allá de aprender dentro de ella, esta se comporta más como un índice donde se agrupan contenidos relacionados, dichos contenidos están estructurados para que el aprendeizaje sea fácil para el usuario, todo esto para un tema en particular.

En MVA, no existe un maestro, no hay tareas, no hay límites de tiempo, pero eso sí: hay exámenes, pero no es nada de que preocuparse son bastante sencillos y de opción múltiple. Por ello es bastante abierta y tu mismo debes saber controlar tus tiempos para organizar tu aprendizaje y sacar el mayor provecho de él.

En particular me agradan los llamados JumpStart ya que son cursos impartidos en vídeo por gente que está muy relacionada con el tema en cuestión. Dichos vídeos sirven como preparación para los exámenes de certificación. Los que más me desagradan son los cursos compuestos de solo links a otros sitios web en los que a veces no se explica el tema a fondo, pero que no dejan de suer útiles al momento del desarrollo.

Por ejemplo, mi ultima aventura fue el curso de Diseño de aplicaciones de Windows 8 en HTML 5, que me fue guiando paso a paso para desarrollar una aplicación totalmente funcional. Antes del curso yo ya había desarrollado apps para Windows 8 usando HTML/JavaScript y no sentía que tomarlo fuera necesario... pero no podía estar más equivocado, puesto que en el curso aprendí cosas que en verdad no sabía ni que existían. Producto de ese curso fue que surgió la aplicación "oficial" de este blog, que desde luego es de código abierto disponible acá blog-w8-app. No se olviden de descargarla de la Tienda Windows: 

 ¡Saludos!
@fferegrino :)

Algoritmos probabilistas

Las últimas prácticas de Análisis de algoritmos ( :'( ), esta vez es otro tipo de algoritmos, aquellos que emplean en azar para resolver el problema que se les asignó. A estos se les llama probabilistas y según la Wikipedia en español, hay de tres tipos; mismos tipos que nos tocó ejemplificar mediante algunos algoritmos conocidos empleando POO (lo cual es un poco difícil para ejemplos tan sencillos), son los siguientes:
Integración de Monte Carlo
Apelando al hecho de que una integral es la sumatoria de la infinidad de resultados de evaluar una función en un intervalo dado, se toman puntos de evaluación aleatorios dentro de ese intervalo dado, se evalúan y se van acumulando para luego realizarles un ajuste matemático, les diría que lo buscaran en Wikipedia, pero este documento me resultó especialmente revelador.

Para el caso de la implementación de POO lo que se consideró fue la creación de dos clases Random y Funcion, la primera para generar números aleatorios y la segunda para evaluar la función.

Aproximación a π
Para este caso se toma un cuarto de círculo de radio = 1, y se lanzan n dardos hacia él de esos n dardos supongamos que m aciertan en él entonces mediante matemágia, podemos encontrar que  π ≈ 4 * m / n

Para (mal) aplicar la POO, existe una clase que hace uso de Random, la clase definida en el ejericio anterior y de otra, llamada Aproximación en la cual se realiza la simulación de los dardos

Comprobación de primalidad (Algoritmo Monte Carlo)
Existe un test de primalidad, inventado por Fermat que nos dice que si tomamos la siguiente frómula a^(n-1) % n para cualquier número a ∈ [1,n-1] y si el resultado de eso es distinto de 1 entonces sabemos que n no es primo. Tomando una gran cantidad de números con valores aleatorios para a ∈ [1,n-1] podríamos asegurar con cierta probabilidad si un número n es primo. Si el test falla, es decir el resultado para cualquiera a es distinto de 1 podemos asegurar que n no es primo.

Resolución del problema de las N reinas (Algoritmo Las Vegas)
El ya conocidísimo problema delas N reinas también se puede resolver mediante probabilidad, es decir, tomamos la columna 1 y colocamos la primera reina, después para la segunda columna tratamos de colocar la siguiente reina en una posición elegida aleatoriamente, si se logró, continuamos con la siguiente columna, y así hasta colocar las N reinas o no poder colocar una, en ese caso falla.
Bastante simple.
Las primeras dos corresponden a la práctica 5, implementada en C++, y la segundas están implementadas en C#, con interfaz gráfica para Windows Phone 8 en XAML. El código, en analizando-algo.

¡Saludos!
@fferegrino :)

Todos pueden aprender ciencias computacionales

Hace mucho me surgió el deseo de ser maestro de esta área que tanto me agrada, enseñar lo que sé sobre programación, algoritmos, estructuras de datos y demás. Sé que voy por el camino correcto puesto que entre mis planes está el hacer una maestría y buscar regresar a alguna de esas escuelas que me formaron  pero esta vez como maestro, pero por mientras quisiera comenzar haciendo algo que, aunque sencillo y pequeño, ayude a acercar a más niños (y también no tan niños) a las ciencias computacionales.

Buscando en internet encontré varios proyectos interesantes que tratan precisamente de eso, acercar el conocimiento a la mayor cantidad de gente posible, entre ellos está el proyecto de Code.org (http://code.org/), la Computer Science Education Week (http://csedweek.org/) y el último, que me parece el más interesante para lo que quiero hacer: Computer Science Unplugged (http://csunplugged.org/).

Este útlimo es programa de enseñanza diseñado específicamente para nivel primaria, de tal manera que el aprendizaje se lleve a cabo mediante juegos y actividades que resulten entretenidas para los niños, sin embargo creo que también se podría usar para cualquier persona que no esté involucrada para nada en el ambiente de la computación.

Por lo pronto veré la posibilidad de usar como guía el programa de Computer Science Unplugged para impartir un curso cerca de donde vivo, espero que se pueda hacer y contarles cómo me fue.

Enseñando también se aprende.

¡Saludos!
@fferegrino :)

Codificación voraz de Huffman

La codificación Huffman es un algoritmo usado para la compresión de datos. Dicho algoritmo hace uso de una tabla de códigos para escribir un determinado símbolo, donde la tabla ha sido rellenada basándose en la probabilidad estimada de aparición de cada símbolo. A cada símbolo le corresponde un código (secuencia de 1 y 0) de longitud variable, puesto que los símbolos cuya aparición es menos frecuente reciben códigos más largos, mientras que los que aparecen más reciben códigos más cortos.

Para la ESCOM, el trabajo fue hacer la implementación voraz de dicho algoritmo, la cual tiene como variante que la comstrucción de la tabla de códigos es distinta para cada archivo, tomando solo en cuenta los símbolos contenidos en él y la cantidad de veces que aparecen.

He de decir que es de las prácticas más pesadas que he tenido en todo lo que llevo en la escuela, dentro del programa se hace uso de recursividad, operaciones a nivel de bits y estructuras de datos a más no poder:
  • Se usa una lista para para ir almacenando las frecuencias de cada caracter
  • Se usa un arreglo de árboles para generar el árbol único de códificación
  • Se usa una cola para obtener el código asignado a cada símbolo

El código, que se encuentra en el proyecto analizando-algo en GitHub, está muy comentado tratando de hacerlo lo más entendible posible. 

¡Saludos!
@fferegrino :)

Programación dinámica y la sucesión de Fibonacci

(Wikipediazo)En informática, la programación dinámica es un método para reducir el tiempo de ejecución de un algoritmo mediante la utilización de subproblemas superpuestos y subestructuras óptimas.

Decir que un problema tiene subproblemas superpuestos es decir que se usa un mismo subproblema para resolver diferentes problemas mayores. Por ejemplo, en la sucesión de Fibonacci (F3 = F1 + F2 y F4 = F2 + F3) calcular cada término supone calcular F2. Como para calcular F5 hacen falta tanto F3 como F4, una mala implementación para calcular F5 acabará calculando F2 dos o más veces.

Esto se puede evitar guardando las soluciones que ya hemos calculado. Entonces, si necesitamos resolver el mismo problema más tarde, podemos obtener la solución de la lista de soluciones calculadas y reutilizarla. Este acercamiento al problema se llama memoización (no confundir con memorización; en inglés es llamado memoization, véase en). Si estamos seguros de que no volveremos a necesitar una solución en concreto, la podemos descartar para ahorrar espacio.

Comenzando con el pseudocódigo:
FUNC Fibonacci (↓n: NATURAL): NATURAL
   VARIABLES
       tabla: ARRAY [0..n] DE NATURALES
       i: NATURAL
   INICIO
       SI n = 0 ENTONCES
           DEVOLVER 0
       SINOSI n = 1 ENTONCES
           DEVOLVER 1
       SINO
           tabla[0] := 0
           tabla[1] := 1
           PARA i = 2 HASTA n HACER
               tabla[i] := tabla[i-1] + tabla[i-2]
           FINPARA
           DEVOLVER tabla[n]
       FINSI
   FIN

Una implementación en C de este algoritmo es la siguiente (he cambiado los tipos de dato para que se puedan calcular valores más grandes):
long long fibonacciArreglo(int n) {
    long long * lista;
    if(n == 0) return 0;
    if(n == 1) return 1;
    lista = (long long *) malloc(sizeof(long long) * n);
    lista[0] = 0;
    lista[1] = 1;
    int i;
    for (i = 2; i <= n; i++) {
        lista[i] = lista[i-1] + lista[i-2];
    }
    return lista[n];
}
Como podemos ver, se reservan n espacios de memoria para almacenar todos los valores de la sucesión, aunque solamente se emplean dos de estos valores a la hora de cálcular el siguente número. Lo cual deriva en un "desperdicio" de memoria. 

Es por eso que basándome en el enunciado que está más arriba en negritas, pensé que implementar una cola sería una opción para ahorrar espacio, podemos agregar dinámicamente los nuevos valores y quitar los que ya no usaremos, de tal manera solo tendríamos en memoria los valores necesarios para calcular el siguiente número en la sucesión. El código queda como sigue:
long long fibonacciCola(int n) {
    Cola cola;
    if (n == 0) return 0;
    if (n == 1) return 1;
    creaLista(&cola);
    formar(&cola, 0);
    formar(&cola, 1);
    int i;
    for (i = 2; i <= n; i++) {
        // Quitamos el elemento menos reciente
        long long fi1 = atender(&cola);
        // Obtenemos el valor del siguiente más reciente
        long long fi2 = valorPrincipio(&cola);
        // Almacenamos el resultado en la cola
        formar(&cola, fi1 + fi2);
    }
    return valorFinal(&cola);
}
De esta forma aseguramos que para cualquier tamaño de n solo se ocupen a lo más 3 espacios de memoria.

El código está disponible en la sección de extras del proyecto analizando-algo

¡Saludos!
@fferegrino :)

Prácticas de análisis de algoritmos [ESCOM]

A lo largo del semestre, en la materia de Análisis de Algoritmos que llevo con el profesor Edgardo Franco tenemos que realizar varias prácticas. Las prácticas consisten en programar algoritmos conocidos para analizar su comportamiento, tanto en tiempo como en memoria consumida, mientras resuelven problemas de "gran" tamaño.

Muchas (si no es que todas D:) estarán hechas para C, para Linux, esto debido a la librería empleada para medir los tiempos que consume la ejecución del algoritmo. Para facilitar la compilación cada práctica cuenta con un archivo Makefile, el cual contiene todas las instrucciones para compilar y ejecutar las prácticas. Dado que tenemos que analizar los tiempos de ejecución y a veces estos pueden ser muchos, para la ejecución de cada programa redireccionamos la salida estandar para que escribiera directamente a un archivo que podemos manejar sencillamente en una hoja de cálculo. Esto se puede ver en el archivo .sh que acompaña a cada práctica.

Todas las prácticas tienen comentarios, unas más, otras menos, pero los tienen. Aún así si queda alguna duda pues no dudes en preguntar. Otra cosa importante es que estas son solo las propuestas de solución que presentamos, no las copies directamente, basate en ellas o usa porciones del código, eso se vale. El link de descarga está al final del artículo ;).

Hasta el momento hemos realizado 3 prácticas:

Práctica 1: "Pruebas a posteriori (Algoritmos de ordenamiento)"

Con base en el archivo de entrada proporcionado que tiene 200,000 números diferentes. Ordenarlo bajo los siguientes métodos de ordenamiento y comparar experimentalmente las complejidades de estos.
  • Burbuja (Bubble Sort)
  • Burbuja Simple
  • Burbuja Mejorada
  • Inserción (Insertion Sort)
  • Selección (Selection Sort )
  • Shell (Shell Sort)
  • Ordenamiento con árbol binario de busqueda (Binary Search Tree)

Práctica 2: "Análisis temporal y notación de orden (Algoritmos de busqúeda)"

Con base en el ordenamiento obtenido a partir del archivo de entrada de la práctica 01 que tiene 200,000 números diferentes. Realizar la búsqueda de elementos bajo 3 métodos de búsqueda y variantes con procesos ligeros, realizar el análisis teórico y experimental de las complejidades; así como encontrar las cotas de los algoritmos.
  • Búsqueda lineal o secuencial (No recursiva)
  • Búsqueda binaria o dicotómica (No recursiva)
  • Búsqueda en un árbol binario de búsqueda (No recursiva)
  • Modificar los tres algoritmos para trabajar con procesos ligeros (Hilos).

Práctica 3: "Divide y vencerás (Rotación de una imagen)"

Implementar el algoritmo de rotación de imágenes que emplea la técnica divide y vencerás. La imágen a girar es cuadrada, y es un .bmp de 24 bits.

Descargas:
Como desde hace tiempo, puedes seguir el proyecto en GitHub analizando-algo (recomendado)
O descargar cada una de las tres prácticas de manera individual:
Práctica 3
Práctica 2
Práctica 3


¡Saludos!
@fferegrino :)

"Mapeando" de procedimientos almacenados a clases en C#


Hace rato, mientras no tenía clase me dispuse a escribir un pequeño programita para facilitarme la vida con algo (asquerosamente tedioso) que tenía que hacer. Y es que lo que tenía que hacer hasta parece arcaíco: Se trata de hacer consultas desde una aplicación web a una base de datos mediante procedimientos almacenados, para ello hay que generar una clase asociada al procedimiento para facilitar la persistencia de los datos dentro de la aplicación.

Hay consultas enoooooooooooooooooooooormes, inclusive hay algunas de más de 20 o 30 columnas lo cual representa perder mucho tiempo creando la clase asociada, aunque a decir verdad yo no lo hago por el tiempo, sino por el aburrimiento que representa hacerlo. Acá mi propuesta de solución:

La idea que se me ocurrió fue colocarles una especie de "clave" para conocer el tipo de dato de cada columna así como el nombre que usaría para ella dentro de la aplicación. La clave elegida fue: --|tipo de dato|nombre dentro de la aplicación  dada la facilidad con la que una cadena de ese tipo es fácilmente encontrable usando expresiones regulares, para ello se requiere del siguiente patrón: --\|[a-zA-Z0-9]+\|[a-zA-Z0-9]+. Además en el programa usé una plantilla de texto T4 para generar el código, esas plantillas son útiles para generar código como en esta ocasión, el ejemplo es sencillo y fácil de entender.

Colgué el proyecto completo en GitHub para que todos pudieran descargarlo, yo pienso que le seguiré añadiendo funcionalidad conforme la vaya necesitando (hasta que me aburra de hacer otra cosa :P).

¡Saludos!
@fferegrino :)

Mis apps para Windows/Windows Phone 8

Últimamente he andado muy ocupado (no tanto), haciendo unas cuantas aplicaciones para Windows Phone 8 y Windows 8 esperando ser parte del programa Microsoft Student Partners 2013.  Al momento llevo 6 aplicaciones publicadas entre la Windows Store y la Windows Phone Store. De algunas ya les he contado y de otras no. En fin, son estas:

Cuantos días
¿Alguna vez has querido saber cuantos días faltan para una fecha importante? Ahora lo puedes saber, con Cuantos días para Windows Phone 8 ten siempre a la vista cuantos días faltan para tu cumpleaños, el re-estreno tu serie favorita o cualquier otra cosa.


C0NV3R7
Un sencillo convertidor entre sistemas numéricos. Convierte de los sistemas binario, octal, decimal y hexadecimal.
De esta ya les había hablado.



RecetApprio(La obra maestra)
Un recetario hecho para ti, que no tienes ganas ni dinero para cocinar algo "gourmet". Recetas simples y sencillas, elaboradas por un experto en la materia de alimentar personas de forma deliciosa, rápida y barata.
En esta conté con la colaboración en el diseño de Julio Montaño, al cual agradezco mucho :). Además aprovecha de los servicios en la nube de Windows Azure.


BombFlipper
Diviértete con este juego que combina el buscaminas y el sudoku para entretenerte como no tienes idea, ejercita tu cerebro tratando de llegar al nivel más alto que puedas y cuando estés ahí comparte tu récord con tus amigos.


El Agente
Diviértete ayudando a este despistado agente a recuperar los papeles que el viento se llevó, pero cuidado, hay algunos papeles que quizá no desee recuperar.


Ojalá puedan descargarlas y valorarlas, así mismo si estás interesado en el desarrollo de alguna de ellas mándame un correo y con gusto vemos cómo hacerle.

¡Saludos!
@fferegrino :)

Invertir una cadena [C#]

Durante la plática de reclutamiento para Microsoft que hubo hace unos días en la ESCOM hicieron una prueba a los asistentes, la prueba consistía en escribir el código de dos funciones:
Una capaz de invertir una cadena, es decir, pasar de "this is a string" a "gnirts a si siht"
Otra muy similar pero solo debía invertir las palabras, pasando de "this is a string" a "siht si gnirts"
Basándonos en un prototipo de función más o menos así:
char* reverse(const char* str)

El lenguaje a usar era cualquiera con el que te sintieras cómodo, C#, C, Java... en fin. La idea era que usaras la menor cantidad de herramientas provistas por el framework o por el lenguaje que escogiste (¡no se valía el .Reverse()!), es decir que todo lo hicieras "artesanalmente". Eso si, no recuerdo muy bien cuanto tiempo dieron para escribir.

Por suerte yo me había encontrado con un problema similar unos días antes, así que creo que no me fue tan mal en esta. Mi solución la propuse en dos lenguajes, C para la primera y (por cuestiones de tiempo) C# para la segunda. Ahora vengo acá a colocar mis soluciones un poco más pensadas y totalmente funcionales escritas en C#:

using System;
using System.Linq;
using System.Text;

namespace ReverseStringsMsft
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "this  is  a string";
            string res = Reverse(s);
            string resWord = ReverseWords(s);
            Console.WriteLine(s);
            Console.WriteLine(res);
            Console.WriteLine(resWord);
            Console.Read();
        }

        /// <summary>
        /// Invierte una cadena
        /// </summary>
        /// <param name="str">La cadena que será invertida</param>
        /// <returns>Una nueva instancia de String</returns>
        public static string Reverse(string str)
        {
            if (str == null)
                return null;
   // Convertir a un arreglo
            char[] cr = str.ToArray();
   // Llamamos a la funcion para toda la cadena
            Reverse(cr, 0, cr.Length - 1);
            return new string(cr);
        }

        /// <summary>
        /// Invierte las subcadenas (separadas por espacios) contenidas dentro de una cadena
        /// </summary>
        /// <param name="str">La cadena que será invertida</param>
        /// <returns>Una nueva instancia de String</returns>
        public static string ReverseWords(string str)
        {
            if (str == null)
                return null;
   // Convertir a un arreglo
            char[] cr = str.ToArray();
            int wordStart = 0;
            int end;
   // Recorremos la cadena para encontrar espacios
            for (int i = 0; i < cr.Length; i++)
            {
                char c = cr[i];
    // Por cada espacio o cada vez que lleguemos al final de la cadena
    // llamaremos a la funcion especialmente para la ubicacion de 
    // la palabra encontrada
                if (c == ' ' || i == cr.Length - 1)
                {
                    end = i - 1;
                    Reverse(cr, wordStart, end);
                    wordStart = i + 1;
                }
            }
            return new string(cr);
        }

        /// <summary>
        /// Cambia de posición los caracteres desde <paramref name="start"/> a
  /// <paramref name="end"/> hasta que todos estén invertidos
        /// </summary>
        /// <param name="str">El arreglo a ser invertido</param>
        /// <param name="start">Inicio</param>
        /// <param name="end">Final</param>
        private static void Reverse(char[] str, int start, int end)
        {
            for (; start < end; start++, end--)
            {
    // Cambiamos uno a uno los caracteres desde la posicion
    // inicial hasta la final, y aumentamos las variables para irlos 
    // intercambiando como deseamos
                char aux = str[start];
                str[start] = str[end];
                str[end] = aux;
            }
        }

    }
}


¡Saludos!
@fferegrino :)

C0NV3R7, convertidor entre bases numéricas


Esta vez vengo a contarles que el otro día mientras divagaba mi mente en la clase de Fundamentos de diseño digital se me ocurrió una "idea" para una app. Y es que digo "idea" porque no es nada nuevo, en clase estábamos viendo los distintos sistemas numéricos y la conversión entre ellos. Y pues de eso se trata la app: de un conversor numérico entre bases, pones un número y en seguida consigues su equivalente en octal, binario, decimal y hexadecimal.

En realidad el código es más que sencillo. La gran novedad es que en esta traté de emplear a fondo el patron de diseño MVVM, dejando toda la lógica de la aplicación en un ensamblado aparte, que usé para las plataformas Windows 8 y Windows Phone 8. En realidad la aplicación es tan sencilla que la interfaz usada en una es igual a la otra.

Pongo el link a las aplicaciones en la Windows Store y en la Windows Phone Store


Además del código del que salieron ambas aplicaciones:

C0NV3R7.rar

PD: Todo lo que he aprendido sobre Windows Phone fue gracias a estos vídeos hechos por Rodrigo Díaz Concha. Chéquenlos, están muy buenos.

¡Saludos!
@fferegrino :)

Proyectos de Compiladores, ESCOM

Esta vez los saludo con un megapack: los proyectos de la asignatura de Compiladores en la ESCOM, entre ellos un conversor expresión regular-AFN-AFD (Java) y un analizador léxico-sintáctico (C). Y es que por problemas técnicos (y un poco de flojera) no los subí en el tiempo en el que fueron realizados.

La asignatura la cursé con el profesor Juárez Gambino Omar, junto con mi equipo: Cruz Cruz Jorge y Gonzales Rodríguez  Javier (@newbie_geek). A lo largo del semestre aprendí demasiado, y parte de ello fue que había mucho tiempo para practicar lo aprendido, aplicando el conocimiento en varias practicas a lo largo del curso.

La primera, fue un programar un analizador léxico, código y un sencillo reporte el cual coloco a continuación:

La segunda, el conversor de expresión regular a autómata finito no determinista, y de autómata finito no determinista a uno determinista. Este está hecho en Java:

La tercera práctica consistió en utilizar el lenguaje Flex para generar un analizador léxico (muy básico) para C, si ya conocen el lenguaje sabrán que la extensión (por convención) es .l:

Para la cuarta práctica comenzamos a emplear Bison, para ayudarnos en la construcción de un analizador sintáctico, la práctica fue individual, porque en realidad era sencilla. Basarnos en un ejemplo y hacer una calculadora:

La quinta y última práctica fue un analizador léxico y sintáctico para C haciendo uso de Flex y Bison juntos, en teoría es la más complicada, y que requirió más trabajo pero no por eso faltó:

La finalidad de poner estos códigos y reportes como descargables es que tú los puedas checar, leer, tratar de entender y posteriormente implementar a tu modo. No simplemente los descargues y entregues, o lo que es peor, no los bajes y cambies los nombres a las variables (nos gustan los nombres de nuestras variables, no los cambies). Como dicen "allá afuera no vas a encontrar las cosas hechas", así que lo ideal sería que estudies y trates de comprender el código.

Si hay alguna parte que no te queda clara puedes comentarla debajo o enviarme un correo, ya de menos un tuít. Pero hagas lo que hagas, NO COPIES.

¡Saludos!
@fferegrino :)

BombFlipper - Windows 8

Sé que tengo rato programando para Windows 8 y la verdad es que es divertido. Durante unos de esos arranques se me ocurrió hacer una versión de un minijuego incluído dentro de otro juego, el no tan famoso Voltorb Flip. No todo fue miel sobre hojuelas, puesto que sería mi primera aplicación hecha desde cero. 

La más dura decisión fue sobre qué tecnología escoger, dura decisión entre C# y XAML o HTML y JavaScript. De C# conozco mucho más que de JS, pero de HTML sé mucho más que de XAML Sinceramante para la interfaz prefería usar la magia de HTML con el poder de CSS, debido a la experiencia que tengo usándolo (además de que la otra opción era completamente desconocida para mi). Sin embargo, para la parte de la lógica solo pensaba en usar C# debido a la cantidad de cálculos necesarios para implementar el juego.

Al final me decidí por C# y su acompañante, porque se me hizo la opción más sólida y por que representaba un reto aprender sobre el desarrollo de interfaces, y es que, aunque el producto final no es de lo más pulcro considero que fue un buen aprendizaje.

Aún queda mucho por hacer, más que anda en la interfaz de usuario porque ni a mi me resulta muy amigable, los invito a descargar el juego en la liga que está más abajo. Si lo prueban les pudo que me comenten aquí o al correo su opinión y sugerencias.



¡Saludos!
@fferegrino :)

BluepointerV2



Hace algunos días les contaba de la aplicación Bluepointer que hice para una asignatura en la escuela, hoy he decidido mejorarla para hacerla más útil.

He retirado el control tipo "swipe" y puesto botones en su lugar. Además de añadirle funcionalidad para navegar hasta el inicio o final de la presentación y poder cerrarla desde el dispositivo.

La aplicación la pueden encontrar ya en la tienda Google Play en el siguiente enlace.


Si tienen sugerencias con respecto a la app, no duden en comentárlas.

¡Saludos!
@fferegrino :)

El agente [Videojuego]


Como parte de una iniciativa de Microsoft para impulsar el desarrollo de videojuegos para la plataforma de Windows 8, recibí una invitación para participar en un curso en línea sobre el tema. Dentro del curso se incluyeron sesiones tanto de programación de videojuegos, creación de historias y realización de animaciones.

La meta del curso era tener publicado el juego en la Windows Store, para esto teníamos que plantear una idea, desarrollar a los personajes, dibujarlos, animarlos, programarlos... de ahí entrar en todo el proceso que requiere la tienda para publicar cualquier aplicación en ella. El premio era un reconocimiento por la participación.

Ahí además fue que conocí la poderosa herramienta Construct 2, herramienta en la cual hice El Agente, un juego inspirado en el trabajo que desempeño diario (no he escrito sobre esto, ya sé). La idea es que un hombre de negocios perdió todos sus documentos importantes debido al viento, tu labor es recuperarlos casi todos, puedes inventarte una excusa para aquellos que no te benefician tanto.

Ya por último coloco el link a la tienda de Windows para que lo descarguen y lo jueguen;

Y aquí está el arte del juego

¡Saludos!
@fferegrino :)

Bluepointer

Bluepointer es un control remoto de diapositivas, usando esta aplicación es sencillo controlar una presentación en Powerpoint. La aplicación se comunica con la PC vía bluetooth. Esta es la tercera y última aplicación que desarrollé para la unidad de aprendizaje Application development for mobile devices (o móviles simplemente) en la ESCOM. 

La idea surgió ya que la sugerencia del profesor era conectar un microcontrolador (a través de un módulo bluetooth) con el teléfono, pero al encontrar dificultades para conseguir el mentado módulo, decidí irme por algo más sencillo ya que para mi lo principal era hacer uso de las capacidades que un dispositivo móvil nos ofrece, como la conectividad.

La aplicación en sí es sencilla, una vez establecida la conexión entre el dispositivo (cliente) y la pc (servidor), lo único que realiza el cliente es enviar "comandos" que resultan ser simples enteros para indicarle al servidor qué acción debe realizar, además, como parte de la funcionalidad extra que me solicitó el profesor, desde el teléfono se pueden enviar mensajes de texto hacia la PC, para lo cual se escribe un arreglo de bytes en el flujo de salida.

Acá un vídeo de la aplicación en todo su esplendor:



Y desde luego, el link hacia la app:


Código fuente de la aplicación para Android (en GitHub): bluepointer-android
Código fuente del servidor (en GitHub): bluepointer-java-server

¡Saludos!
@fferegrino :)

Probando la AppFactory (II)

Hace poco les contaba que probé la AppFactory y que estaba, digamos, contento con lo que había visto, comentaba, también que había enviado mi aplicación para que la certificaran y estuviera pronto en la tienda. Sin embargo, mi desencanto no podría ser peor...

Resulta pues que las aplicaciones creadas dependen completamente de internet, de por si me resultó un poco raro que en el manifiesto de la aplicación estuvieran marcados los permisos de Internet y Redes Privadas. La app fue rechazada varias veces porque declaraba el uso de internet y no incluía una póliza de privacidad para el usuario ( ¬¬).



Mi app en ningún momento hace uso explícito de internet puesto que solo consta de 4 módulos de noticias (texto estático)  y uno de galería (imágenes estáticas). Nada consumido bajo demanda, ni conexiones a servicios web, mucho menos cuentas de usuario.

Debuggeando me di cuenta de el horror: Cuando la aplicación inicia se conecta a un web service para descargar información necesaria para el inicio de esta misma, lo cual significa que si el usuario final no tiene conexión a internet jamás podrá iniciar la app. Traté de romper ese vínculo de las aplicaciones con internet pero tampoco pude y es que me parece que la plataforma a experimentado algunos problemas en los últimos días.

La verdad es que no sé para que sea necesaria la conexión a internet para arrancar nuestra app, pero se me ocurren muchas teorías misteriosas, entre ellas una en donde creo que si en algún momento dado dejas de pagar por el servicio de AppFactory tu aplicación será inservible hasta que vuelvas a cumplir los pagos.

En resúmen: Vaya decepción que no pueda usar mi aplicación si no estoy conectado a internet y vaya decepción que mi app no haya quedado "lista" para certificarse inmediatamente después de haberla descargado de la plataforma de AppFactory.

¡Saludos!
@fferegrino :)

El problema del agente viajero y los algoritmos genéticos


Algoritmos genéticos
De las clases aprendí que los algoritmos genéticos son métodos de búsqueda y optimización inspirados en la evolución y en la base genética que esta implica. Para el uso de un algoritmo se genera un conjunto de soluciones posibles (nombraremos a cada una de estas soluciones "individuos") a nuestro problema (llamada población), esta población es mutada y recombinada mediante acciones aleatorias, como sucede en la evolución, además son sometidos a una evaluación para decidir cuales son los más aptos y separarlos del resto, que será descartado. En fin.


Llegó momento de entregar el proyecto final de la unidad de aprendizaje Genetic Algorithms, y como proyecto final elegí el clásico problema del agente viajero (Traveling Salesman Problem, TSP), y digo clásico porque en verdad resulta ser de los más usados para ejemplificar una de las muchas aplicaciones de este tipo de algoritmos.

TSP
El problema, más o menos, enuncia que: Un agente viajero tiene que visitar n ciudades sin pasar por la misma ciudad más que una vez, así mismo desea recorrer las ciudades trasladandose lo menos posible entre ellas, esto quiere decir que desea encontrar la ruta más corta para pasar por todas y cada una de ellas solamente una vez.

El problema es sencillo y se puede resolver con un algoritmo genético simple, basta con que se emplee técnicas permutativas (evitando así que se de una solución en la que se repitan ciudades para una ruta).

Solución
Para llegar a la solución de este problema escribí una pequeña aplicación en C#, en donde se emplea un algoritmo genético para llegar al resultado. 

Para la cruza se emplea el método de Cruza Cíclica, la mutación se realiza intercambiando dos genes seleccionados aleatoriamente y en la selección se elige a la mitad de individuos con mejores soluciones.

Código
Ahora sí, lo más interesante, además de lo ya mencionado dentro de la aplicación se usa la API de gráficos. Me da la impresión de que por ahí puede haber un poco de desperdicio de memoria pero pues ¡meh!
Traté de comentar el código todo lo que pude a manera de que quede claro así que espero les sirva y cualquier comentario y/o aclaración por correo, Twitter o en la sección de comentarios.

Encuéntralo en GitHub: Traveling Salesman Problem - C#

¡Saludos!
@fferegrino :)

Probando la AppFactory


Hace unos días obtuve un pase para probar la nueva AppFactory, que, como su nombre lo indica, e suna fábrica de aplicaciones para Windows 8. El concepto es simple: el usuario del sistema puede crear aplicaciones sencillas sin escribir una sola línea de código, el día de hoy vengo a contarles mi experiencia.

De entrada, el sitio web me gustó, agradable a la vista y muy limpio, demostrando la simplicidad de la que se precia. Una vez logueado nos mostrará las aplicaciones que hemos creado (por primera vez 0) y debajo nos da la opción de crear una nueva. La verdad, la primera vez que lo probé no sabía por donde seguir una vez que elegí crear la nueva app, duda resuelta al momento de revisar el vídeo tutorial y por lo cual considero que sería bueno colocar ese tipo de recursos dentro del sistema, y que estén disponibles en todo momento para el usuario.

No me agradó demasiado el hecho de tener que colocar las imagenes sin pleno conocimiento de a donde iban a parar algunas de ellas, considero que sería bueno tener una previsualización de como y donde van a quedar esas imagenes que se nos solicitan al inicio. Me llevé un pequeño disgusto al ver que una imagen no se veía bien en mi aplicación final puesto que no pude encontrar la manera de reemplazarlas.

Después fue tiempo de continuar con el desarrollo de mi aplicación añadiendo módulos, para esta utilicé 6 módulos en total: 5 de Noticias y 1 de Galería. 

Consideré que el de noticias sería más apto para presentar recetas de una manera más simple, el módulo, propiamente dicho funciona perfecto para presentar información fija, como puede ser el caso de recetas, descripciones, definiciones. Sin embargo me agradaría más tener la opción de añadir texto sin que tenga que ser una noticia, es decir, que no todos los campos sean necesarios.

En cuanto a la galería todo perfecto, nos permite subir imagenes y ponerles un título, cumple su funcionalidad.

Una vez completada la app, elegí publicarla, paso en el que volví a requerir asistencia del tutorial. Siguiendo los pasos fui capaz de descargar, compilar y enviar para revisión mi aplicación a la Windows Store. Ojalá me publiquen pronto :).

En resúmen: el servicio resulta bastante bueno y cumple lo que promete, ni una sola línea de código escrita por mi (me quedé con las ganas). Sin embargo creo que hay detalles que deben de pulirse, así como módulos que podrían dividirse y no ser tan genéricos. También me encantaría la posiblididad de usar los contratos de Windows 8 (por ejemplo: el contrato de Sharing, para poder compartir las imagenes y noticias que tengamos en nuestra app). Las posibilidades son muchas y creo que la AppFactory las puede aprovechar.



¡Saludos!
@fferegrino :)

Revolución OS

Hace unos días, en clase de compiladores nos tocó ver un documental (muuuuuuy viejo) acerca del surgimiento del movimiento de software libre, sin embargo. A pesar de que fue estrenado en 2001 se mantiene vigente e interesante. Siempre será bueno saber un poco de historia, en el vídeo se pueden observar a personalidades de la talla de Richard Stallman y Linus Torvalds.

Lo coloco acá abajo para que ustedes lo puedan ver:


Espero pronto poder hacer un post acerca de películas y documentales acerca de la historia del software, cómputo y tecnología.

¡Saludos!
@fferegrino :)

tacOmetro

Cuando el profesor de aplicaciones móviles me comentó sobre la idea de hacer un tacómetro para Android me pareció un poco descabellada la idea, después de mucho pensarlo (y buscar mucho en internet) se pudo, aquí una breve crónica al respecto, además del enlace a la aplicación y el reporte entregado.

Idea

La idea es hacer que mediante la cámara del dispositivo se perciba una imagen, de esta se extraiga la información necesaria como para crear un análisis en las variaciones de ilumnación de la misma. Se parte de la premisa de que cada que un objeto gire frente a la cámara habrá pequeñas (o muy grandes) variaciones en la iluminación. Entonces, contando estas variaciones y el tiempo que se lleva siguiendo podemos obtener la medición de las revoluciones por minuto. Esta parte de la aplicación se puede observar en este vídeo, en él se aprecia como es que la aplicación responde a las variaciones de iluminación:

El dispositivo a medir

Desde el inicio se supo que no podríamos medir cualquier cosa, ya que la prueba se debe desarrollar en ambiente controlado así que agarré mis Legos y de armar se trató esto:

Para finalizar

Ya para terminar les muestro un vídeo del producto funcionando, así como el reporte para que lo descargen y el enlace a la aplicación.

Ah, por cierto, esta la considero una aplicación muerta (ya no piennso seguirla actualizando) así que si alguien lo desea puede obtener el código fuente en GitHub para emplearlo como desee.

Reporte


¡Saludos!
@fferegrino :)

Para "perder el tiempo"

Si eres como yo, de esos que les gusta pasear por el internet, seguro te gustará conocer unos cuantos sitios más. Encontré unos blogs acerca del espacio y la tierra, estos sitios tienen unas cuantas fotos impresionantes y que espero ustedes disfruten "perdiendo su tiempo" tanto como yo lo hice.

Infinity Imagined
Heck Yeah Galaxies
Pappus' plane
Terra et Cosmos
Col. Chris Hadfield

En fin, todos son interesantes, si conocen otro más, coméntenlo para agregarlo a la lista.

¡Saludos!
@fferegrino :)

AndroidWebServer

La aplicación

Para construir un servidor web es necesario contar con un programa que haga las veces de “servidor”, es decir, que esté escuchando siempre en uno o varios sockets a la espera de algún cliente para servirle la información solicitada.
La interfaz gráfica será muy sencilla, una etiqueta para mostrar la IP del servidor, un botón para encender o apagar el servidor web y una consola para ver que es lo que está sucediendo, es decir llevar un registro de eventos.

Super query sobre Northwind

Antiguamente, en mis clases en UPIITA el profesor Carlos de la Cruz había pedido un query sobre la base de datos Northwind que nos devolviera las órdenes que tuvieran dos productos iguales, en aquel momento no pude hacerlo (t_t), pero ahora que lo ha vuelto a pedir en el grupo de mi maigo @Rosend_mc, me lo tomé personal y aquí está.

La consulta nos regresará pares de órdenes, con al menos dos productos iguales, sé que es enooorme y que seguro hay una solución mejor pero como siempre digo: por algo se empieza. Dejo el Script en SQL y un PDF en el que intento explicar los detalles de la consulta.

Descargar PDF con la explicación
SELECT DISTINCT O1.Or1
 ,O2.Or2
FROM (
 SELECT OD1.OrderID Or1
  ,OD2.OrderId Or2
  ,OD1.ProductID
  ,OD2.ProductID P1
 FROM [Order Details] OD1
 INNER JOIN [Order Details] OD2
  ON OD1.ProductID = OD2.ProductID
   AND OD1.OrderID <> OD2.OrderID
 WHERE OD1.OrderID IN (
   SELECT OD.OrderID
   FROM [Order Details] OD
   GROUP BY OD.OrderID
   HAVING COUNT(OD.ProductID) >= 2
   )
  AND OD2.OrderID IN (
   SELECT OD.OrderID
   FROM [Order Details] OD
   GROUP BY OD.OrderID
   HAVING COUNT(OD.ProductID) >= 2
   )
 ) O1
INNER JOIN (
 SELECT OD1.OrderID Or1
  ,OD2.OrderId Or2
  ,OD1.ProductID
  ,OD2.ProductID P2
 FROM [Order Details] OD1
 INNER JOIN [Order Details] OD2
  ON OD1.ProductID = OD2.ProductID
   AND OD1.OrderID <> OD2.OrderID
 WHERE OD1.OrderID IN (
   SELECT OD.OrderID
   FROM [Order Details] OD
   GROUP BY OD.OrderID
   HAVING COUNT(OD.ProductID) >= 2
   )
  AND OD2.OrderID IN (
   SELECT OD.OrderID
   FROM [Order Details] OD
   GROUP BY OD.OrderID
   HAVING COUNT(OD.ProductID) >= 2
   )
 ) O2
 ON O1.Or1 = O2.Or1
  AND O1.Or2 = O2.Or2
  AND O1.P1 <> O2.P2

Si lo mejoran no duden en pasarme su script.


¡Saludos!
@fferegrino :)

Usando OneNote en la escuela

Ahora que he regresado a la escuela he decidido usar OneNote para tomar mis apuntes, he de aprovechar que ahora curso asignaturas que tienen que ver por completo con el desarrollo de sistemas informáticos. Por el momento es un poco extraño oír solo las digitaciones mientras otros rasgan sus hojas con bolígrafos. Ya me acostumbraré.

Tampoco es que sepa aprovechar al 100% la plataforma de OneNote, pero de a poco se aprende (¿¡cómo inserto un dibujo en una hoja?!).

Ah, se me olvidaba, acá el link a los apuntes: Bloc de notas ESCOM_3, desde luego, se actualiza diario... o cada vez que tomo notas ;)

¡Saludos!
@fferegrino :)

Envío de correos "desde la base de datos" con .NET

Seguro hay otras maneras de hacerlo, pero cuando tienes que hacerlo rápido no hay muchas opciones, hablo de enviar correos periódicamente desde datos tomados de la base de datos.

Forma de uso
La solución que aquí propongo es de cierta manera "dinámica", ya que podemos usar este programita para enviar tantos correos como deseemos, lo único que necesitamos hacer es enviarle como parámetro el stored procedure del cual consultará los datos, el procedimiento le deberá devolver estas tres columnas al programa:

  • DESTINATARIOS: Una columna que contiene los correos a los cuales será enviado el mensaje. Los correos deberán ir separados por un ;.
  • ASUNTO: Contiene el asunto con el que será enviado el correo.
  • MENSAJE: El mensaje que contendrá el correo, puede ser HTML (recomiendo sea básico).



Como mencioné al principio de todo: probablemente haya mejores maneras de hacerlo ya que de esta manera dejamos toda la carga a la BD ya que es ella quien tendría que formar el mensaje, el dinamismo del que hablo radica en que nosotros podemos, con la ayuda del stored procedure sacar cualquier información que necesitemos de la base.

La forma de usar el programa es la siguiente:
$ SendMails storedProcedure
La mejor parte es que gracias a las tareas de Windows podemos programar el programa para que se ejecute periódicamente, tantas veces como deseamos y con un procedimiento distinto para enviar correos distintos cada ocasión.

Para configurarlo necesitamos poner nuestra cadena de conexión en el archivo app.config, así como los parámetros para enviar el correo, como el host, usuario, puerto...
<configuration>
  <appSettings>

    <add key="mailHost" value="smtp.gmail.com"/>
    <add key="mailUser" value="ejemplo@gmail.com"/>
    <add key="port" value="587"/>
    <add key="ssl" value="true"/>
    <add key="user" value="ejemplo@gmail.com"/>
    <add key="password" value="random*Pass"/>

  </appSettings>
  <connectionStrings>
    <add name="CON" connectionString="Data Source=localhost\SQL;Initial Catalog=DB;User ID=US;Password=PSWD" 
        providerName="System.Data.SqlClient"/>
  </connectionStrings>
</configuration>

SendMailsApp (Se incluyen las librerías de Microsoft Practices necesarias para que el programa funcione).

¿Tienes alma de desarrollador?

Si necesitas algo más especializado te dejo el código la solución del programa hecho en C# y con Visual Studio  para que lo modifiques a tu gusto.

Cualquier duda o comentario siempre es bienvenido :)

SendMailsSource (Se necesitan algunas librerías de Microsoft Practices incluídas en el enlace de arriba).

¡Saludos!
@fferegrino :)