Características de Javascript – 01

Operador Ternario (?)

Regularmente cuando trabajamos con condiciones estamos acostumbrados a utilizar las clausulas if-else, pero, lo cierto es que no siempre son la mejor ni la única opción que nos ofrece javscript, sobre todo si nuestro código a ejecutar en cada bloque condicional es de tan sólo una línea, veamos el siguiente ejemplo:

El Siguiente código javascript:

var isPhpDeveloper = true;
var framework;
if(isPhpDeveloper){
    framework = "Symfony!";
}
else{
    framework = "Rails";
}
console.log("Yo utilizo " + framework);

Podemos cambiarlo utilizando el operador ternario y haciendo nuestro código más conciso:

var isPhpDeveloper = true;
var framework = isPhpDeveloper ? "Symfony!" : "Rails";
console.log("Yo utilizo " + framework);

También podríamos colocar un operador ternario dentro de una concatenación de variables tipo string:

var isPhpDeveloper = false;
console.log("Yo utilizo " + (isPhpDeveloper ? "Symfony!" : "Rails"));

Noten que el bloque del operador ternario está encerrado entre paréntesis, esto es necesario ya que el operador ternario (?) evaluará toda expresión que esté antes de él y si no separamos  el operador ternario de la cadena anterior y entonces podríamos no estar evaluando lo que realmente deseamos. Recordemos que los valores que se traducen como falsos dentro de un bloque condicional son: false, undefined, null, 0 (cero) y "" (Una cadena vacía), todo lo demás es traducido como verdadero o true.

Pero, esto no se queda acá podemos incluso añadir mucha más lógica cuando hacemos uso del operador ternario:

var isPhpDeveloper = true;
var framework, ide; 

isPhpDeveloper ? (framework = "Symfony!", ide = "PHPStorm")
               :
                 (framework = "Rails!",   ide = "RubyMine");

console.log("Yo utilizo " + framework + (ide ? " y mi IDE es " + ide : ""));

También podríamos tener operadores ternarios anidados:

var isPhpDeveloper = true;
var likeFrameworks = true;
var framework, ide; 

isPhpDeveloper && likeFrameworks ? (framework = "Symfony!", ide = "PHPStorm")
                                :
                                isPhpDeveloper ? (framework = "Un imán!", ide = "")
                                               : (framework = "Perl!");

console.log("Yo utilizo " + framework + (ide ? " y mi IDE es " + ide : ""));

Otra característica que podemos explotar otras características al unir el operador ternario con funciones anónimas:

var isPhpDeveloper = true;

isPhpDeveloper ? function() {
                     console.log("Yo utilizo Symfony y mi IDE es PHPStorm"));
                 }()
               :
                 function() {
                     console.log("Yo utilizo Rails y mi IDE es RubyMine"));
                 }();

Asignación Lógica OR (||)

Hay veces donde el operador ternario es incluso menos conciso de lo que deseamos, para estos casos podemos hacer usos de la asignación lógica, en este ejemplo veremos que los operadores lógicos pueden hacer la asignación condicional incluso más corta que con el con operador ternario:

var technologiesSkills = {
    addProgrammingLanguage: function(language){
        this.languages = this.languages || []; // Asignación lógica con "OR"
        this.languages.push(language);
    }
};

En el ejemplo que acabamos de ver, hacemos uso del operador lógico OR (||) para efectuar una asignación lógica de valor. Cuando utilicemos la asignación lógica con el operador OR será asignador el primer valor que sea evaluado como verdadero (thruty value) o distinto de falso (non falsy value) <recordemos la lista de valores que son tomados como falso en JavaScript>, si no encuentra valores evaluados como verdaderos asignará el último valor de la asignación lógica (El que se encuentra más a la derecha).

Asignación Lógica AND (&&)

En este caso se tomará el último valor evaluado como verdadero en la asignación lógica (El que se encuentre más a la derecha) o el primer valor evaluado como falso. Veamos un ejemplo de esto:

var language = "" && "PHP"; // language = ""
var language = 0 && "PHP"; // language = 0
var language = undefined && "PHP"; // language = undefined

var language = "English" && "PHP"; // language = "PHP"

var isDeveloper = true;
var technologies = {
    languages: ["PHP", "JavaScript", "Python", "Ruby", "Java"]
    retrieveLanguage: function (languageRequested) {
        var index = this.languages.indexOf(languageRequested);
        return (index>0)? this.languages.splice(index, 1)[0] : false;
    }
};

// language will contain "PHP" if:
var language = isDeveloper && technologies.retrieveLanguage("PHP");

// language will be false if:
var language = isDeveloper && technologies.retrieveLanguage("English");

Sentencia SWITCH

Utilizar la sentencia switch puede muchas veces ayudar a que nuestro código sea un poco más conciso y también podemos utilizar sus características propias como el funcionamiento fall-through para construir bloques jerárquicos. Vamos con un ejemplo:

Supongamos que queremos crear un objeto Empresa que requiere saber de las aptitudes que debe de tener un programador de acuerdo a su experiencia. Construyamos la clase empresa:

/**
 * Constructor
 */
function Company (name, country, address, webPage){
    this.name = name;
    this.country = country;
    this.address = address;
    this.webPage = webPage;
}

// Methods
Company.prototype = {
    getSkillsForWebDeveloper: function(level){
        var skills = [];
        switch (level) {
            case "Jr":
                skills.push("Algorítmos", "PHP", "Javascript", "HTML5", "CSS3",
                            "MySQL", "SQL");
                break;
            case "Semi-senior":
                skills.push("Algorítmos", "PHP", "Javascript", "HTML5", "CSS3",
                            "MySQL", "SQL", "Bootstrap", "jQuery", "Yii", 
                            "Codeigniter", "PostgreSQL");
                break;
            case "Sr":
                skills.push("Algorítmos", "PHP", "Javascript", "HTML5", "CSS3", 
                            "MySQL", "SQL", "Bootstrap", "jQuery", "Yii", 
                            "Codeigniter", "PostgreSQL", "Symfony", "Laravel",
                            "Phalcon", "Python", "Django", "Nodejs", "Expressjs",
                            "Angularjs", "PL/PgSQL", "MongoDB");
                break;
            default:
                alert("Is not ther the level " + level);
                break;
        }
        return skills;
    };
};

En el ejemplo vemos que repetimos los skills que tiene un desarrollador “Jr” en los niveles subsecuentes como Semi-senior o Sr. Esto lo podemos mejorar haciendo el uso del fall-through del bloque switch, esto lo logramos quitando la palabra clave “break” en los bloques “case” que deseemos que :

/**
 * Constructor
 */
function Company (name, country, address, webPage){
    this.name = name;
    this.country = country;
    this.address = address;
    this.webPage = webPage;
}

// Methods
Company.prototype = {
    getSkillsForWebDeveloper: function(level){
        var skills = [];
        switch (level) {
            case "Jr":
                skills.push("Algorítmos", "PHP", "Javascript", "HTML5", "CSS3",
                            "MySQL", "SQL");
            case "Semi-senior":
                skills.push("Bootstrap", "jQuery", "Yii", 
                            "Codeigniter", "PostgreSQL");
            case "Sr":
                skills.push("Symfony", "Laravel", "Phalcon", "Python", "Django",
                            "Nodejs", "Expressjs", "Angularjs", "PL/PgSQL",
                            "MongoDB");
                break;
            default:
                alert("Is not ther the level " + level);
                break;
        }
        return skills;
    };
};

