Programacion, desarrollo y mas...

Problemas de seguridad en Servientrega

2015-01-08T14:20:00.004-05:00

Todos realizamos envíos por empresas de encomiendas y envíos, nos interesa que lleguen los paquetes rápido, a tiempo, ¿Pero con el delivery termina todo? ¿Qué pasa después de que firmamos el recibido? Bueno, al parecer las empresas se destacan también por su falta de seguridad en documentos. Más abajo se muestran las guías en PDF de personas al azar.

ALTERNATIVA PARA DESARROLLO EN OPENGL (GLUT) EN WINDOWS 8 O SISTEMAS DE 64 BITS

2013-09-29T11:39:00.001-05:00

No sé si solo me ha ocurrido a mí, o si esta es la mejor solución para los problemas que se presentan el desarrollo sobre la API de OPENGL en sistemas con Windows de 64 bits.

Por lo general utilizo Visual Studio 2012 para mis proyectos en C++, pero este compilador es muy restrictivo en cuanto el manejo de matrices sin longitudes constantes, lo cual puede convertirse en un problema. Otra opción es Dev C++ 4.9.9.2 que funciona bien en sistemas de 32 bits, pero no tiene soporte para x64 o Windows 8. Están también las versiones Bloodshed Dev C++ en las cuales son un lio colocar las librerías para que al final compile pero no se ejecute el programa.

Así que después de encontrarme con estos inconvenientes y sin querer cambiar de SO encontré a Code::Blocks es un entorno de desarrollo integrado libre y multiplataforma para el desarrollo de programas en lenguaje C y C++.

Instalación Code::Blocks:

Se descarga de la página http://www.codeblocks.org/downloads/26#windows o en http://sourceforge.net/projects/codeblocks/files/Binaries/12.11/Windows/codeblocks-12.11mingw-setup.exe/download debe ser la versión MinGW que trae el compilador GNU GCC Compiler.
Seguir los pasos de instalación.

Librerías OPENGL (GLUT)

Se descargan de la página http://user.xmission.com/~nate/glut/glut-3.7.6-bin.zip
Luego de descomprimirlas se colocan en las siguientes rutas:

Glut.h en C:\Program Files (x86)\CodeBlocks\MinGW\include\GL
Glut32.lib en C:\Program Files (x86)\CodeBlocks\MinGW\lib
Glut32.dll en C:\Program Files (x86)\CodeBlocks\MinGW\bin

Creación del Proyecto de OPENGL

Abrir Code::Blocks
Entrar a la opción de menú File->New->Project, en la ventana se selecciona GLUT Project.
Se siguen los pasos hasta llegar al que pide la ruta de las librerías de GLUT, se coloca la ruta C:\Program Files (x86)\CodeBlocks\MinGW.
No olvidar siempre seleccionar el compilador GNU GCC Compiler e incluir la librería #include en el código.
Si por algún motivo aparece el error: El programa no puede iniciarse porque falta glut32.dll

Solo hay que agregar Glut32.dll en la ruta el proyecto [Proyecto]/bin/[Debug y/o Release]/ y listo, ya se pueden romper la cabeza con OPENGL.

