Translate

Mostrando entradas con la etiqueta Tutoriales. Mostrar todas las entradas
Mostrando entradas con la etiqueta Tutoriales. Mostrar todas las entradas

jueves, 16 de febrero de 2017

Configurar Github para usarlo con SSH en Linux

Si usas Git y Github y no quieres estar introduciendo tu username y password cada vez que haces un push porque lo tienes configurado con HTTPS, lo mejor es que configures SSH, algunos IDEs, como Visual Studio, lo hacen de manera automática, en Linux es bastante sencillo, incluso en la página de Github te dicen como, sin embargo, para mi la mejor forma de aprender bien algo es intentar explicarlo 😃.

1- Generar una SSH Key
Lo primero es abrir una terminal, presiona ctrl+alt+t y generamos una Key SSH usando tus credenciales de Github, con el siguiente comando:
ssh-keygen -t rsa -b 4096 -C "tu_email_de_registro_en_github@email.com"
Luego sigues los pasos que te indican, ese comando genera un archivo que contiene tu configuración SSH usando el algoritmo RSA con un tamaño de clave de 4096 bits. Tu clave por defecto se almacena en ~/.ssh/id_rsa.pub

2- Añadir tu SSH Key a ssh-agent
Lo siguiente es añadir tu clave SSH a ssh-agent
ssh-add ~/.ssh/id_rsa
(Opcional) Verificamos si se añadió con:
ssh-add -L

sábado, 11 de febrero de 2017

Algoritmo Quicksort

Quicksort es uno algoritmos de ordenación más utilizados en las librerías bases de los lenguajes de programación, por su eficiencia y por su sencillez. Probablemente ya has escuchado o incluso conozcas este algoritmo, sin embargo siempre es bueno repasar lo básico porque, por ejemplo, si estas buscando empleo, es muy probable que en una entrevista de trabajo, especialmente empresas de EEUU, te pidan implementar Quicksort o te pregunten sobre alguno de los algoritmos básicos de ordenación o estructuras de datos como los Heaps.

Un poco de historia

Este algoritmo fue inventado por Tony Hoare a finales de los 60s y también es la base de otros como Quickselect -creado por el mismo Hoare- sin duda, es muy interesante y es uno de los métodos de ordenación “Linearítmicos” más eficientes que existen, sin embargo no siempre garantiza O(nlogn) en su peor caso la complejidad de este algoritmo es cuadrática, eso va a depender de la calidad de pivote que se elija. Ha sido muy estudiado, especialmente por Robert Sedgewick y utiliza la técnica de Divide and Conquer.

Descripción del algoritmo

Obviamente esta es una explicación mundana, como mencioné anteriormente el algoritmo se ha estudiado ampliamente, incluyendo pruebas matemáticas rigurosas. Sin embargo mi intención es que se pueda entender de manera fácil. Para una explicación más completa ver la referencia del libro de Sedgewick al final del post o buscar en Wikipedia. Anteriormente escribí sobre el Heapsort que garantizaba O(nlogn) Quicksort es diferente porque la eficiencia del algoritmo va a depender del elemento pivote.

miércoles, 7 de diciembre de 2016

Algoritmo Heap Sort

Una de las aplicaciones de los Heaps o Montículos es el algoritmo HeapSort, el cual es uno de tantos que permite ordenar un conjunto "S" de datos en tiempo “linearítmico“ O(n logn). No es un algoritmo estable, es decir, no garantiza que los elementos tengan el mismo orden relativo después de la ordenación, pero a diferencia de otros algoritmos como Quicksort siempre garantiza O(n logn) como mejor, promedio o peor caso.


Una vez que se entiende la estructura de datos Heap el algoritmo es bastante sencillo y se basa en los siguientes pasos:
  1. Construir un MaxHeap o MinHeap a partir de un arreglo.
  2. Inicializar un ciclo desde I=heap.Length – 1 hasta I > 1 e Ir eliminando el tope (intercambiándolo con el último elemento I). Luego se verifica desde el primer nodo que se mantenga la propiedad del montículo (El mayor o menor elemento esté en el tope) esta operación generalmente se conoce como Heapify.
La explicación de eliminar del tope junto con Heapify puedes leerlas en mi post sobre Heaps o montículos, donde las explico con imágenes para que se entienda un poco mejor. Cabe destacar que para ordenar de manera creciente se utiliza un MaxHeap y para ordenar de manera decreciente un MinHeap. De igual manera, vale mencionar que la mayoría de las implementaciones de este algoritmo son en sitio, es decir, se modifica directamente el arreglo que se quiere ordenar.

martes, 29 de noviembre de 2016

Heaps o Montículos

Si tienes una carrera formal en computación, o alguna rama relacionada, probablemente habrás visto alguna clase de estructura de datos y recordarás los Heaps o -montículos en español- En caso de que no recuerdes, o no sabías que existían, en este post intentaré explicar de manera resumida esta interesante estructura de datos.