Luego seguiremos con más características y buenas prácticas de desarrollo en Javascript.

Anuncios

MongoDB – Primeros Pasos – 01

logo-mongodb-tagline

Creo que ya conocemos de MongoDB, ya el decir que es una base de datos NoSQL orientada a documentos y que almacena sus datos en formato BSON (JSON Binario) ya suena a cliché. Es una de las base de datos NoSQL más populares, pero, por qué?… Hay muchas razones, una de ellas, está en el hecho de que en contraste con otras bases de datos NoSQL como Redis o Cassandra (Con las que bien puede complementarse) MongoDB da una facilidad extra a los desarrolladores y DBAs que venimos con cierta experiencia en bases de datos relacionales como Oracle o PostgreSQL, ya que varios conceptos básicos como colecciones (tablas), documentos (registros), atributos (columnas o campos), índices (índices), entre otros, son (aunque no iguales) análogos, con la diferencia de que aunque los datos en MongoDB poseen una estructura definida no existe un esquema rígido y fijo como en los RDBMS (Sistemas de bases de datos relacionales). Otra característica que la ayuda a ser la elegida de los desarrolladores es que al proveer sus datos en formato JSON este se adapta fácilmente a cualquier lenguaje de programación.

Pero, ¿Cuándo utilizarla?

A esta pregunta se responde con la forma de trabajar de MongoDB, a diferencia de los RDBMS, MongoDB no posee transacciones y tampoco soporta integridad referencial (no directamente) con joins o relaciones entre distintas colecciones, aunque con cada versión de MongoDB esta brecha de distinciones con los RDBMS está reduciéndose. (Ver Map Reduce y Aggregation Framework)

No veamos esto como una deficiencia, estas distinciones además hacen que MongoDB sea muy rápida y tenga un performance muy superior con respecto a las bases de datos relacionales, por lo que es muy utilizada hoy en día para la aplicación de Big Data e Inteligencia de Negocio. Además también es muy utilizada en aplicaciones tipo CRUD como lo son mucho de los desarrollos web actuales. (Ver MEAN.js)

Además, ¿Quiénes la utilizan?

¿Que quiénes utilizan MongoDB? Aunque las bases de datos NoSQL hoy son algo relativamente (ya no debería serlo para nadie) nuevo… MongoDB es utilizado por empresas importantes en el ámbito de la tecnología como Google o Facebook y en otras empresas que se dedican a promover el imperio norteamericano como New York Times.

Si quieren ahondar más en el cuándo utilizar MongoDB, ventajas y desventajas recomiendo este post.

Ya hemos hablado mucho de MongoDB, vamos a dar nuestros primeros pasos como desarrolladores (aún no como DBAs) en esta base de datos, comenzaremos explicando cómo insertamos los datos en MongoDB:

Antes de insertar datos en MongoDB es bueno saber cómo se instala, eso lo pueden conseguir fácilmente en la documentación oficial de MongoDB. Acá les dejo la instalación en Ubuntu que es de donde estaré llevando a cabo la práctica de estos post de MongoDB.

Una vez instalada y suponiendo que tenemos corriendo el servicio de MongoDB (mongod) en el puerto 27017. Si no lo tuvieramos deberíamos crea un documento para la configuración (es lo más recomendado):

$ nano config.cfg

Y agregarímos lo siguiente al archivo, teniendo en cuenta que los directorios indicados para almacenar los log (logpath) y las bases de datos (dbpath) deben existir:

logpath=/home/user/mongodb/log/mongo.log
dbpath=/home/user/mongodb/data/db

Guardamos el archivo, nos posicionamos en el mismo direcorio donde creamos el archivo, para mayor facilidad y ejecutamos lo siguiente para levantar el servicio:

$ nohup mongod --config config.cfg &

Este proceso casi siempre hay que hacerlo para levantar el servidor de MongoDB en Guindows ya que en la mayoría de las distribuciones Linux el servicio se levanta automáticamente…

Podemos verificar dónde (en qué puerto) está corriendo mongo a nivel local ejecutando lo siguiente:

  $ sudo lsof -iTCP -sTCP:LISTEN | grep mongo

Vamos a la terminal

Antes de comenzar explicaré que la nomenclatura de las terminales donde estaremos ejecutando comandos, son las siguientes:

1.- Si el código comienza con el caracter “dolar” ($) el comando lo ejecutaremos en la terminal del sistema operativo.

2.- Si el comando comienza con el caracter “mayor que” (>) estaremos en el cliente (o shell) de MongoDB.

Para entrar al shell o cliente de MongoDB debemos ejecutar en la terminal:

  $ mongo

Este comando nos conectará a MongoDB en el puerto por defecto (27017) y la base de datos por defecto “test”. También podemos conectarnos a una base de datos de forma directa ejecutando lo siguiente:

  $ mongo localhost:27017/mi-base-de-datos

Por ahora, solo ejecutaremos mongo en la terminal, esto nos llevará al shell de MongoDB. El prompt de MongoDB es un cliente que permite ejecutar código javascript para comunicarse con la base de datos.

Este primer post va a estar orientado a cómo Registrar Datos en MongoDB, para esto es necesario conocer los tipos de datos con los que nos encontraremos y la estructura de un documento JSON.

En MongoDB los documentos JSON se almacenan en Colecciones las cuales poseen una estructura de datos no fija definida por los mismos documentos JSON que se encuentran registrados en estas. Por otra parte, los documentos JSON están compuesto por dos tipos de estructuras de datos:

  1. Una colección de pares nombre : valor , en otros lenguajes esto es conocido como arreglos asociativos, diccionario de datos, tablas hash…
  2. Una lista ordenada de valores, en otros lenguajes esto es conocido como matriz, vector, lista, secuencia.

Un ejemplo de un documento JSON es el siguiente:

 {
     "id" : 1,
     "nombre" : "María",
     "apellido" : "Pérez",
     "edad": 27,
     "fechaDeNacimiento": new ISODate("1987-04-21")
     "hobbies": [
         "Jugar Tenis",
         "Ir de Compras",
         "Ir al Cine",
         "Ir a Fiestas"
     ]
 }
 

En el Shell de Mongo se pueden ejecutar algunas funciones para obtener información de nuestro entorno, alguna de las funciones que nos dan información son las siguientes:

El siguiente comando nos muestra la lista de bases de datos presentes en el servidor con el tamaño que ocupan:

> show dbs;

El objeto “db” es el que más utilizaremos en Mongo, este representa el contexto de la base de datos donde estamos conectados actualmente, al ejecutar esta línea en el Prompt veremos el nombre de la base de datos actual:

> db;

Con el objeto “db” podemos tener información como el de la versión de la base de datos, ejecutando lo siguiente:

> db.version();

Por ejemplo, podríamos ver las colecciones presentes en la base de datos con:

> db.getCollectionNames();

O ver las estadísticas ejecutando:

> db.stats()

El objeto “db” tiene además muchos otros métodos y propiedades que la harán nuestra herramienta principal, además a través de este podremos efectuar operaciones sobre nuestras colecciones. Por otra parte, para cambiar entre bases de datos o crear una base de datos nueva solo hay que ejecutar:

> use miBaseDeDatos;

Si la base de datos “miBaseDeDatos” no existiera se crearía una y el shell se cambiaría a esa nueva base de datos, de existir solo haría esto último.