Algoritmos Genéticos (# Reinas)

2013-05-19T22:15:00.002-05:00

Presentado a:

Julio Cesar Sierra

Por:

Maria Jose Velandia
Jorge Barrera

Archivos:

Se recomienda instalar la ultima versión del jre7 http://www.java.com/es/download/

Runnable Jar

ALGORTIRMOS GENETICOS

Los Algoritmos Genéticos (AG's) son métodos adaptativos que pueden usarse para resolver problemas de búsqueda y optimización. Están basados en el proceso genético de los organismos vivos. A lo largo de las generaciones, las poblaciones evolucionan en la naturaleza de acorde con los principios de la selección natural y la supervivencia de los más fuertes, postulados por Darwin (1859). Por imitación de este proceso, los Algoritmos Genéticos son capaces de ir creando soluciones para problemas del mundo real. La evolución de dichas soluciones hacia valores óptimos del problema depende en buena medida de una adecuada codificación de las mismas.

LAS 8 REINAS

El problema de las ocho reinas es un pasatiempo en el que se colocan ocho reinas sin que se amenacen. Fue propuesto por el ajedrecista alemán Max Bezzel en 1848. En el juego del ajedrez la reina amenaza a aquellas piezas que se encuentren en su misma fila, columna o diagonal. El juego de las 8 reinas consiste en colocar sobre un tablero de ajedrez ocho reinas sin que estas se amenacen entre ellas.

import java.util.*;
import javax.swing.*;

public class Reinas {

    private static int poblacionIni = 75;           // TamaÃ±o de la poblacion 
    private static double probApareamiento = 0.7;   // Probabilidad de reproduccion entre dos cromosomas. rango: 0.0 < probMutacion < 1.0
    private static double tasaMutacion = 0.001;     // Tasa de mutacion. rango: 0.0 < tasaMutacion < 1.0
    private static int minSeleccion = 10;           // Minimo de padres para la seleccion.
    private static int maxSeleccion = 50;           // Maximo de padres para la seleccion. rango: minSeleccion < maxSeleccion < poblacionIni
    private static int numDesendencia = 20;         // Cantidad desendencia por generacion. rango: 0 < numDesendencia < maxSeleccion.
    private static int minBaraja = 8;               // Rango para generar aleatorios
    private static int maxBaraja = 20;
    private static int ptsCruce = 4;                // Maximo de puntos de cruce. rango: 0 < ptsCruce < 8 (> 8 isn't good).
    private static int anchoTablero = 8;            // Ancho del tablero.
    private static int generacion = 0;
    private static int numHijos = 0;
    private static int sigMutacion = 0;             // Programa las mutaciones.
    private static int numMutaciones = 0;
    private static List<Cromosoma> poblacion  = new ArrayList<Cromosoma>();

    /**
     * Metodo que emula un algortimo genetico Simple
     */
    public static void AlgoritmoGenetico(JTextArea tablero, JTextArea generaciones) {

        int tamanioPoblacion = 0;
        Cromosoma cromosoma = null;
        boolean terminado = false;
        GenerarPoblacionInicial();                          //Genera población inicial

        numMutaciones = 0;
        sigMutacion = NumeroAleatorio(0, (int) Math.round(1.0 / tasaMutacion));

        while (!terminado) {                                //Mientras no terminada la búsqueda
            tamanioPoblacion = poblacion.size();            //Tamaño de población
            for (int i = 0; i < tamanioPoblacion; i++) {
                cromosoma = poblacion.get(i);
                if ((cromosoma.getConflictos() == 0)) {
                    terminado = true;
                }
            }

            Fitness();                                      //Calcula el fitness dependiendo la cantidad de conflictos

            Seleccion();                                    //Selecciona los padres de la siguiente generación

            Reproduccion();                                 //Realiza el cruce parcial de los padres

            PrepararSiguienteGeneracion();                  //Selecciona los hijos de la siguiente generación

            generacion++;
        }

        tamanioPoblacion = poblacion.size();
        for (int i = 0; i < tamanioPoblacion; i++) {
            cromosoma = poblacion.get(i);
            if (cromosoma.getConflictos() == 0) {
                ImprimirSolucion(cromosoma, tablero);
            }
        }

        generaciones.setText(generaciones.getText() + "Resuelto en " + generacion + " generaciones \nencontrado con " + numMutaciones + " mutaciones \nen el " + numHijos + " cromosoma.");
    }

    /**
     * Busca la mejor actitud
     */
    private static void Fitness() {
        // Menor error = 100%, Mayor Error = 0%
        int tamanioPoblacion = poblacion.size();
        Cromosoma cromosoma = null;
        double mejor = 0;
        double peor = 0;

        // La peor puntuaciÃ³n serÃa el que tiene la mayor energÃa, mejor mÃ¡s bajo.
        peor = poblacion.get(Maximo()).getConflictos();

        // Convertir a un porcentaje ponderado.
        mejor = peor - poblacion.get(Minimo()).getConflictos();

        for (int i = 0; i < tamanioPoblacion; i++) {
            cromosoma = poblacion.get(i);
            cromosoma.SetFitness((peor - cromosoma.getConflictos()) * 100.0 / mejor);
        }
    }

    /**
     * Seleccion de cromosomas de la generacion
     */
    private static void Seleccion() {

        int j = 0;
        int tamanioPoblacion = poblacion.size();
        double genTotal = 0.0;
        double selTotal = 0.0;
        int maximoSeleccionar = NumeroAleatorio(minSeleccion, maxSeleccion);
        double seleccionar = 0.0;
        Cromosoma cromosoma = null;
        Cromosoma comosomaAux = null;
        boolean terminado = false;

        for (int i = 0; i < tamanioPoblacion; i++) {
            cromosoma = poblacion.get(i);
            genTotal += cromosoma.getFitness();
        }

        genTotal *= 0.01;

        for (int i = 0; i < tamanioPoblacion; i++) {
            cromosoma = poblacion.get(i);
            cromosoma.setProbSeleccion(cromosoma.getFitness() / genTotal);
        }

        for (int i = 0; i < maximoSeleccionar; i++) {
            seleccionar = NumeroAleatorio(0, 99);
            j = 0;
            selTotal = 0;
            terminado = false;
            while (!terminado) {
                cromosoma = poblacion.get(j);
                selTotal += cromosoma.getProbSeleccion();
                if (selTotal >= seleccionar) {
                    if (j == 0) {
                        comosomaAux = poblacion.get(j);
                    } else if (j >= tamanioPoblacion - 1) {
                        comosomaAux = poblacion.get(tamanioPoblacion - 1);
                    } else {
                        comosomaAux = poblacion.get(j - 1);
                    }
                    comosomaAux.setSeleccionado(true);
                    terminado = true;
                } else {
                    j++;
                }
            }
        }
    }

    /**
     * Produce una nueva generacion
     */
    private static void Reproduccion() {
        int getRand = 0;
        int padreA = 0;
        int padreB = 0;
        int newIndex1 = 0;
        int newIndex2 = 0;
        Cromosoma newChromo1 = null;
        Cromosoma newChromo2 = null;

        for (int i = 0; i < numDesendencia; i++) {
            padreA = SeleccionarPadre();
            // Probabilidad de prueba de reproduccion.
            getRand = NumeroAleatorio(0, 100);
            if (getRand <= probApareamiento * 100) {
                padreB = SeleccionarPadre(padreA);
                newChromo1 = new Cromosoma(anchoTablero);
                newChromo2 = new Cromosoma(anchoTablero);
                poblacion.add(newChromo1);
                newIndex1 = poblacion.indexOf(newChromo1);
                poblacion.add(newChromo2);
                newIndex2 = poblacion.indexOf(newChromo2);

                // Elige uno o ambos de los siguientes:
                CruceParcial(padreA, padreB, newIndex1, newIndex2);

                if (numHijos - 1 == sigMutacion) {
                    IntercambiarMutacion(newIndex1, 1);
                } else if (numHijos == sigMutacion) {
                    IntercambiarMutacion(newIndex2, 1);
                }

                poblacion.get(newIndex1).CalcularConflictos();
                poblacion.get(newIndex2).CalcularConflictos();

                numHijos += 2;

                // Programa la siguiente mutacion.
                if (numHijos % (int) Math.round(1.0 / tasaMutacion) == 0) {
                    sigMutacion = numHijos + NumeroAleatorio(0, (int) Math.round(1.0 / tasaMutacion));
                }
            }
        } // i
    }

    /**
     * Cruza con probabilidad dos individuos obteniendo dos decendientes
     *
     * @param chromA
     * @param chromB
     * @param hijo1
     * @param hijo2
     */
    private static void CruceParcial(int chromA, int chromB, int hijo1, int hijo2) {
        int j = 0;
        int item1 = 0;
        int item2 = 0;
        int pos1 = 0;
        int pos2 = 0;
        Cromosoma cromosoma = poblacion.get(chromA);
        Cromosoma comosomaAux = poblacion.get(chromB);
        Cromosoma newChromo1 = poblacion.get(hijo1);
        Cromosoma newChromo2 = poblacion.get(hijo2);
        int crossPoint1 = NumeroAleatorio(0, anchoTablero - 1);
        int crossPoint2 = NumeroAleatorioExclusivo(anchoTablero - 1, crossPoint1);

        if (crossPoint2 < crossPoint1) {
            j = crossPoint1;
            crossPoint1 = crossPoint2;
            crossPoint2 = j;
        }

        // Copia los genes de padres a hijos.
        for (int i = 0; i < anchoTablero; i++) {
            newChromo1.getGenes(i, cromosoma.setGenes(i));
            newChromo2.getGenes(i, comosomaAux.setGenes(i));
        }

        for (int i = crossPoint1; i <= crossPoint2; i++) {
            // Obtener los dos elementos que intercambian.
            item1 = cromosoma.setGenes(i);
            item2 = comosomaAux.setGenes(i);

            // Obtiene los items, posiciones en la descendencia.
            for (j = 0; j < anchoTablero; j++) {
                if (newChromo1.setGenes(j) == item1) {
                    pos1 = j;
                } else if (newChromo1.setGenes(j) == item2) {
                    pos2 = j;
                }
            } // j

            // Intercambiar.
            if (item1 != item2) {
                newChromo1.getGenes(pos1, item2);
                newChromo1.getGenes(pos2, item1);
            }

            // Obtiene los items, posiciones en la descendencia.
            for (j = 0; j < anchoTablero; j++) {
                if (newChromo2.setGenes(j) == item2) {
                    pos1 = j;
                } else if (newChromo2.setGenes(j) == item1) {
                    pos2 = j;
                }
            } // j

            // Intercambiar.
            if (item1 != item2) {
                newChromo2.getGenes(pos1, item1);
                newChromo2.getGenes(pos2, item2);
            }

        } // i
    }

    /**
     * Cruza con probabilidad dos individuos obteniendo dos decendientes
     *
     * @param chromA
     * @param chromB
     * @param hijo1
     * @param hijo2
     */
    private static void CrucePorPosicion(int chromA, int chromB, int hijo1, int hijo2) {
        int k = 0;
        int numPoints = 0;
        int tempArray1[] = new int[anchoTablero];
        int tempArray2[] = new int[anchoTablero];
        boolean matchFound = false;
        Cromosoma cromosoma = poblacion.get(chromA);
        Cromosoma comosomaAux = poblacion.get(chromB);
        Cromosoma newChromo1 = poblacion.get(hijo1);
        Cromosoma newChromo2 = poblacion.get(hijo2);

        // Elegir y ordenar los puntos de cruce.
        numPoints = NumeroAleatorio(0, ptsCruce);
        int crossPoints[] = new int[numPoints];
        for (int i = 0; i < numPoints; i++) {
            crossPoints[i] = NumeroAleatorio(0, anchoTablero - 1, crossPoints);
        } // i

        // Obtenga no elegidos de los padres 2
        k = 0;
        for (int i = 0; i < anchoTablero; i++) {
            matchFound = false;
            for (int j = 0; j < numPoints; j++) {
                if (comosomaAux.setGenes(i) == cromosoma.setGenes(crossPoints[j])) {
                    matchFound = true;
                }
            } // j
            if (matchFound == false) {
                tempArray1[k] = comosomaAux.setGenes(i);
                k++;
            }
        } // i

        // Insertar elegido al hijo 1.
        for (int i = 0; i < numPoints; i++) {
            newChromo1.getGenes(crossPoints[i], cromosoma.setGenes(crossPoints[i]));
        }

        // Rellene no elegidos para hijos 1.
        k = 0;
        for (int i = 0; i < anchoTablero; i++) {
            matchFound = false;
            for (int j = 0; j < numPoints; j++) {
                if (i == crossPoints[j]) {
                    matchFound = true;
                }
            } // j
            if (matchFound == false) {
                newChromo1.getGenes(i, tempArray1[k]);
                k++;
            }
        } // i

        // Obtenga no elegidos de los padres 1
        k = 0;
        for (int i = 0; i < anchoTablero; i++) {
            matchFound = false;
            for (int j = 0; j < numPoints; j++) {
                if (cromosoma.setGenes(i) == comosomaAux.setGenes(crossPoints[j])) {
                    matchFound = true;
                }
            } // j
            if (matchFound == false) {
                tempArray2[k] = cromosoma.setGenes(i);
                k++;
            }
        } // i

        // Inserte elegido en hijos 2.
        for (int i = 0; i < numPoints; i++) {
            newChromo2.getGenes(crossPoints[i], comosomaAux.setGenes(crossPoints[i]));
        }

        // Rellene no elegidos para hijos 2.
        k = 0;
        for (int i = 0; i < anchoTablero; i++) {
            matchFound = false;
            for (int j = 0; j < numPoints; j++) {
                if (i == crossPoints[j]) {
                    matchFound = true;
                }
            } // j
            if (matchFound == false) {
                newChromo2.getGenes(i, tempArray2[k]);
                k++;
            }
        } // i
    }

    /**
     * Intercambia los genes, realiza la mutacion
     *
     * @param indice
     * @param intercambio
     */
    private static void IntercambiarMutacion(int indice, int intercambio) {
        int i = 0;
        int tempData = 0;
        Cromosoma cromosoma = null;
        int gene1 = 0;
        int gene2 = 0;
        boolean terminado = false;

        cromosoma = poblacion.get(indice);

        while (!terminado) {
            gene1 = NumeroAleatorio(0, anchoTablero - 1);
            gene2 = NumeroAleatorioExclusivo(anchoTablero - 1, gene1);

            // Cambia los genes seleccionados.
            tempData = cromosoma.setGenes(gene1);
            cromosoma.getGenes(gene1, cromosoma.setGenes(gene2));
            cromosoma.getGenes(gene2, tempData);

            if (i == intercambio) {
                terminado = true;
            }
            i++;
        }
        numMutaciones++;
    }

    /**
     * Seleccionar los padres para la reproduccion
     *
     * @return
     */
    private static int SeleccionarPadre() {
        // FunciÃ³n sobrecargada, consulta "choosepadre (ByVal Parenta As Integer)".
        int padre = 0;
        Cromosoma cromosoma = null;
        boolean terminado = false;

        while (!terminado) {
            // Elige al azar un padre elegible.
            padre = NumeroAleatorio(0, poblacion.size() - 1);
            cromosoma = poblacion.get(padre);
            if (cromosoma.getSeleccionado() == true) {
                terminado = true;
            }
        }

        return padre;
    }

    /**
     * Seleccionar los padres para la reproduccion, diferente al seleccionado
     *
     * @return int
     */
    private static int SeleccionarPadre(int padreA) {
        // FunciÃ³n sobrecargada, consulta "choosepadre()".
        int padre = 0;
        Cromosoma cromosoma = null;
        boolean terminado = false;

        while (!terminado) {
            // Elige al azar un padre elegible.
            padre = NumeroAleatorio(0, poblacion.size() - 1);
            if (padre != padreA) {
                cromosoma = poblacion.get(padre);
                if (cromosoma.getSeleccionado() == true) {
                    terminado = true;
                }
            }
        }

        return padre;
    }

    /**
     * Prepara la poblacion de la siguiente generacion
     */
    private static void PrepararSiguienteGeneracion() {
        int tamanioPoblacion = 0;
        Cromosoma cromosoma = null;

        // Restaura estado de cromosoma
        tamanioPoblacion = poblacion.size();
        for (int i = 0; i < tamanioPoblacion; i++) {
            cromosoma = poblacion.get(i);
            cromosoma.setSeleccionado(false);
        }
    }

    /**
     * Imprime la mejor solucion
     *
     * @param mejorSolucion
     */
    private static void ImprimirSolucion(Cromosoma mejorSolucion, JTextArea visorTablero) {
        String tablero[][] = new String[anchoTablero][anchoTablero];

        // Limpia el tablero.
        for (int x = 0; x < anchoTablero; x++) {
            for (int y = 0; y < anchoTablero; y++) {
                tablero[x][y] = "";
            }
        }

        for (int x = 0; x < anchoTablero; x++) {
            tablero[x][mejorSolucion.setGenes(x)] = "Q";
        }

        // Muestra el tablero.
        for (int y = 0; y < anchoTablero; y++) {
            for (int x = 0; x < anchoTablero; x++) {
                if (tablero[x][y] == "Q") {
                 visorTablero.setText(visorTablero.getText() + "X ");
                } else {
                 visorTablero.setText(visorTablero.getText() + "O ");
                }
            }
            visorTablero.setText(visorTablero.getText() + "\n");
        }
    }

    /**
     * Obtiene un numero aleatorio en el rango
     *
     * @param low
     * @param high
     * @return
     */
    private static int NumeroAleatorio(int low, int high) {
        return (int) Math.round((high - low) * new Random().nextDouble() + low);
    }

    /**
     *
     * @param high
     * @param except
     * @return
     */
    private static int NumeroAleatorioExclusivo(int high, int except) {
        boolean terminado = false;
        int getRand = 0;

        while (!terminado) {
            getRand = new Random().nextInt(high);
            if (getRand != except) {
                terminado = true;
            }
        }

        return getRand;
    }

    /**
     * Obtener numero aleatorio fuera del rango
     *
     * @param low
     * @param high
     * @param except
     * @return
     */
    private static int NumeroAleatorio(int low, int high, int[] except) {
        boolean terminado = false;
        int getRand = 0;

        if (high != low) {
            while (!terminado) {
                terminado = true;
                getRand = (int) Math.round((high - low) * new Random().nextDouble() + low);
                for (int i = 0; i < except.length; i++) //UBound(except)
                {
                    if (getRand == except[i]) {
                        terminado = false;
                    }
                } // i
            }
            return getRand;
        } else {
            return high; // or low (it doesn't matter).
        }
    }

    /**
     * Obtiene el minimo cromosoma
     *
     * @return int
     */
    private static int Minimo() {
        // Devuelve un Ãndice de matriz.
        int tamanioPoblacion = 0;
        Cromosoma cromosoma = null;
        Cromosoma comosomaAux = null;
        int winner = 0;
        boolean foundNewWinner = false;
        boolean terminado = false;

        while (!terminado) {
            foundNewWinner = false;
            tamanioPoblacion = poblacion.size();
            for (int i = 0; i < tamanioPoblacion; i++) {
                if (i != winner) {             // Avoid self-comparison.
                    cromosoma = poblacion.get(i);
                    comosomaAux = poblacion.get(winner);
                    if (cromosoma.getConflictos() < comosomaAux.getConflictos()) {
                        winner = i;
                        foundNewWinner = true;
                    }
                }
            }
            if (foundNewWinner == false) {
                terminado = true;
            }
        }
        return winner;
    }

    /**
     * Obtiene el maximo cromosoma
     *
     * @return
     */
    private static int Maximo() {
        // Devuelve un Ãndice de matriz.
        int tamanioPoblacion = 0;
        Cromosoma cromosoma = null;
        Cromosoma comosomaAux = null;
        int winner = 0;
        boolean foundNewWinner = false;
        boolean terminado = false;

        while (!terminado) {
            foundNewWinner = false;
            tamanioPoblacion = poblacion.size();
            for (int i = 0; i < tamanioPoblacion; i++) {
                if (i != winner) {             // Avoid self-comparison.
                    cromosoma = poblacion.get(i);
                    comosomaAux = poblacion.get(winner);
                    if (cromosoma.getConflictos() > comosomaAux.getConflictos()) {
                        winner = i;
                        foundNewWinner = true;
                    }
                }
            }
            if (foundNewWinner == false) {
                terminado = true;
            }
        }
        return winner;
    }

    /**
     * Generar poblacion inicial
     */
    private static void GenerarPoblacionInicial() {
        int shuffles = 0;
        Cromosoma newChromo = null;
        int chromoIndex = 0;

        for (int i = 0; i < poblacionIni; i++) {
            newChromo = new Cromosoma(anchoTablero);
            poblacion.add(newChromo);
            chromoIndex = poblacion.indexOf(newChromo);

            // Escoja al azar el nÃºmero de baraja realizar.
            shuffles = NumeroAleatorio(minBaraja, maxBaraja);

            IntercambiarMutacion(chromoIndex, shuffles);

            poblacion.get(chromoIndex).CalcularConflictos();

        }
        return;
    }
}

public class Cromosoma {

    private int anchoTablero = 0;
    private int genes[];
    private double fitness = 0.0;
    private boolean seleccionado = false;
    private double probSeleccion = 0.0;
    private int conflictos = 0;

    /**
     * Constructor del la clase
     */
    public Cromosoma(int longitud) {

        this.anchoTablero = longitud;
        genes = new int[longitud];

        for (int i = 0; i < longitud; i++) {
            this.genes[i] = i;
        }
    }

    /**
     * Calcula los conflictos de movimiento entre las reinas
     */
    public void CalcularConflictos() {
        int x = 0;
        int y = 0;
        int auxx = 0;
        int auxy = 0;
        String tablero[][] = new String[anchoTablero][anchoTablero];
        int numConflictos = 0;
        int dx[] = new int[]{-1, 1, -1, 1};
        int dy[] = new int[]{-1, 1, 1, -1};
        boolean terminado = false;

        // Limpia el tablero.
        for (int i = 0; i < anchoTablero; i++) {
            for (int j = 0; j < anchoTablero; j++) {
                tablero[i][j] = "";
            }
        }

        for (int i = 0; i < anchoTablero; i++) {
            tablero[i][this.genes[i]] = "Q";
        }

        // Recorrer cada una de las Reinas y calcular el número de conflictos.
        for (int i = 0; i < anchoTablero; i++) {
            x = i;
            y = this.genes[i];

            // Evaluar diagonales.
            for (int j = 0; j <= 3; j++) {
                auxx = x;
                auxy = y;
                terminado = false;
                while (!terminado) {
                    auxx += dx[j];
                    auxy += dy[j];
                    if ((auxx < 0 || auxx >= anchoTablero) || (auxy < 0 || auxy >= anchoTablero)) {
                        terminado = true;
                    } else {
                        if (tablero[auxx][auxy].compareToIgnoreCase("Q") == 0) {
                            numConflictos++;
                        }
                    }
                }
            }
        }

        this.conflictos = numConflictos;
    }

    /**
     * Coloca conflicto
     *
     * @param value
     */
    public void setConflictos(int value) {
        this.conflictos = value;
    }

    /**
     * Obtiene conflicto
     *
     * @return int
     */
    public int getConflictos() {
        return this.conflictos;
    }

    /**
     * Obtiene la probabilidad de seleccion
     *
     * @return double
     */
    public double getProbSeleccion() {
        return probSeleccion;
    }

    /**
     * Coloca la probabilidad de seleccion
     *
     * @param SelProb
     */
    public void setProbSeleccion(double SelProb) {
        probSeleccion = SelProb;
    }

    /**
     * Obtiene si esta seleccionado
     *
     * @return boolean
     */
    public boolean getSeleccionado() {
        return seleccionado;
    }

    /**
     * Selecciona el cromosoma
     *
     * @param sValue
     */
    public void setSeleccionado(boolean sValue) {
        seleccionado = sValue;
    }

    /**
     * Obtiene el grado de optitud del cromosoma
     *
     * @return double
     */
    public double getFitness() {
        return fitness;
    }

    /**
     * Coloca el grado de aptitud del cromosoma
     *
     * @param score
     */
    public void SetFitness(double score) {
        fitness = score;
    }

    /**
     * Coloca los genes al cromosoma
     *
     * @param index
     * @return int
     */
    public int setGenes(int index) {
        return genes[index];
    }

    /**
     * Obtiene los genes del cromosoma
     *
     * @param index
     * @param value
     */
    public void getGenes(int index, int value) {
        genes[index] = value;
    }
}

Analizador Sintáctico

2013-04-16T23:03:00.002-05:00

Presentado a:

Julio Cesar Sierra

Por:

Steven Rodriguez
Andres Vega
Jorge Barrera

Archivos:

Se recomienda instalar la ultima versión del jre7 http://www.java.com/es/download/

Runnable Jar
Ejemplo de entrada c / q - p * r

Un analizador sintáctico es una de las partes de un compilador que transforma su entrada en un árbol de derivación. El análisis sintáctico convierte el texto de entrada en otras estructuras (comúnmente árboles), que son más útiles para el posterior análisis y capturan la jerarquía implícita de la entrada

Implementación del Triqui con Algoritmo de Mini Max

2013-04-14T17:21:00.001-05:00

Presentado a Julio Cesar Sierra

Por:

- María José Velandia: 52960713
- Jorge Barrera: 1018413066

Universidad Central 2013

Runnable Jar

Se colocan secciones de código críticas donde se muestra el funcionamiento del algoritmo de MiniMax.

 /* Metodo recursivo, que genera los nodos con los movimientos. */
 public void movComputadora(NodoG raiz) {

  /* Numero de movimientos disponibles y sus indices en el tablero. */
  int movimientos = movDisponibles(raiz.tablero);
  int indices[] = posVacias(raiz.tablero);
  int Max, Min;

  /* Inicializamos el nodo. */
  raiz.nodos = new NodoG[movimientos];

  /* Verificamos si hay un ganador. */
  int ganador = terminado(raiz.tablero);
  if (ganador == 1) {
   ganador = -1;
  } else if (ganador == 2) {
   ganador = 1;
  }

  if (ganador != 0 || movimientos == 0) {
   raiz.ganador = ganador;
  } else {

   /* Creamos los datos de cada hijo. */
   for (int i = 0; i < movimientos; i++) {

    /* Inicializamos los nodos hijos del arbol. */
    raiz.nodos[i] = new NodoG();

    /* Les pasamos su tablero. */
    for (int j = 0; j < 9; j++) {
     raiz.nodos[i].tablero[j] = raiz.tablero[j];
    }

    /* Creamos los diferentes movimientos posibles. */
    if (raiz.miTurno) {
     raiz.nodos[i].tablero[indices[i]] = 1;
    } else {
     raiz.nodos[i].tablero[indices[i]] = 2;
    }

    /* Cambiamos el turno de los hijos */
    raiz.nodos[i].miTurno = !raiz.miTurno;

    /* Guardamos el indice de su movimiento. */
    raiz.nodos[i].indice = indices[i];

    movComputadora(raiz.nodos[i]);

   }

   /* Minimax */
   if (!raiz.miTurno) {
    raiz.ganador = Max(raiz);
   } else {
    raiz.ganador = Min(raiz);
   }
  }
 }

Análisis sintáctico predictivo no recursivo

2013-03-30T16:41:00.002-05:00

Presentado a:

Julio Cesar Sierra

Por:

Steven Rodriguez
Andres Vega
Jorge Barrera

Archivos:

Implementación Algoritmo 4.3 Análisis sintáctico predictivo no recursivo (pag. 192, Aho)

 Vector buffer;
 int i = 1;
 String ae = "", X, a;

 Stack<String> pila = new Stack<String>();
 pila.push("$");
 pila.push("E");

 buffer = acciones.LlenarVector();
 ae = buffer.get(0).toString();

 while (pila.lastElement().toString() != ae) {
  X = pila.lastElement();
  a = ae;
  if (X.equals("$") || acciones.Validar(X) > 0) {
   if (X.equals(a)) {
    pila.remove(pila.lastElement());
    ae = buffer.get(i).toString();
    i++;
   } else {
    throw new Exception("Se encontro un error sintactico");
   }
  } else {
   if (acciones.Existe("M[" + X + "," + a + "]")) {
    pila.remove(pila.lastElement());
    acciones.MeterEnPila(pila, X, a);
    acciones.EmitirProduccion(X, a);
   } else {
    throw new Exception("Se encontro un error sintactico");
   }
  }
 }

Analizador Lexico

2013-02-27T15:27:00.002-05:00

Presentado a Julio Cesar Sierra

Por:

- Steven Rodriguez
- Andres Vega
- Jorge Barrera

Universidad Central 2013

Runnable Jar

Para probar, descargar los siguientes archivos en

c:\compiladores

COMPILADORES

Un compilador es un programa informático que traduce un programa escrito en un lenguaje de programación a otro lenguaje de programación, generando un programa equivalente que la máquina será capaz de interpretar.

ANALIZADOR LEXICO

Un analizador léxico o analizador lexicográfico (en inglés scanner) es la primera fase de un compilador consistente en un programa que recibe como entrada el código fuente de otro programa (secuencia de caracteres) y produce una salida compuesta de tokens (componentes léxicos) o símbolos. Estos tokens sirven para una posterior etapa del proceso de traducción, siendo la entrada para el analizador sintáctico (en inglés parser).

Búsquedas en Amplitud y Profundidad

2013-02-16T12:53:00.002-05:00

Presentado a Julio Cesar Sierra

Por:

- Lorena Ramirez cod: 1010179099
- Carlos Caicedo: 1015412218
- Jorge Barrera: 1018413066

Universidad Central 2013

Runnable Jar

BÚSQUEDA PROFUNDIDAD

Una Búsqueda en profundidad (en inglés DFS o Depth First Search) es un algoritmo que permite recorrer todos los nodos de un grafo o árbol (teoría de grafos) de manera ordenada, pero no uniforme. Su funcionamiento consiste en ir expandiendo todos y cada uno de los nodos que va localizando, de forma recurrente, en un camino concreto. Cuando ya no quedan más nodos que visitar en dicho camino, regresa (Backtracking), de modo que repite el mismo proceso con cada uno de los hermanos del nodo ya procesado.

    @Override
    public boolean Buscar() {

        NodoArbol nodo = new NodoArbol(' ');
        abierto.add(inicial);                                           //1.    Poner nodo inicial en una lista llamada ABIERTO

        while (!abierto.isEmpty() && nodo.getElemento() != caracter) {  //2.    Mientras ABIERTO tenga elementos y no se se haya llegado al estado meta

            nodo = abierto.remove(0);                                   //2.1   Quitar el primer elemento de ABIERTO

            if (!cerrado.contains(nodo)) {                              //2.2   Si el nodo no se encuentra en CERRADO

                ruta = ruta + " -> " + nodo.getElemento();
                cerrado.add(nodo);                                      //2.2.1 Ponerlo en una lista llamado CERRADO

                NodoArbol n = nodo;                                     //2.2.2 Llamar a este nodo N

                if (n.getHijos().size() > 0) {                          //2.2.4 Si hay sucesores y no son el estado meta

                    abierto.addAll(abierto.size(), n.getHijos());       //2.2.3 Expander el nodo n obteniendo todos sus sucesores                  
                    //      Almacenarlos al final de la lista ABIERTO
                }                                                       //2.2.5 Fin del condicional 2.2.4

            }                                                           //2.3   Fin del condicional 2.2

        }                                                               //3.    Fin del mientras

        return true;                                                    //4.    Si alguno de los sucesores es el estado meta, entonces el algoritmo concluye con EXITO; de otra forma con FRACASO
    }

BÚSQUEDA EN ANCHURA

Búsqueda en anchura (en inglés BFS - Breadth First Search) es un algoritmo para recorrer o buscar elementos en un grafo (usado frecuentemente sobre árboles). Intuitivamente, se comienza en la raíz (eligiendo algún nodo como elemento raíz en el caso de un grafo) y se exploran todos los vecinos de este nodo. A continuación para cada uno de los vecinos se exploran sus respectivos vecinos adyacentes, y así hasta que se recorra todo el árbol.

    @Override
    public boolean Buscar() {

        NodoArbol nodo = new NodoArbol(' ');
        abierto.add(inicial);                                           //1.    Poner nodo inicial en una lista llamada ABIERTO

        while (!abierto.isEmpty() && nodo.getElemento() != caracter) {  //2.    Mientras ABIERTO tenga elementos y no se se haya llegado al estado meta

            nodo = abierto.remove(0);                                   //2.1   Quitar el primer elemento de ABIERTO

            if (!cerrado.contains(nodo)) {                              //2.2   Si el nodo no se encuentra en CERRADO

                ruta = ruta + " -> " + nodo.getElemento();
                cerrado.add(nodo);                                      //2.2.1 Ponerlo en una lista llamado CERRADO

                NodoArbol n = nodo;                                     //2.2.2 Llamar a este nodo N

                if (n.getHijos().size() > 0) {                          //2.2.4 Si hay sucesores y no son el estado meta

                    abierto.addAll(0, n.getHijos());                    //2.2.3 Expander el nodo n obteniendo todos sus sucesores                  
                    //      Almacenarlos al inicio de la lista ABIERTO
                }                                                       //2.2.5 Fin del condicional 2.2.4

            }                                                           //2.3   Fin del condicional 2.2

        }                                                               //3.    Fin del mientras

        return true;                                                    //4.    Si alguno de los sucesores es el estado meta, entonces el algoritmo concluye con EXITO; de otra forma con FRACASO
    }

Por que somos pobres los Colombianos?

2011-11-30T16:38:00.000-05:00

Este es un video que deberíamos ver y entender los colombianos a ver si salimos de esta pobreza, o mejor dicho, pobreza de mentalidad, se los recomiendo.

Molestando Con SMS Gratis

2011-08-10T20:44:00.000-05:00

Bueno esta es una aplicacioncilla que utiliza recursos mal administrados para el uso estrictamente inoficioso, jejeje, espero que puedan molestar a otros enviando mensajes de texto gratis, hay persona que al parecer no les cuesta nada un SMS, así que esta es nuestra oportunidad de llenar los buzones enviando mensajes GRATISSSSSSS de texto.
Puede que no sea el texto que esperamos, pero servirá por lo menos para llenar los buzones, ahora sí, a enviar mensajes GRATISSSS.

Desafortunadamente o afortunadamente solo esta habilitado para Colombia.

Molestando Gratis

Html5 demos y ejemplos

2011-02-10T10:37:00.002-05:00

Bueno ahora con el mayor soporte de html 5 en los diferentes exploradores web podemos ir pensando como utilizar su potencial en nuestros proyectos en la web, aca les dejo algunas paginas para consultar, suerte

http://html5demos.com/

HTML Parser en Java

2010-09-10T19:51:00.007-05:00

Bueno ahora traigo un problema y una solución. Los pongo en contexto, hace un tiempo necesitaba analizar el HTML de una pagina web desde un web service dejemos hasta hay después les hablo de mi odisea jboss web service eclipse, jejjeje, como hacerlo?, como analizar el HTML de una pagina web, bueno al parecer cuando escucho analizar texto se me ocurren muchas cosas pero cual de estas ¨cosas¨ es la mas eficiente?.

La primera posible solución fue analizar el HTML como una cadena de texto y extraer las etiquetas y atributos que necesitaba mediante un algoritmo de búsqueda bruta de pronto con alguna heurística, pero de todas formas no me pareció debía encontrar otra forma para no manejar funciones de cadena.

Sin salir de la idea de analizar la cadena HTML pensé luego, por que no utilizar regular expressions (regex).?, puede servir es mas este es un ejemplo que utilice http://www.javamex.com/tutorials/regular_expressions/example_scraping_html.shtml

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.URL;

import javax.swing.text.MutableAttributeSet;
import javax.swing.text.html.HTML;
import javax.swing.text.html.HTMLEditorKit;

public class MainClass {
private static void parse(URL url, String encoding) throws IOException {
ParserGetter kit = new ParserGetter();
HTMLEditorKit.Parser parser = kit.getParser();
InputStream in = url.openStream();
InputStreamReader r = new InputStreamReader(in, encoding);
HTMLEditorKit.ParserCallback callback = new Outliner(new OutputStreamWriter(System.out));
parser.parse(r, callback, true);
}

public static void main(String[] args) throws Exception {

ParserGetter kit = new ParserGetter();
HTMLEditorKit.Parser parser = kit.getParser();

String encoding = "ISO-8859-1";
URL url = new URL("http://www.java2s.com");
InputStream in = url.openStream();
InputStreamReader r = new InputStreamReader(in, encoding);
// parse once just to detect the encoding
HTMLEditorKit.ParserCallback doNothing = new HTMLEditorKit.ParserCallback();
parser.parse(r, doNothing, false);

parse(url, encoding);
}

}

class Outliner extends HTMLEditorKit.ParserCallback {

private Writer out;

private int level = 0;

private boolean inHeader = false;

private static String lineSeparator = System.getProperty("line.separator", "\r\n");

public Outliner(Writer out) {
this.out = out;
}

public void handleStartTag(HTML.Tag tag, MutableAttributeSet attributes, int position) {

int newLevel = 0;
if (tag == HTML.Tag.H1)
newLevel = 1;
else if (tag == HTML.Tag.H2)
newLevel = 2;
else if (tag == HTML.Tag.H3)
newLevel = 3;
else if (tag == HTML.Tag.H4)
newLevel = 4;
else if (tag == HTML.Tag.H5)
newLevel = 5;
else if (tag == HTML.Tag.H6)
newLevel = 6;
else
return;

this.inHeader = true;
try {
if (newLevel > this.level) {
for (int i = 0; i < newLevel - this.level; i++) {
out.write("

");
}
} else if (newLevel < this.level) {
for (int i = 0; i < this.level - newLevel; i++) {
out.write(lineSeparator + "

" + lineSeparator);
}
out.write(lineSeparator + "

");
} else {
out.write(lineSeparator + "

");
}
this.level = newLevel;
out.flush();
} catch (IOException ex) {
System.err.println(ex);
}

}

public void handleEndTag(HTML.Tag tag, int position) {

if (tag == HTML.Tag.H1 || tag == HTML.Tag.H2 || tag == HTML.Tag.H3 || tag == HTML.Tag.H4
|| tag == HTML.Tag.H5 || tag == HTML.Tag.H6) {
inHeader = false;
}

// work around bug in the parser that fails to call flush
if (tag == HTML.Tag.HTML)
this.flush();

}

public void handleText(char[] text, int position) {

if (inHeader) {
try {
out.write(text);
out.flush();
} catch (IOException ex) {
System.err.println(ex);
}
}

}

public void flush() {
try {
while (this.level-- > 0) {
out.write(lineSeparator + "");
}
out.flush();
} catch (IOException e) {
System.err.println(e);
}
}

private static void parse(URL url, String encoding) throws IOException {
ParserGetter kit = new ParserGetter();
HTMLEditorKit.Parser parser = kit.getParser();
InputStream in = url.openStream();
InputStreamReader r = new InputStreamReader(in, encoding);
HTMLEditorKit.ParserCallback callback = new Outliner(new OutputStreamWriter(System.out));
parser.parse(r, callback, true);
}

}

class ParserGetter extends HTMLEditorKit {
public HTMLEditorKit.Parser getParser() {
return super.getParser();
}
}

Instalación Visual Studio 2005 y SQL Server 2005 Express en Windows 7

2010-07-14T12:02:00.002-05:00

Ya tuve una mala experiencia con esta instalación ahora comparto como hacerla de forma adecuada siguiendo los siguientes pasos ten en cuenta que debes iniciar los msi y exe con privilegios de administrador es decir clic derecho->compatibilidad…. Esto porque se van a hacer modificaciones al sistema y w7 tiene mucho cuidado con esto

- Como primer paso realiza todas las actualizaciones que tengas pendientes en tu PC Windows Panel de control\Sistema y seguridad\Windows Update

- Se realiza la Instalación clásica de Visual Studio 2005 Standard, Professional y Team Editions en mi caso Professional Edition, al terminar el Visual Studio 2005 y SQL Server 2005 Express te mostrara mensajes de que por favor instale las respectivas actualizaciones y SP. Al final te dirá algo que para mí es curioso y muestra la preocupación de Microsoft y es que se recomienda encarecidamente la instalación de SP1.

- Descargamos e ejecutamos el Service Pack 1 para Microsoft® Visual Studio® 2005 Standard, Professional y Team Editions
(http://www.microsoft.com/downloads/details.aspx?FamilyID=bb4a75ab-e2d4-4c96-b39d-37baf6b5b1dc&DisplayLang=es)

- Luego la correspondiente a Windows Vista y 7Actualización de Visual Studio 2005 Service Pack 1 para Windows Vista y 7 (http://www.microsoft.com/downloads/details.aspx?FamilyID=90e2942d-3ad1-4873-a2ee-4acc0aace5b6&displaylang=es)

El que más se demora es el primer SP

- Ahora el Service Pack 3 de Microsoft SQL Server 2005 Express Edition(http://www.microsoft.com/downloads/details.aspx?displaylang=es&FamilyID=3181842a-4090-4431-acdd-9a1c832e65a6)

Aunque parece algo complejo es sencillo solo se deben seguir las indicaciones no te puedes perder

- Por último instalamos la consola de Administración Microsoft SQL Server Management Studio Express
(http://www.microsoft.com/downloads/details.aspx?displaylang=es&FamilyID=c243a5ae-4bd1-4e3d-94b8-5a0f62bf7796)
Si te sale el error 29506 es por que debes ejecutar el SQLServer2005_SSMSEE.exe con permisos de administrador para esto debes ejecutar el cmd como administrador y desde aquí ir a donde se encuentra el SQLServer2005_SSMSEE

Y listo esto es todo ahora ya puedes empezar a hacer lo que más te gusta :)

Herramientas de Google Code

2010-07-05T08:49:00.004-05:00

Que es Google? A muchos les he escuchado que es solo un buscador en la web, pero hace unos años se convirtió es mucho más, ya no es solo búsquedas, ahora nos podemos beneficiar nosotros los desarrolladores entre muchas de sus nuevas utilidades me voy a enfocar de Google Code. Google Code es un sitio de Google para desarrolladores interesados en APIs, librerías y servicios open source que facilitan el manejo de:

Anuncios

API de Google AdSense Obtén ingresos para ti y para tus usuarios incluyendo anuncios
en tu sitio web.
Google AnalyticsRealiza un seguimiento del tráfico del sitio y escribe tus propias
aplicaciones cliente que utilizan datos de Google Analytics como feeds del API de
datos de Google.
API del motor de búsqueda personalizado de Google Crea un motor de búsqueda personalizado
para uno o varios sitios web.

AJAX

API AJAX de GoogleCrea sitios web completos y dinámicos solamente con JavaScript
y HTML.
API AJAX de Google para feeds Integra feeds públicos fácilmente con JavaScript.
API de visualización de Google Crea aplicaciones de elaboración de informes y visualizaciones
con acceso a datos estructurados en un formato común.
Google Web Toolkit Crea aplicaciones AJAX en lenguaje Java.

Mapas

API de Google Maps Integra los mapas interactivos de Google en tu sitio web.
API de Google Static Maps Inserta una imagen de Google Maps en tu página web sin
utilizar JavaScript ni ningún sistema de carga de páginas dinámicas.
API de Google Maps para Flash Integra Google Maps en aplicaciones Flash.

Busquedas

API AJAX de Google para búsquedas Incluye un cuadro de búsqueda de Google y los
resultados en tu sitio web.
Sitemaps de Google Permite que Google rastree rápidamente tu sitio web.
API de datos de Herramientas para webmasters de Google (Labs) Visualiza y actualiza
sitemaps e información de sitios web como feeds.
API del motor de búsqueda personalizado de Google Crea un motor de búsqueda personalizado
para uno o varios sitios web.

Aplicaciones sociales

API de gadgets Crea miniaplicaciones que se ejecutan en muchos sitios, incluidos
iGoogle, Google Desktop o cualquier página web.
API de YouTube Integra vídeos de YouTube en tu aplicación o sitio web.

API de datos de Blogger (Labs) Permite ver y actualizar contenido de Blogger a través
de aplicaciones propias.

API de datos de hojas de cálculo de Google Docs (Labs) Permite ver y actualizar
contenido de las hojas de cálculo de Google Docs a través de aplicaciones propias.

estos entre muchas utilidades, los invito a que ingresaen al la pagina web http://code.google.com/intl/es-CO/

jQuery Facilita tu Vida

2010-06-09T23:33:00.006-05:00

Que tal este lema "escribe menos has mas", pues bueno es cierto.

jQuery es una biblioteca de Javascript, que permite simplificar la manera de interactuar con los documentos HTML, manejar eventos, desarrollar animaciones y agregar interacción con la tecnología AJAX a páginas web.

Es software libre y de código abierto, al igual que otras bibliotecas, ofrece una serie de funcionalidades basadas en Javascript que de otra manera requerirían de mucho más código. Es decir, con las funciones propias de esta biblioteca se logran grandes resultados en menos tiempo y espacio.

Además de las ventajas que comente esta es liviana y Cross-browser IE 6.0+, FF 2+, Safari 3.0+, Opera 9.0+, Chrome, es compatible con CSS1-3.

Los invito a entrar a la pagina http://jquery.com/ y conocer mas sobre esta gran herramienta.

W3C Valida tu Web

2010-05-24T16:48:00.005-05:00

Todos tenemos el anhelo de que nuestras aplicaciones web independientemente al lenguaje o tecnologías con las que las implantemos corran bien sobre los distintos web browser que hay en este momento, Pero que pasa? hay etiquetas que no soportan todos los exploradores, o estilos CSS o métodos de Java Script.

Esto sucede porque cada quien hace lo que quiere, las empresas “Microsoft” definen muchos elementos que solo soporta iexplore y no se basa en las reglas ni estándares lo mismo pasa con los demás piensan que son únicos, pero los que realmente sufrimos somos nosotros los soldaos rasos.

¿Y ahora quien podrá ayudarnos? Yo la W3C o bueno La World Wide Web Consortium (W3C), esta una comunidad internacional que desarrolla estándares para garantizar el crecimiento a largo plazo de la Web y nos suministra varias herramientas para probar la interoperabilidad de nuestras aplicaciones.

Validador de etiquetas HTML XHTML http://validator.w3.org/ realmente estructuramos bien nuestra pagina

Validador de Hojas de Estilos CSS http://jigsaw.w3.org/css-validator/, tu lo ves verde y otro azul, serás daltónico? No creo

Validador de Links Rotos http://validator.w3.org/checklink/ estas seguro de donde dejas tus cosas, o buscas debajo de la cama

Bueno estas herramientas entre otras que podrás encontrar en la página de la W3C http://www.w3.org/QA/Tools/ te podrán ayudar a mejorar tus prácticas web y te llevaran a luchar por estas medallas.

SilveOS

2010-05-22T09:51:00.005-05:00

SilveOS.com es un sistema operativo de Silverlight . Trae la comodidad y el confort que sabemos de las aplicaciones de escritorio clásica en su navegador. SilveOS.com le da una interfaz de trabajo familiar que tiene el mismo tanto si está trabajando en la computadora de tu casa, o de forma remota desde un ordenador prestado o público.

SilveOS.com está basada en la web de Silverlight 3 y requiere para funcionar. La aplicación se ejecuta en el entorno limitado de seguridad de Silverlight. Por código predeterminado es restringido el acceso a su sistema de archivos o haciendo cualquier cosa que pueda hacerle daño a su máquina. Además de escritorio, barra de tareas, menú de inicio y la barra lateral, que actualmente incluye aplicaciones como:

* Explorador de archivos

* Internet Explorer

* Reproductor de vídeo

* Editor de texto enriquecido

* Lector de noticias

* Bloc de notas

* Editor de Imagenes

* Cliente Twitter

* Cliente Flickr

* Visor de Youtube

* Virtual Earth

* Chat

* Calculadora

* y juegos como el ajedrez, Solitario, Spider, etc

Silverlight

2010-05-08T10:48:00.010-05:00

Microsoft Silverlight es un complemento de Microsoft que nos permite desarrollar aplicaciones enriquecidas para la web. Silverlight funciona sobre varias plataformas y múltiples exploradores y proporciona una nueva generación de experiencias de usuario basadas en .NET. Tras una descarga que se instala en segundos, Silverlight posibilita una nueva plataforma rica, segura y escalable.

Si quieres comenzar con este cuento te recomiendo estas paginas:

Introduccion:

http://blogs.msdn.com/andygon/archive/2010/04/26/silverlight-4-training-kit.aspx

Herramientas, descargas, información:

http://blogs.msdn.com/andygon/archive/2010/04/16/silverlight-4-herramientas-descargas-informaci-n.aspx

MSDN:

http://msdn.microsoft.com/es-mx/library/cc838158%28VS.95%29.aspx

Con nuevo Blog !!

2010-01-01T12:00:00.002-05:00

Bueno soy nuevo en esto, este blog es acerca de tecnología y mis experiencias en el mundo del análisis y desarrollo de software, tengo experiencia en distintas tecnologías web sobre todo web estoy atento a colaborar en lo que necesiten, espero que lo que publique sea de utilidad para los que me visiten. GRACIAS