Las operaciones en los heaps son eficientes, la mayoría son O(logn). Los montículos se usan principalmente en el algoritmo Heapsort y en las Priority Queues (Colas de prioridades). Está representada por una estructura de tipo árbol y su característica principal es que el nodo padre -o raíz- siempre es mayor, o menor según sea el caso, que sus nodos hijos.

Los Heaps pueden ser MaxHeaps (El nodo padre es mayor que los hijos) o MinHeaps (El nodo padre siempre es menor que los hijos). La representación más usada son los Binary Heaps (montículos binarios) que tienen la estructura de un árbol binario. La forma más usada para almacenar los datos en esta estructura es un Array (dinámico por lo general), esto genera un árbol binario completo (todas las secciones deben estar balanceadas, con una posible excepción de la última) por lo que sabemos de antemano su forma y con simple aritmética podemos calcular los índices en el array de los nodos hijos a partir del padre y viceversa.
La imagen representa un MaxHeap, nótese como los nodos padres o raíz siempre son mayores a los hijos, y cada vez que se inserte un nuevo nodo o se elimine el nodo raíz se debe garantizar esta propiedad.

sábado, 30 de enero de 2016

Algoritmo Quick Union

Algoritmo Quick Union
Al igual que Quick Find. El algoritmo Quick Union permite conectar nodos de un Árbol entre sí, la diferencia es que en Quick Find las referencias son con el nodo raíz, y Quick Union mantiene una referencia al nodo padre.

Quick Union
El algoritmo se basa en 3 funciones principales, una para encontrar el nodo raíz, otra para unir 2 nodos y una función para verificar si existe conexión entre 2 nodos. Toda la información sobre las conexiones entre nodos se almacenan en un arreglo.

Encontrar el nodo raíz
Para encontrar el nodo raíz basta con recorrer el arreglo dentro de un ciclo hasta que el valor del arreglo[i] sea igual al índice, lo cual quiere decir que alcanzamos la raíz, el algoritmo es de complejidad O(n) donde n = longitud necesaria para alcanzar la raíz, en pseudocódigo:
def find_root(int []array, int node):
    i = node
    while(array[i] != i):
        i = array[i]
    return i
Unir 2 nodos
Para unir 2 nodos "a y b" hay que establecer el nodo raíz de "b" en "a", es decir, hacer algo como:
def union(int []array, int node1, int node2):
    array[find_root(node1)] = find_root(node2)
Saber si 2 nodos están conectados
Sería verificar si los nodos tienen la misma raíz, la complejidad es O(n) al igual que la unión:

viernes, 29 de enero de 2016

Algoritmo Quick Find

El curso de coursera “Algorithms, Part I” me vino excelente ya que este año quería mejorar mis conocimientos en algoritmos. El curso es totalmente gratuito y los vídeos son de altísimo nivel, muy recomendado.

La primera semana introduce un par de algoritmos de conectividad dinámica, son Quick Find y Quick Union. Estos algoritmos permiten conectar y verificar la conexión que existe entre nodos de una estructura de tipo Árbol, representada en un Array. Primero escribiré sobre Quick Find y en otro post sobre Quick Union, para no hacer los posts tan largos.

Quick Find
El algoritmo se basa en 2 funciones principales, Union y Find, Union permite conectar 2 nodos y Find permite verificar si dos nodos están conectados, directa o indirectamente, es decir a través de otros nodos.

Union
La unión permite conectar 2 nodos, la lógica es simple (complejidad O(n)), se basa en recorrer todo el arreglo dentro de un ciclo y establecer como raíz al nodo2 en todos los nodos que tengan como raíz al nodo1, para ello basta con verificar en cada paso si arreglo[i] == arreglo[nodo1], de ser verdadero, sustituir arreglo[i] con el valor del arreglo[nodo2]. De manera tal que todos tengan el mismo nodo raíz, en Pseudopython sería:
def union(int []array, int node1, int node2):
    temp = array[node1]
    for i to len(array):
        if array[i] == temp:
            array[i] = array[node2]

Find
Con find se verifica si dos nodos están conectados y es una operación muy rápida, O(1), creo que por eso el nombre del algoritmo “Quick Find”, basta con verificar si los nodos tienen comparten la misma raíz arreglo[nodo1]==arreglo[nodo2]

 
  Imagen tomada de uno de los vídeos del curso en Coursera

Por ejemplo, en la imagen los nodos 0 5 y 6 están conectados. En el arreglo el valor en la posición id[0] id[5] e id[6] es 0 ya que el id 0 es algo así como el nodo raíz y la forma de verificar si están conectados es que todos tengan el mismo valor.

lunes, 4 de mayo de 2015

Crear nuestros propios eventos en Node.js

Un evento, en el contexto de programación y código, es un suceso de interés al cual nos podemos suscribir y realizar alguna acción en específico, por ejemplo: En el navegador con JavaScript tenemos la función setInterval(callback, interval); que dispara un evento al callback cada vez que se cumple el intervalo especificado.