Si ejecutas el comando “exit” en la shell puedes salir de ella hacia la terminal del sistema:

> exit; // Te vuelves a conectar ejecutando mongo

Para ver más método que pueden ser ejecutados en el shell de MongoDB pueden acceder acá.

Vamos a conectarnos a una base de datos llamadas begin.

> use begin;

Para registrar datos en MongoDB lo podemos hacer desde su shell, mediante un archivo javascript o a través de un archivo json.

1.- Vamos a ver cómo registrar datos desde el shell de MongoDB, para esto hay que entender que las colecciones (a diferencia de las tablas en las bases de datos relacionales) no se crean antes que los documentos que la contienen, no se define una estructura para las colecciones, por tanto las colecciones empiezan a existir cuando se registra un documento en ellas. Para registrar un documento en una colección se hace uso del método “insert” de dicha colección, teniendo este comando el siguiente formato:

> db.<nombreDeLaColección>.insert();

Para comenzar, crearemos una colección llamada estudiante, para esto crearemos primero una variable “nuevoEstudiante” que contendrá un objeto JSON con los datos de un estudiante, y luego utilizaremos el método “insert” para insertar un nuevo documento y a su vez crear una colección nueva (si esta no existiera):

> var nuevoEstudiante = { "nombre" : "Gabriel Alejandro", 
                          "apellido" : "González León",
                          "genero": "M", 
                          "fecha_nacimiento" : new ISODate("1987-10-04"),
                          "curso" : "Desarrollo de Software",
                          "aptitudes" : [
                               "Linux", "Oracle", "PostgreSQL", "MongoDB", 
                               "MySQL", "PHP", "Javascript", "GIT", "Python", 
                               "Ruby", "Java SE", "Java EE", "Node", "jQuery", 
                               "AngularJS", "Yii", "Symfony", "Laravel", 
                               "Django", "ExpressJS", "Rails", "Spring", "Hibernate"
                          ]
                         };
db.estudiante.insert(nuevoEstudiante);

Con las sentencias ejecutadas anteriormente a la base de datos, se pueden apreciar el proceso de inserción de un solo documento a la colección “estudiante”. Al pasar un arreglo de documentos JSON al método insert pudiéramos insertar varios datos a la vez, eso lo lograríamos si ejecutamos lo siguiente:

> var listaDeEstudiantes = [
 {
   "origen" : "V",
   "cedula" : 12,
   "nombre" : "María",
   "apellido" : "Moncada",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1989-11-24"),
   "curso" : "Administración de Base de Datos",
   "aptitudes" : ["Linux", "Oracle", "PostgreSQL", "MongoDB", "MySQL", 
                "Apache", "Glassfish"]
 },
 {
   "origen" : "V",
   "cedula" : 13,
   "nombre" : "José",
   "apellido" : "Pérez",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1992-06-14"),
   "curso" : "Desarrollo de Software",
   "aptitudes" : ["Linux", "Oracle", "PostgreSQL", "MongoDB", "MySQL", 
                "PHP", "Javascript", "GIT", "Python", "Ruby", "Java SE", 
                "Java EE", "Node", "jQuery", "AngularJS", "Yii", "Symfony", 
                "Laravel", "Django", "ExpressJS", "Rails", "Spring", 
                "Hibernate"]
 },
 {
   "origen" : "V",
   "cedula" : 14,
   "nombre" : "Alexander",
   "apellido" : "Sosa",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1991-08-29"),
   "curso" : "Desarrollo de Software",
   "aptitudes" : ["Linux", "Oracle", "MongoDB", "MySQL", "Java SE", 
                "Java EE", "Node", "jQuery", "AngularJS", "ExpressJS", 
                "Spring", "Hibernate"]
 },
 {
   "origen" : "V",
   "cedula" : 15,
   "nombre" : "Carmen",
   "apellido" : "Alvarado",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1987-04-13"),
   "curso" : "Levantamiento de Procesos",
   "aptitudes" : ["Linux", "UML", "BPMN", "Bonita", "Intalio"]
 },
 {
   "origen" : "V",
   "cedula" : 16,
   "nombre" : "Luisa",
   "apellido" : "Ibarra",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1987-04-13"),
   "curso" : "Levantamiento de Procesos",
   "aptitudes" : ["Linux", "UML", "StarUML"]
 },
 {
   "origen" : "V",
   "cedula" : 17,
   "nombre" : "Alex",
   "apellido" : "Kernel",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1987-01-07"),
   "curso" : "Desarrollo de Software",
   "aptitudes" : ["Linux", "PostgreSQL", "MongoDB", "MySQL", "PHP", 
                "Javascript", "GIT", "HTML5", "CSS", "Ruby", 
                "Java SE", "Java EE", "jQuery", "Yii", "Symfony", 
                "Rails", "Spring", "Hibernate"]
 },
 {
   "origen" : "V",
   "cedula" : 18,
   "nombre" : "Sofía",
   "apellido" : "Morales",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1991-03-14"),
   "curso" : "Desarrollo de Software",
   "aptitudes" : ["Linux","PostgreSQL", "MongoDB", "PHP", "Javascript", 
                "HTML5", "Python", "Java EE", "Node", "jQuery", "AngularJS", 
                "Symfony", "Laravel", "Django", "ExpressJS", "Spring"]
 },
 {
   "origen" : "V",
   "cedula" : 19,
   "nombre" : "Edgar",
   "apellido" : "Brito",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1988-08-04"),
   "curso" : "Administración de Base de Datos",
   "aptitudes" : ["Linux", "PostgreSQL", "MySQL", "Apache", "Windows", 
                "Tomcat", "Glassfish"]
 },
 {
   "origen" : "E",
   "cedula" : 21,
   "nombre" : "Pedro",
   "apellido" : "Echenique",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1996-09-24"),
   "curso" : "Administración de Base de Datos",
   "aptitudes" : ["Linux", "Oracle", "MongoDB", "MySQL", "Apache", "Nginx"]
 },
 {
   "origen" : "E",
   "cedula" : 22,
   "nombre" : "Kevin",
   "apellido" : "Pedrosa",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1997-09-19"),
   "curso" : "Levantamiento de Procesos",
   "aptitudes" : ["Windows", "UML", "BPMN", "Intalio"]
 },
 {
   "origen" : "V",
   "cedula" : 23,
   "nombre" : "Javier",
   "apellido" : "Osorio",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1993-07-14"),
   "curso" : "Desarrollo de Software",
   "aptitudes" : ["Linux", "Oracle", "PostgreSQL", "MySQL", "Javascript", 
                "GIT", "HTML5", "CSS", "Python", "Java SE", "Java EE", 
                "AngularJS", "Spring", "Hibernate"]
 },
 {
   "origen" : "E",
   "cedula" : 24,
   "nombre" : "Mary",
   "apellido" : "González",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1995-11-10"),
   "curso" : "Desarrollo de Software",
   "aptitudes" : ["Windows", "Oracle", "MongoDB", "MySQL", "PHP",
                "Javascript", "HTML5", "CSS", "Ruby", "Java EE", 
                "Node", "AngularJS", "Symfony", "ExpressJS", "Rails"]
 },
 {
   "origen" : "E",
   "cedula" : 25,
   "nombre" : "Ana",
   "apellido" : "Luengo",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1983-12-17"),
   "curso" : "Levantamiento de Procesos",
   "aptitudes" : ["Linux", "Windows", "UML", "BPMN", "Intalio"]
 },
 {
   "origen" : "V",
   "cedula" : 26,
   "nombre" : "Leticia",
   "apellido" : "Prieto",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1989-10-07"),
   "curso" : "Levantamiento de Procesos",
   "aptitudes" : ["Linux", "BPMN", "Bonita"]
 },
 {
   "origen" : "E",
   "cedula" : 27,
   "nombre" : "Mery",
   "apellido" : "Estrada",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1976-05-20"),
   "curso" : "Administración de Base de Datos",
   "aptitudes" : ["Linux", "PostgreSQL", "MongoDB", "Apache", "Nginx", 
                "Glassfish"]
 },
 {
   "origen" : "V",
   "cedula" : 28,
   "nombre" : "Orlando",
   "apellido" : "Esparragosa",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1990-04-10"),
   "curso" : "Levantamiento de Procesos",
   "aptitudes" : ["Linux", "BPMN", "Bonita", "UML"]
 },
 {
   "origen" : "E",
   "cedula" : 31,
   "nombre" : "Rosangel",
   "apellido" : "Quiroz",
   "genero": "F",
   "fecha_nacimiento" : new ISODate("1988-07-08"),
   "curso" : "Administración de Base de Datos",
   "aptitudes" : ["Linux", "PostgreSQL", "MySQL", "Apache", "Nginx", 
                "Glassfish"]
 },
 {
   "origen" : "V",
   "cedula" : 32,
   "nombre" : "Nelson",
   "apellido" : "Prato",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1992-11-13"),
   "curso" : "Desarrollo de Software",
   "aptitudes" : ["Linux", "MySQL", "PHP", "Javascript", "GIT", "HTML5", "CSS", 
                "Python", "AngularJS"]
 },
 {
   "origen" : "V",
   "cedula" : 33,
   "nombre" : "Nelson",
   "apellido" : "Prato",
   "genero": "M",
   "fecha_nacimiento" : new ISODate("1992-11-13"),
   "curso" : "Desarrollo de Software",
   "aptitudes" : ["Linux", "Oracle", "PHP", "Java SE", "Javascript", "GIT", 
                "HTML5", "CSS", "Python", "AngularJS", "Symfony"]
 }
 ];

db.estudiante.insert(listaDeEstudiantes);

Ejecutando esto desde la shell de MongoDB habremos cargado 19 estudiantes más el primero cargado de forma individual, tendríamos un total de 20 estudiantes.

2.- Otra forma de cargar datos es a través de un documento javascript, empecemos por guardar en un archivo llamado cargaPuntuaciones.js el siguiente código javascript (Ver más detalle en la documentación oficial):

function cargaPuntuaciones() {

    // Al estar en el contexto de un archivo Javascript en Mongo,
    // se necesita obtener la base de datos que representa el objeto db
    db = db.getSiblingDB("curso");

    db.puntuaciones.drop();

    var tiposEjercicios = [  "interrogatorio" , 
                             "ejercicio" , 
                             "tarea" , 
                             "examen",  
                             "taller",  
                             "exposición",  
                             "laboratorio",  
                             "proyecto",  
                             "foro", 
                             "debate" ];

    var cursorEstudiantes = db.estudiante.find();

    var estudiante = null;

    var puntuacion = null;
        
    while(cursorEstudiantes.hasNext()){

        estudiante = cursorEstudiantes.next();
        if (version26Post()) {
           var cargaMasiva = db.puntuaciones.initializeUnorderedBulkOp();
           for (var i = 1 ; i <= 5 ; i++) {
               for (var j = 0 ; j < 10 ; j++) {
                   cargaMasiva.insert({
                       idEstudiante : estudiante._id ,
                       periodo : i,
                       tipo : tiposEjercicios[j] ,
                       puntuacion : 100 * Math.random()
                   });
               }
           }
           cargaMasiva.execute();
        }
        else {
            for (var i = 1 ; i <= 5 ; i++) {
                for(var j = 0 ; j < 10 ; j++) { 
                    db.puntuaciones.insert( { 					
                        idEstudiante : estudiante._id,
                        periodo : i,
                        tipo : tiposEjercicios[j],
                        puntuacion : 100 * Math.random()
                    });
                }
            }
        }
    }
}

/**
 * Indica si la versión de Mongo es mayor a la 2.6
 */
function version26Post() {
    var partesVersion = version().split( "." );
    return partesVersion[0] + partesVersion[1] >= 26;
};

cargaPuntuaciones();

Podemos ir a la terminal del sistema operativo y ejecutamos lo siguiente:

$ mongo localhost:27017/begin --shell cargaPuntuaciones.js

Ó también desde el shell de MongoDB podemos utilizar la función load para cargar los archivos js:

> load("/home/user/mongodb/scripts/cargaPuntuaciones.js")

Con esto, si ya hemos cargado los 20 estudiantes anteriormente tendremos 1000 calificaciones cargadas con las que próximamente podremos practicar los procesos de consulta.

3.- Otra forma de insertar datos en una base de datos MongoDB es haciendo uso del comando mongoimport, este nos permite importar datos a una colección de la base de datos a la que indiquemos a través de archivos en formato JSON o CSV. Más información en la documentación.

$ mongoimport –db users –collection contacts –file contacts.json

Esto se ejecutaría luego de haber ejecutado un mongoexport.

$ mongoexport –db users –collection contacts –out contacts.json

4.- También podemos hacer un restore de una base de datos MongoDB con el comando mongorestore, esto luego de hacer un backup de la base de datos con mongodump.

Este primer post de MongoDB (espero que no sea el último) tuvo el objetivo de estudiar las formas de insertar datos en MongoDB y entender más o menos la estructura con la que se almacenan los datos en esta muy funcional base de datos. Más adelante veremos la forma de consultar los datos, actualizarlos y eliminarlos.

Si recibes un warning al inicial la shell de mongo, acá puedes ver una solución

Pentaho Data-Integration (ulimit -c unlimited) Problemas con Java

spoon

Hace unas horas empecé mi migración de todas mis máquinas a Ubuntu 14.04. Esto implicó instalar tooooodo de nuevo incluyendo mis herramientas de trabajo para el desarrollo de software entre esas herramientas se encuentra Pentaho Data Integration 5.0.1, mejor conocida como spoon o kettle, la cual depende de java (en mi caso java-8-oracle) por lo que al ejecutar ./spoon.sh se me presentó el siguiente error:


DEBUG: Using PENTAHO_JAVA_HOME
DEBUG: _PENTAHO_JAVA_HOME=/usr/lib/jvm/java-8-oracle
DEBUG: _PENTAHO_JAVA=/usr/lib/jvm/java-8-oracle/bin/java
No bp log location saved, using default.
[000:000] Cpu: 6.42.7, x4, 2301Mhz, 3863MB
[000:000] Computer model: Not available
[000:000] Browser XEmbed support present: 1
[000:000] Browser toolkit is Gtk2.
[000:000] Using Gtk2 toolkit
No bp log location saved, using default.
[000:000] Cpu: 6.42.7, x4, 2301Mhz, 3863MB
[000:000] Computer model: Not available
[000:320] No bp log location saved, using default.
[000:322] Cpu: 6.42.7, x4, 2301Mhz, 3863MB
[000:322] Computer model: Not available
[000:322] Browser XEmbed support present: 1
[000:322] Browser toolkit is Gtk2.
[000:322] Using Gtk2 toolkit
[000:283] No bp log location saved, using default.
[000:285] Cpu: 6.42.7, x4, 2301Mhz, 3863MB
[000:285] Computer model: Not available
#
# A fatal error has been detected by the Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x00007f2bed1632a1, pid=3852, tid=139828568024832
#
# JRE version: Java(TM) SE Runtime Environment (7.0_45-b18) (build 1.7.0_45-b18)
# Java VM: Java HotSpot(TM) 64-Bit Server VM (24.45-b08 mixed mode linux-amd64 compressed oops)
# Problematic frame:
# C  [libsoup-2.4.so.1+0x6c2a1]  soup_session_feature_detach+0x11
#
# Core dump written. Default location: /opt/pentaho/data-integration/core or core.3852
#
# An error report file with more information is saved as:
# /tmp/hs_err_pid3852.log
#
# If you would like to submit a bug report, please visit:
#   http://bugreport.sun.com/bugreport/crash.jsp
# The crash happened outside the Java Virtual Machine in native code.
# See problematic frame for where to report the bug.
#
Aborted (core dumped)

La causa de esto es que después de actualizar a GNOME 3.8 con libsoup 2.42.0, Eclipse se bloquea de forma después de unos segundos de su utilización, esto se presenta como un error ya reportado de eclipse, para más detalle podemos acceder a este link.

Lo importante de esto después de todo es la solución y eso lo conseguimos editando el archivo “spoon.sh” que se encuentra en el directorio de Pentaho Data Integration, ahí buscaremos la línea que comience por OPC=”$… la comentaremos y la sustituiremos por la siguiente línea:

OPT="$OPT $PENTAHO_DI_JAVA_OPTIONS -Djava.library.path=$LIBPATH -DKETTLE_HOME=$KETTLE_HOME -DKETTLE_REPOSITORY=$KETTLE_REPOSITORY -DKETTLE_USER=$KETTLE_USER -DKETTLE_PASSWORD=$KETTLE_PASSWORD -DKETTLE_PLUGIN_PACKAGES=$KETTLE_PLUGIN_PACKAGES -DKETTLE_LOG_SIZE_LIMIT=$KETTLE_LOG_SIZE_LIMIT -Dorg.eclipse.swt.browser.DefaultType=mozilla"

 

Tenga en cuenta que la cosa que hay que añadir a las opciones de Java es:

-Dorg.eclipse.swt.browser.DefaultType = mozilla

En caso de que todavía surgen problemas, trate de añadir esta opción también:

-Dorg.eclipse.swt.browser.XULRunnerPath = / usr/lib64/xulrunner /

o la ruta equivalente en su sistema para xulrunner

y eso es todo, espero que sea de ayuda.

Fuente de Información

http://sharingtechknowledge.blogspot.com/2013/08/pentaho-data-integration-kettle-on.html

Instalando PHP5, XDebug, Mcrypt, APC, Apache en Ubuntu 14.04 y Derivados

linux-mysql-php-apache2Muchas son las veces que debo ponerme a configurar un nuevo servidor web para PHP 5.6 en un equipo con Ubuntu o Debian y bueno, este es un muy buen momento para crear una lista de comandos con el fin de no tener que buscar en mi muy estropeada memoria y ayudar al que pase por acá buscando información:

Lo primero que debemos hacer es añadir el repositorio ppa:ondrej/php5 que es el que tiene por ahora la versión 5.4 de PHP, esto lo hacemos ejecutando este comando add-apt-repository  en nuestra consola:

sudo apt-get install libpcre3-dev
sudo -E add-apt-repository ppa:ondrej/php # Si eres Ubuntu
sudo apt-get update
sudo apt-get install git apache2 php5.6 php5.6-cli php5.6-xdebug php5.6-pgsql php5.6-gd php5.6-apcu php5.6-mcrypt php5.6-sqlite php5.6-dev php5.6-intl php5.6-pear php5.6-ldap php5.6-mbstring php5.6-xml

Cuando reiniciamos una y otra vez el servidor apache seguramente nos encontraremos con un alerta (warning) fastidioso por parte del servicio apache2, algo como:

* Starting web server apache2
apache2: Could not reliably determine the server's fully qualified domain name,
using 127.0.1.1 for ServerName

Esto lo resolvemos muy fácil, ejecutamos el siguiente comando:

sudo sh -c 'echo "ServerName localhost" >> /etc/apache2/apache2.conf'
sudo service apache2 restart

Antes de Seguir debemos asegurarnos adicionalmente de que al final en el archivo /etc/php/5.6/apache/php.ini y /etc/php/5.6/cli/php.ini se deben activar las siguientes opciones (los dos últimos parámetros deben setearse en estos valores sólo en ambiente de desarrollo ya que repercute en el performance si se colocan así en ambiente de producción):

date.timezone = America/Caracas
short_open_tag = Off
display_errors = On
html_errors = On

Reiniciamos el apache.

sudo service apache2 restart

No estaría de más añadir a nuestro ambiente de desarrollo un admminitrador de control de versiones como git:

sudo apt-get install git

Una vez Finalizado esto ya tendremos nuestro entorno de desarrollo web PHP casi completo. Me faltó oci8 y pdo_oci para soporte a Oracle, se los debo.

Dejo acá un link para Instalar PHPMyAdmin Y Acá un link para instalar PHP OCI8 para conexión a la Base de Datos Oracle
Me gustaría enseñarles también cómo configurar un proyecto Symfony2 llamado “sgc” con url amigables en apache y que pueda ser accedido desde el navegado con la dirección “sgc.dev”:

<VirtualHost *:80>
    ServerName sgc
    ServerAlias sgc.dev
    SetEnv SYMFONY__DATABASE__USER “postgres”
    SetEnv SYMFONY__DATABASE__PASSWORD “postgres”
    DocumentRoot “/var/www/demo/web”
    DirectoryIndex app_dev.php
    <Directory “/var/www/demo/web”>
        AllowOverride None
        Allow from All
        <IfModule mod_rewrite.c>
            Options -MultiViews
            RewriteEngine On
            RewriteCond %{REQUEST_FILENAME} !-f
            RewriteRule ^(.*)$ app.php [QSA,L]
        </IfModule>
    </Directory>
    KeepAlive On
    MaxKeepAliveRequests 200
    KeepAliveTimeout 5
    AddOutputFilterByType DEFLATE text/css text/plain text/html application/xhtml+xml text/xml application/xml
    <IfModule mod_headers.c>
       Header append Vary User-Agent env=!dont-vary
        ExpiresActive On
        ExpiresDefault “now plus 1 week”
        ExpiresByType image/x-icon “now plus 1 month”
        ExpiresByType image/gif “now plus 1 month”
       ExpiresByType image/png “now plus 1 month”
       ExpiresByType image/jpeg “now plus 1 month”
   </IfModule>
</VirtualHost>

El archivo anterior podría ser copiado en “/etc/apache2/sites-available/demo.conf” por ejemplo, y luego ejecutar:

# sudo a2ensite demo.conf

Luego debemos editar el archivo /etc/hosts y añadir la línea “127.0.0.1 demo.dev” ejecutando lo siguiente:

# sudo nano /etc/hosts

y pegar en la última línea

127.0.0.1       demo.dev