En Node.js son muy utilizados por el API y de cierta manera encajan perfectamente con su naturaleza asíncrona, por ejemplo, hay un evento muy interesante del objeto “process” que se dispara al momento de salir del entorno de ejecución de Node.js, el evento se llama “exit” y podemos suscribirnos de la siguiente manera:
process.on(“exit”, function () {
     console.log(“Saliendo!”);
});

La mayoría del API de Node.js utiliza los eventos para informar cosas interesantes a las cuales podemos suscribirnos y esto es posible gracias al objeto EventEmitter del módulo events, el cual mediante el método emit permite disparar eventos a todos los suscriptores. Haz clic aquí para más información sobre este objeto. Sin duda alguna, los eventos son un paradigma muy interesante, ahora bien, si queremos que nuestros propios objetos generen eventos el proceso es muy sencillo, basta con “heredar” de la clase EventEmitter, mediante el método del módulo util “inherits” y luego disparar el evento mediante “emit”. Veamos un ejemplo sencillo de un objeto llamado Auto el cual emite el evento “arrancar”:
var EventEmitter = require("events").EventEmitter;
var util = require("util");

//Heredar del objeto EventEmitter
util.inherits(Car, EventEmitter);

function Car(brand) {
    EventEmitter.call(this);
    this._brand = brand;
}

Car.prototype.start = function() {
    console.log("Arrancando el auto de marca " + this._brand);
    var date = new Date();
    this.emit("arrancar", date);
}

var car = new Car("Audi");

car.on("arrancar", function(date) {
    console.log("El auto arranca en la fecha: " + date.toString());
});

car.start();
Como vemos, es muy sencillo primero “Heredamos” del objeto EventEmitter, luego disparamos el evento deseado con el método emit, podemos pasar los parámetros que se requieran al suscriptor como argumentos del método emit, en el caso del ejemplo se pasa la fecha de arranque del auto, por último nos suscribimos al evento con el método on.

Referencias:
https://nodejs.org/api/events.html

sábado, 23 de noviembre de 2013

Configurar PHPUnit y Netbeans en Windows 8


Hace algunos días migré a Windows 8 y tuve que reinstalar todo el entorno de programación desde cero!, me dispuse a descargar todas las herramientas de programación con PHP que usaba en Windows 7, Xampp, Netbeans, etc. Para mi sorpresa las cosas no fueron tan fáciles como esperaba. En este artículo trato de describir como logré la instalación que tenía en Windows 7. La versión usada es Netbeans 7.2 en español.

Instalar Xampp

1) Descargar e instalar xampp para Windows de: http://www.apachefriends.org/en/xampp-windows.html
Es conveniente dejar el path de instalación por defecto, es decir, "C:\xampp". Xampp añade automáticamente el path de php, C:\xampp\php, a las Variables de entorno, por lo que tendremos acceso global desde la terminal a php, y a los paquetes que instalemos con PEAR, como PHPUnit.

2) Luego de instalación ir al directorio de instalación de PHP en Xampp por defecto C:\xampp\php y Eliminar los siguientes archivos:
pear.bat
peardev.bat
phpunit
phpunit.bat

viernes, 11 de octubre de 2013

Concurrencia optimista con Entity Framework

Concurrencia Optimista y Concurrencia Pesimista

Para este artículo es necesario comprender estos dos conceptos que son muy sencillos aunque el nombre haga pensar que es algo complejo. En entornos multiusuario donde se accede a una base de datos, por ejemplo un sitio  web. es común que dos o más personas estén editando algún campo de la base de datos al mismo tiempo.

Vamos a suponer que tenemos un sitio web y varios administradores editando campos de la base de datos y en ese momento dos de ellos están editando el mismo campo. El “Administrador A y el B”. Los dos comienzan a editar el campo al mismo tiempo, el “Administrador A” comienza a editar y luego se va a tomar un café, mientras que el “Administrador B“ edita y guarda rápidamente el campo modificado.

Al regresar el “Administrador A” no va a tener la información actualizada de la base de datos por lo que podrían producirse problemas futuros. En teoría hay dos formas de tratar con un escenario de este estilo aquí es donde aparecen los dos conceptos de concurrencia optimista y pesimista

Traduciendo aplicaciones en ASP.NET MVC 4 y .NET 4.5

Como el título indica la versión utilizada es ASP.NET MVC 4, .NET 4.5 y Visual Studio Express 2012. Si no conoces lo que es un archivo de recurso en ASP.NET puedes visitar el siguiente link en MSDN

Lo primero que haremos es crear una carpeta con el nombre Resources, de igual manera podríamos haber colocado nuestro recurso en la "carpeta especial" App_GlobalResources, pero puede generar problemas tal y como explica Scott Allen en el siguiente artículo el cual recomiendo leer.

Una vez creada la carpeta añadimos un archivo de recursos, Clic derecho en la carpeta, Agregar > Nuevo elemento. Deberíamos dar un nombre significativo por ejemplo: “Text” o “Labels”. Este archivo de recursos, Text.resx, va a ser el idioma por defecto de nuestra aplicación, supongamos que es español, damos doble clic al archivo en el explorador de soluciones y veremos algo parecido a la imagen.