Por otra parte, les dejo también un aporte, esto a continuación es un archivo index.php que yo coloco en la raíz de mi servidor en ubuntu, es una burda copia del archivo index.php de WAMP pero, modificado XD Es de mucha ayuda para saber cuales son las extensiones que se han instalado y que han sido cargadas exitosamente así como de proveerme una forma fácil de acceder a todos mis proyectos y se ve más o menos así:

Bye guys! Happy code!

Buenas Prácticas de Desarrollo Web en PHP

Me gustaría recomendarles algunas cosas a las personas que desarrollan con PHP:

1.- No utilicen las etiquetas cortas de PHP. Si lo hacen tendran que lidiar con que su código no sea portable. Las etiquetas de PHP son

<?php \\Here your code; ?>

1.1 Desde PHP5.4 se activa por defecto la etiqueta corta para impresión de variables ya que esta caracterítica ya no depende de la opción short_open_tag:

<?= $fooVar ?>

De resto, si no utilizas PHP5.4 o superior, utiliza la forma no abreviada:

<?php echo $fooVar; ?>

2.- En la Vista, así vayan a imprimir una variable terminen siempre la línea de código  con punto y coma (;).

3.- Si no utilizan un framework como Symfony2 y necesitan hacer uso de los “require_once” utilicen url absolutas como argumento a esta función.

Ejemplo:

    require_once($_SERVER['DOCUMEN_ROOT'].
                 DIRECTORY_SEPARATOR.
                 'modelo'.
                 DIRECTORY_SEPARATOR.
                 'usuarios.php');

// Esta es una opción. Hay muchas formas de obtener url absolutas.

4.- Utilicen por favoooooor en lo posible, programación orientada a objetos (POO) y no mezclen su código POO con programación estructurada.

5.- Si van a imprimir una cadena de texto que no posee dentro ninguna variable coloque esa cadena de texto entre comillas simples, esto hace que su código sea más óptimo.

6.- Utilicen por favooooor en lo posible, el patrón de diseño Modelo, Vista, Controlador (MVC) bien hecho. Con esto quiero decir:

6.1.- El modelo es la única sección del programa que debe contener código de consultas a base de datos o webservices. No debe haber nunca un “SELECT, INSERT, UPDATE…” a la base de datos en medio de un código HTML (Vista)

6.2.- La vista solo debe contener eso mismo vista, código de interfáz gráfica de usuario. es decir solo HTML5, importaciones de archivos javascript y css3. Con respecto al código PHP que es esta debe de llevar, solo de llevar impresiones de variables y solo lógica de bucles o pocas validaciones.

6.3.- El controlador es el que maneja todas las peticiones. Les recomiendo que tengan un controlador frontal y que este llame a los verdaderos controladores de acuerdo al recurso que se esté requiriendo por parte de usuario mediante una petición ya sea GET, POST o incluso GET y POST mediante AJAX.

6.4.- Para interactividad javascript de la vista, utilicen solo una librería de javascript. Les recomiendo jQuery. ¿Qué no puede hacer jQuery?.

6.5.- Para los estilos de la vista, utilicen responsive design, la forma más fácil de hacer esto es, usando “twitter bootstrap”.

7.- Empiecen a hacer uso de los namespaces en PHP.

8.- Si quieren evitarse problemas, utilicen un framework serio como Symfony2 o Yii. No framework que te hacen trabajar doble como Cake, CodeIgniter entre otros…

9.- En cuanto a los editores, déjenle Dreamweaver a los diseñadores y a los noobs, los programadores, usamos Netbeans, (Si tienes una buena pc), ZendStudio For PHP y PHPStorm(Si tienes una buena pc y tienes Real), TextMate(Para mac), SublimeText2 (El mejor), boten si lo tienen, eclipse entre otras porquerias derivadas que hay por allí.

10.- Si utilizan SublimeText2 no se olviden de instalar el Package Control. Esto les permitirá instalar nuevos temas, snippets (ayuda de generación de código y autocompletado) y otros plugins.

11.- Si utilizan ajax con jquery no utilicen la función $.post ni $.get lo recomiendan los que más saben, además la función $.ajax te da mucha más flexibilidad para efectuar una petición XMLHTTPRequest. Utilicen $.ajax(); Ejemplo:

$.ajax({
    type: "POST",
    dataType: "html",
    data: mis_datos_serializados,
    url: url_controller,
    success: function(datos){
        $("#"+div_string).html(datos).fadeIn("slow");
    }
});

12.- Por el amor a sus padres, hagan uso del control de versiones. Les recomiendo GIT.

13.- Definan las variables antes de utilizarlas, así sea con null, pero, definanlas primero antes de imprimirlas, asignarlas, o pasarlas como argumento a algún método o función PHP…

14.- Documenten el puto código.

15.- El más importante, SEAMOS HUMILDES, ACEPTEMOS CRÍTICAS y ERRORES PROPIOS. SOMOS HUMANOS. APRENDEMOS, EJECUTAMOS,  ERRAMOS, RECTIFICAMOS y SOLUCIONAMOS. Humildad ante todo.

Variables útiles de PHP -> http://tednologia.com/10-utiles-variables-de-servidor-en-php/

jQuery, Framework Javascript -> http://jquery.com/

Twitter Bootstrap -> http://twitter.github.com/bootstrap/

Instalacion de PHPUnit en Wamp (Windows PHP)

WampServer

En esta guía de instalación de PHPUnit utilizaremos la plataforma WAMP 2.2 (Apache2.2.22, PHP5.4.3) 32bits.

Antes de todo estoy suponiendo que ya tenemos añadido en la variables de entorno PATH de Windows nuestro directorio de instalación de PHP. En mi caso C:\wamp\bin\php\php5.4.3. Aunque si no lo tenemos, abrimos nuestra consola de Windows y ejecutamos el siguiente comando:

> set PATH=%PATH%;C:\wamp\bin\php\php5.4.3

Esto nos permitirá ejecutar a través de la consola de Windows el comando “php” desde cualquier contexto (directorio).

Primeramente debemos instalar PEAR. A pesar de que existen otras opciones para instalar paquetes de PHP (En nuestro caso PHPUnit) como Composer, son muchas las personas que instan a utilizar la instalación por medio de PEAR. Los expertos me comentaran cuales son las diferencias.

Por ahora, instalemos PEAR:

1.- Descarguemos el archivo go-pear.phar, particularmente yo, lo he colocado en el directorio C:\wamp\bin\php\php5.4.3

2.- Abrimos la consola de Windows como Administrador. Importante! como Administrador.

3.- Estando en la consola de Windows como Administrador. Ejecutamos los siguientes comandos:

> cd /wamp/bin/php/php5.4.3
> php go-pear.phar

4.- A partir de este momento podremos utilizar el comando “pear” en la consola. Confirmemos la instalación ejecutando:

> pear

Esto debe desplegarnos todas las funciones de este manejador de bibliotecas de PHP (PEAR).

Primera forma para Instalar PHPUnit con PEAR

Ejecutamos los siguientes comando en la consola:

> pear config-set auto_discover 1
> pear install pear.phpunit.de/PHPUnit

Segunda forma para Instalar PHPUnit con PEAR

Si no nos funciona por alguna cuestión (que suele pasar) la primera forma para instalar PHPUnit con PEAR. Podemos instalarla de esta segunda forma. Ejecutamos los siguientes comando en la consola para añadir los canales:

> pear clear-cache
> pear channel-update pear.php.net
> pear upgrade-all
> pear channel-discover components.ez.no 
> pear channel-discover pear.phpunit.de 
> pear channel-discover pear.symfony-project.com 
> pear channel-discover pear.symfony.com

Luego ejecutamos el comando de instalación de PHPUnit:

> pear clear-cache
> pear install --alldeps --force phpunit/PHPUnit

A partir de este momento podremos utilizar el comando “phpunit” en la consola. Confimemos la instalación ejecutando:

> phpunit --version

En el momento que escribí este articulo la respuesta al comando anterior fue la siguiente:

PHPUnit 3.7.13 by Sebastian Bergmann.

Instalación de PHPUnit con Composer

La alternativa más actual es realizar la instalación con composer. Les dejo un link para que puedan ver cómo se hace:

http://www.phpunit.de/manual/current/en/installation.html#installation.composer

¿Qué podemos esperar de la Internet en un futuro?

Son muchas las tecnologías que están mejorando hoy la web, y es necesario tomar en cuenta que estas tecnologías nacen de la demanda actual de este servicio que se ha convertido en una necesidad.

Por ejemplo:

Hoy en día el servicio de internet movil está muy demandado lo que ha requerido que los equipos de datos móviles de nuestros proveedores de servicio soporten mayor ancho de banda y por otra parte los diseñadores web ha tenido que pensar en la variedad de dispositivos móviles, variedad de resoluciones en la que se debe mostrar una página web y además tomar en cuenta el poco ancho de banda que porporciona la red móvil de datos y hacer una web vistosa pero, a la vez rápida y que pese muy poco kbytes, estás exigencias han dado lugar a tecnologías como CSS3, HTML5, Responsive Design, Utilización de Frameworks de Desarrollo tanto del lado del cliente como del lado del servidor.

Del lado del servidor ya se buscan tecnologías que puedan soportar conexiones concurrentes sin desmejorar el tiempo de respuesta al cliente de estos requerimientos han surgido tecnologías como:

NodeJs: Javascript del lado del Servidor basado en el Motor V8 de Javascript de Google Chrome. Puede poseer una alta concurrencia muy por encima  a cualquier otra tecnología web sin ver Posee frameworks de desarrollo como Railsway que dan mucha agilidad a desarrollos web basados en este lenguaje y tecnología joven pero, madura a la vez.

NGineX: Servidor web para PHP interesante alternativa a Apache. Mejora los tiempos de respuesta de las páginas hechas en PHP con respecto a Apache por su posibilidad de multiprocesos, se espera que Apache 3 pueda llegar al performace de este servidor web. http://usemoslinux.blogspot.com/2012/06/nginx-una-interesante-alternativa.html

APC y PHP: Manejo de Cache para PHP, mejorando el tiempo de respuesta del lado del servidor, no viene por defecto con la distribución de PHP5. Según algunas se espera que esta librería (APC) entre en la distribución oficial de PHP6. Quién sabe si quiera cuándo saquen PHP6, mientras la podemos agregar como una extensión más de este famoso lenguaje de programación.

Python y Django: Alternativas al conjunto PHP-Symfony2. Al parecer mejoran el performance un poco con respecto a otras tecnologías web. Pero, lo que sí mejoran por mucho son los tiempos de desarrollo de aplicaciones y portales web gracias a la facilidad y agilidad con la que se desarrolla haciendo uso del lenguaje Python y de su framework Django.

Flash adios, Bienvenido CSS3: Son menos las webs que poseen animaciones flash (pesadas y hacen dependiente tu aplicación del navegador y de plugins como flash player) y son más las que empiezan a utilizar animaciones mediante los estándares de CSS3 y HTML5.

Además también hay que tomar en cuenta la red que nos provee de internet:

Cada día son más las corporaciones que proveen servicios de internet quienes tomando en cuenta la demanda de información (ancho de banda) de sus usuarios están cambiando toda su red de transmisión de cobre a fibra óptica, lo que supondría una mejora muy sustancial en este preciado servicio.

BPMN

BPMN

Notación de Modelaje de Procesos de Negocios (BPMN) es una notación gráfica estandarizada que permite el modelado de procesos de negocio, en un formato de flujo de trabajo. Su principal objetivo es, Resolver las dificultades de comunicación que tiene el lenguaje común a través de que el mismo

  • Proporciona un método normalizado para representar procesos de negocios.
  • Facilita su entendimiento debido a la poca complejidad de su notación.
  • Proporciona un lenguaje común entre los usuarios de negocio y los técnicos.
  • Facilita la diagramación de los procesos de negocio.

Actualmente hay una amplia variedad de lenguajes, herramientas y metodologías para el modelado de procesos de negocio. La adopción cada vez mayor de la notación BPMN como estándar ayudará a unificar la expresión de conceptos básicos de procesos de negocio (por ejemplo procesos públicos y privados, orquestación, coreografía, etc.) así como conceptos avanzados de modelado (por ejemplo manejo de excepciones, compensación de transacciones, modelado de toma de decisiones, entre otros).

Se hace cada vez más importante en este mundo globalizado con procesos cada vez más complejos el poder llevar a cabo la administración o gestión de los procesos de negocio además de hacerlo en un lenguaje o notación entendible por toda la organización, es por esto que la BPMI creo la versión 1.2 de BPMN y cada vez es más fácil ir viendo aplicaciones de la notación de modelado de procesos de negocio en su versión 2.0 actualmente mantenida por la OMG. Y es con el fin de agilizar la definición y posterior automatización de los procesos de negocios basados en la arquitectura orientada a servicios que el estudio y aplicación de BPMN se hace cada vez más una necesidad para las grandes organizaciones ya que le da flexibilidad, agilidad y capacidad de respuesta a la misma.

Algunas tecnologías detrás de la Internet

Al hablar de las tenologías que se unen para hacer vivir la internet es inevitable hablar de modelo OSI.

En cuanto a la capa física, la capa más baja de la internet se encuentran protocolos y tecnologías que nos permite primeramente conectarnos a la internet y definir los medios de trasmisión de la información que carguemos a la web o descarguemos de esta, algunos de estos son los pares trensado RS232, cables coaxiales, fibra óptica potenciada con tecnologías de alta velocidad como DWDM, Medios inalambricos por radio frecuencia e incluso Medios Satelitales se pueden apreciar en esta capa 1.

Luego de estar conectados a internet nuestro dispositivo terminal (PC) debe ser reconocido en la red física, por lo que se hacen necesarias tecnologías cubiertas en la capa 2 del modelo OSI, la capa de enlace de datos, donde se encuentra el protocolo MAC que permite el direccionamiento físico de tramas (unidad de información de esta capa) una de las funciones de esta capa además de detección de errores, acceso al medio, control de flujo… La MAC o Dirección MAC se encuentra en nuestra tarjeta de red y el cual además de ser un identificador único en toda la red, no es dinámico como si lo pudiera ser una IP.

La Capa de Red se encarga primordialmente del direccionamiento lógico y lo hace mediante el manejo del protocolo más conocido de la internet IP. En esta tercera capa sobre el protocolo IP operan una gran cantidad de protocolos de direccionamiento que se encargan de buscar la mejor via para el envio y recepción de paquetes (unidad de información de esta capa). Alguno de los protocolos utilizados para el enrutamiento entre redes que cumplan con las mismas características o redes autónomas son el protocolo OSPF (estándar abierto con gran cantidad de funcionalidades y configuraciones) y IGRP/EIGRP (protocolos propietarios de Cisco, vale acotar que más inteligentes y con mayor sencillez de implementación sin importar la tipología de red). Pero, como estamos hablando de red de redes (la internet) se deben comunicar muchas redes de características y topologías y con uso de protocolos distintos, sin embargo debe haber un protocolo que pueda comunicar todas estas redes y enrutar la información alojada en la ineternet de un origen a un destino sin importar estas adversidades, este protocolo es el llamado BGP (Border Gateway Protocol) el cual es un protocolo  mediante el cual se intercambia información de enrutamiento entre sistemas autónomos distintos. Cada uno de estos protocolos seleccionan la mejor ruta de acuerdo a ciertos criterios como: topología de la red, congestion de la red, cantidad de saltos entre enrutadores de un origen a un destino, compatibilidad, sencillez de implementación, entre otros.

IP es un protocolo que solo se encarga de seleccionar la ruta para enviar la información y no le importa si esta llega o si llega de forma correcta y ordenada o no, por lo que debe trabajar en conjunto con la cuarta capa o Capa de Transporte donde se encuentran los protocolos que se encargan de las tareas del transporte de la información como lo son TCP y UDP. El primero de ellos (TCP) es ampliamente utilizado en el envio de datos cuando no importa que exista un delay en la recepción de la información sino la seguridad de que los datos llegaran correctamente ya que este hace una verificación de cada paquete cuando es enviado y cuando es recibido (poniendo en juego el ancho de banda), para aplicaciones de telecomunicaciones como Teleconferencias, VoIP, Video Streaming en vivo, donde la comunicación (envio de paquetes) debe ser casi instantanea y el uso del ancho de banda debe ser los más óptimo posible se puede hacer uso de protocolos como UDP.

La Capa 5, Capa de Sesión, se encarga de la adminisracion y establecimiento de sesión entre el origen y el destino La capa de sesión decide si va a utilizar la conversación simultanea de dos vías o la comunicación alternada de dos vías. Esta decisión se conoce como control de dialogo. En esta capa se hacen presentes protocolos como AppleTalk (protocolo de conexión propietario de Apple).

Por otra parte, una vez establecida una sesión tanto el origen como el destino deben ponerse de acuerdo en qué lenguaje hablar para así entenderse, de esta forma se hace necesaria la capa de presentación la cual tiene como función entre otras cosas, la codificación y conversión de datos de la capa de aplicación para garantizar que los datos del dispositivo de origen puedan    ser interpretados por la aplicación adecuada en el dispositivo de destino, compresión de los datos de forma que puedan ser descomprimidos por el dispositivo de destino, encriptaciónde los datos para transmisión y descifre de los datos cuando se reciben en el destino. Los estándares de la Capa 6 OSI también determinan la presentación de las imágenes gráficas. En esta capa se encuentran estándares de sonido, imágen y archivos como JPEG, MP3, GIF, OGG, ZIP, TAR… entre otros.

La última capa del modelo OSI es la que interactuamos más comúnmente. La capa de Aplicación es la capa que proporciona la interfaz entre las aplicaciones que utilizamos para comunicarnos y la red subyacente en la cual se transmiten los mensajes. Los protocolos de capa de aplicación se utilizan para intercambiar los datos entre los programas que se ejecutan en los hosts de origen y destino. En esta capa podemos conseguir protocolos, aplicaciones y servicios como HTTP, HTTPS, FTP, FTPS, NFS, RPC (Remote Procedure Call), Terminales, entre otros.

Es necesario también recordar que existen otras tecnologías como las tecnologías de desarrollo de software que hacen posible que los servicios prestados en la capa de aplicación se puedan dar. Entre las tecnologías y/o lenguajes más utilizados en el desarrollo de aplicaciones web se encuentran: HTML5, CSS3, Javascript, AJAX, PHP5, JEE, .NET Framework, Perl, Ruby…

Es importante ver que cada una de estas tecnologías son necesarias para que pueda existir la internet y quea medida que se sigan estandarizando los protocolos utilizados en cada una de las capas de comunicación se verán beneficiados los ISP (proveedores de servicio de internet) al poder implementar redes menos complejas, más mantenibles y menos propensa a errores, beneficiandonos a nosotros como usuarios finales de internet.

Fuentes:

http://www.guillesql.es/Articulos/Manual_Cisco_CCNA_Protocolos_Enrutamiento.aspx

http://eltallerdelbit.com/

http://www.tufuncion.com/ventajas-ajax

Decreto 3390 Apoyo del Estado al SL

Desligar la política de las consecuencias sociales y económicas que traen sus acciones sobre un país es algo imposible. En muchos paises como en Venezuela se ha impulsado el uso de software libre porque concuerda ampliamente con el ética socialista y ha contado ampliamente con el apoyo de un gobierno que cree en estos valores. El software libre nacio bajo ciertos principios y valores que son de cierto modo antagónico con el sistema económico e ideológico del capitalismo. Sin embargo gran parte de las comunidades de Software Libre han tratado en lo posible de desligar esto de la política (cosa también bastante difícil) por los mismos motivos.

Me gusta mucho la última frase:

“…EL PEOR ANALFABETO, ES EL ANALFABETO POLITICO, ES QUIEN HACE POSIBLE LA MISERIA, LA PROSTITUCION, LA IGNORANCIA, LA MENTIRA, EL ROBO… Esto lo dijo en su momento Bertold Brecht, no olvidemos que en Nuestro nombre, los politicos del regimen capitalista, hacen y deshacen segun los intereses de los grandes capitales. ”

En Venezuela el 28 de diciembre del 2004 se ha tomado como un asunto de importancia nacional y de caracter de estado la adopción de tecnologías de información y estándares libres como prioridad mediante el conocido decreto 3390.

Principales ventajas del Decreto 3390:

1. será un Programa de computación cuya licencia le garantizara   al usuario: el acceso al código de fuente,   modificarlo y retribuirlo   tantas veces desee.
2. la adopción del Software Libre desarrollado con Estándares Abiertos, facilitará la interoperabilidad de los sistemas de información del Estado.
3. tendrá calidad de servicio y mejoramiento en sistema y con menos costo.
4. Ahora con este decreto los usuarios podrán tener mayor participación con el mantenimiento de los niveles de seguridad de los software.
5. también se deberán implantar mecanismos que preserven la identidad y necesidades culturales del país, incluyendo a sus grupos indígenas, para lo cual procurará que los sistemas operativos y aplicaciones que se desarrollen se adecuen a su cultura.
6. se creara una red de formación de servicios especializados con estándar abierto para los desarrolladores.

Algunas desventajas que algunos pesimistas suelen encontrar en la adopción del software libre y el cumplimiento del decreto 3390:

1. El Software Libre es mas complejo de manejar para la mayoria de los usuarios, ya que se necesita tener conocimientos de programación para solventar problemas
2. Para entender el código fuente los usuarios deben tener conocimientos informáticos en el área de programación y sistemas
3. No todos los Software Libre son de licencia gratuita
4. No todos los usuarios venezolanos migran a Software Libre, ya que existe dependencia por la facilidad de manejo de los Software Propietario.
5. No todas las personas se interesa por el aprendizaje y uso del Software Libre.