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

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.

Cita

Software Libre vs Software Propietario “La lucha por la independencia”

Al revisar en la red y otras publicaciones nos encontramos muchas partes donde se dice que el Software Libre y el Conocimiento Libre encajan perfectamente dentro de los conceptos del Capitalismo, por la mísma razón que el “Libre Mercado” lo hace. La libertad de los mercados nos es así “Libre” como la definen. Los mercados dependen del concepto de escasez. Cuando al Software Libre, Conocimiento Libre e Investigación Libre, se está trabajando contra el concepto de escasez y se está eliminando donde definitivamente no es necesaria. Cualquier persona puede beneficiarse del Software y del Conocimiento, puede mejorarlo y todo el mundo está autorizado a copiarlo.

Teniendo conocimiento de la cuatro libertades que debe cumplir el Software Libre, es necesario revisar el problema de la industria informática bajo el capitalismo. La forma en que funciona la industria informática de hoy es un ejemplo perfecto de todas las fallas e ineficiencias masivas del capitalismo, donde el objetivo principal no es servir a los intereses de la sociedad. Desarrollar, mejorar y distribuir el software se lleva a cabo solo cuando cuando se pueden obtener grandes beneficios. Esto está en agudo contraste con el software libre donde se utiliza el conocimiento humano y el producto del trabajo humano en beneficio de toda la sociedad.

El tema que trata de programas informáticos puede resultar un poco abstracto para algunos lectores, pero, es un tema relevante para todo aquel que utiliza una computadora. Debemos preocuparnos de la forma en que la industria de la computación nos impone severas restricciones a los que usamos sus productos, ya que es posible que algún día no se nos permita escuchar música en mp3 o leer documentos en MSWord. Se puede pensar que podemos seguir con estas tareas por siempre, porque creemos que realmente poseemos y controlamos la mayor parte de lo que está almacenado en el computador. Sin embargo, de acuerdo a las grandes empresas de software este no es el caso.

No somos dueños de esa copia de MSWord, el juego de video o incluso un reproductor mp3, de la misma manera en que las mayoría de las personas utilizan software comercial (sea pirata o pagado), no son propietarios de ninguna manera de acceso a la información. hay que entender sin embargo lo que significa un licencia de Software.

Una licencia de Software es una forma de contrato que se ha convertido en la forma más común de distribución de programas hoy en dia. Cuando se instala un nuevo programa en la computadora, debemos hacer click en un “Acepto”, un “Ok” o algo por el estilo de esta manera estamos firmando un contrato que probablemente nunca hemos leido. La mayoría de estas licencias son cerradas, es decir, que cuando compramos legalmente una copia de Windows 7 o Word, no está permitido pasarle una copia a los amigos ni podemos hacer modificaciones en el software. Cuando la gente dice “Voy comprar Photoshop” en realidad están diciendo “Voy a comprar una licencia para ejecutar una copia de Photoshop”.

El software antes mencionado es un Software Propietario. El software libre representa una ruptura fundamental con el modelo cerrado. Se necesita todavía obtener una licencia para softwar libre, pero, al mismo tiempo da más poder al usuario para hacer copias y modificarlo. El producto software en si, no es visto como un bien privado sino como un recurso público.

La verdadera importancia del modelo de software libre está lejos de ser desligada de la política. Miles de programadores en todo el mundo trabajan juntos en un proyecto común y comparten su código informático con el fin de confeccionar un buen producto que todo el mundo pueda ser capaz de utilizar. Esto demuestra que en la práctica incluso en este mundo capitalista es posible colaborar en vez de estar en competencia unos con otros y que es un mito de las personas solo van a hacer las cosas por dinero o con fines de lucro.

Las grandes empresas utilizan su control monopólico para imponer estándares de facto, en sí mismo el estánddar o normalización es positivo, de esta manera los equipos utilizan los mismos formatos para que los documentos, archivos de audio entre otros se pueden intercambiar sin problemas. El aspecto negativo de este tipo de normas utilizan estos mismos estándares propietarios para reforzar aún más su monopolio. Una parte importante de la economía mundial depende ahora de estas norma (Documentos de MSWord, es un buen ejemplo).

Aquí es donde la tecnología se convierte en política. El único poder que es capaz de promover de manera efectiva los estándares abiertos y software libre en general es un poder político. Ahora el problema es que muchos proyectos de código abiertos son más bien de voluntarios y no terminan en ninguna parte debido a la falta de financiamiento.

La solución al conflicto actual en el mundo de la informática no es convencer a todos de cambiar a los sistemas operativos linux, aunque sería un paso en la dirección correcta. El software libre debe ser un “Germen” de una nueva sociedad. Para que el nuevo concepto se situe en una posición privilegiada, la sociedad tiene que cambiar. Tenemos que cambiar el modo de producción capitalista y sustituirlo por uno soscialista.

Luis Arguello

Software Libre vs Softwar…

Clasificación de Licencias de Software Libre

En Wikipedia se puede encontrar que todas estas licencias de Software Libre también tienen una clasificación.

1.- Según los derechos del autor, se encuentran las siguientes:

A.- Licencias de Código Abierto Permisivas: Se caracterizan por permitir crear una derivación de una obra de Software Libre sin que esta derivación tenga la obligación de protección alguna. Algunas de las que entran en esta clasificación son:

BSD License.

W3C Software Notice and License.

Open LDAP License v.2.7

Perl License.

Python License v.2.1

PHP License v.3.0

B.- Licencias de Código Abierto Robustas: Establece algunas restricciones sobre las obras derivadas. Y a su vez se divide en dos subconjuntos:

B.1.- Fuertes: Conocidas como Copyleft Fuertes. Establecen que toda derivación o modificación del software original que posea estas licencias debe licenciarse bajo los mismos términos y condiciones de la licencia original. Algunas de estas son:

GNU General Public License v.2.0.

GNU General Public License v.3.0.

Eclipse Public License.

OpenSSL License.

B.2.- Débiles: Conocidas como Copyleft Débiles o Híbridas. Permite que las obras derivadas de modificaciones o derivaciones de un software original puede no cumplir con los términos y condiciones de la licencia original. Algunas de estas son:

GNU Lesser General Public License v.2.1.

Mozilla Public License

Open Source License.

Apple Source License v.2.0

2.- Según el destinatario, se pueden encontrar dos tipos de licencias:

A.- Licencia de Usuario Final: “… Este tipo de acuerdo expresa los usos qué se pueden dar y cuáles no al producto, ya que quien lo compra no es, legalmente, en ninguna forma dueño del producto, sino sólo de una licencia para su uso, considerándose esto último por algunas personas como una limitación a los derechos del consumidor…” Fuente

B.- Licencia de Distribuidor: “… En este tipo de contrato, se le asigna derechos restringidos a un comerciante de tipo comisionario para que venda el producto(software) dando una remesa o comisión al fabricante. La misma puede ser por primera venta o licencia de renovación de contrato…” Fuente

Configurando WAMP para Symfony2

Symfony2 es hoy en día (a opinión muy personal) el mejor framework de desarrollo web en PHP5. Te permite gran cantidad de formas de explotar tu imaginación como programador y aún diseñador, eso sí, siempre con una estructura y un patrón de diseño ordenado y definido. Sin embargo, el objetivo central de este tema es el de aprender a configurar Symfony2 en tu máquina con Sistema Operativo Windows (XP, Vista, 7…) Y no me gustaría repetir la documentación que ya es muy basta aún en lenguaje español por lo que recomiendo algunos links para ahondar más en temas de Symfony2:

Primeras Impresiones con Symfony2: El compañero Alberto Varela nos cuenta acerca de sus primeras impresiones con Symfony2. Es bueno leerlo antes que cualquier otro. A mí me sirvió mucho para enamorarme de Symfony2. (Idioma: Español).

Symfony2 Official: La página Oficial de Symfony2. La documentación Oficial (Documentation) donde encontraremos el libro de este maravilloso framework (The Book) así como muchas recetas de actividades específicas (Cookbook) que nos permite realizar Symfony2 se consiguen en esta página. Y obviamente, además el código necesario para comenzar un proyecto con Symfony2 (Downloads). (Idioma: Inglés).

Symfony2 GitHub: Un Gran Aporte a la comunidad de Habla Hispana por parte del compañero Nacho Pacheco. Esta página contiene la traducción a nuestro rico idioma el Español, de la Documentación Oficial de Symfony2. (Idioma: Español).

Symfony.es: Para mí la mejor página con respecto a noticias y tópicos nuevos así como sitio de referencia de Symfony en todas sus versiones y bueno, hoy en día de lleno con Symfony2. Esta página fué creada por un gran desarrollador y gran conocedor del framework Javier Eguiluz. (Idioma: Español)

DeSymfony: Página Oficial de “La conferencia hispana más importante sobre Symfony y la segunda a nivel mundial.” como se define ella misma. La próxima 15 y 16 de junio de 2012 en La Universidad Jaume I, Castellón (España). Venezuela estará representada por un muy buen ponente y conocedor del framework Symfony Albert Jessurum. (Idioma: Español).

Desarollo Web Ágil con Symfony2: El mejor libro de Desarrollo de Symfony2 en Español. Para mí fue un problema comprarlo, sin embargo, pude hacerlo gracias a unos amigos de amigos que viven en España. Es un libro muy barato para lo completo que es. Ah y fue escrito por, adivinen quien? Sí, ese mismo Javier Eguiluz. (Idioma: Español).

Symblog: Tutorial paso a paso de cómo hacer una aplicación sencilla (un Blog) con Symfony2 llamada Symblog. (Idioma: Inglés).

La Instalación de todo lo necesario para trabajar con Symfony2 y WAMP 2.2 o mayor

Ahora sí, vamos con el verdadero tema de este post, la configuración de WAMP para poder correr nuestros proyectos con Symfony2. Por si a las moscas, hago un paréntesis, yo uso sistema operativo es Ubuntu 10.04 y eventualmente Windows 7. En cuanto editores, recomiendo NetBeans 7.1.1 e instalar los plugins de Twig y Symfony2. Sin embargo si quieren un editor ligero y sin complicaciones les recomiendo Sublime Text 2. Todos estos editores están en plataforma Linux y Windows así como Mac OS.

1.- Bueno, lo primero que demos hacer es Descargar WAMP 2.2. Lo instalamos en nuestra máquina con Windows.

2.- Descargar Symfony 2.0 (Edición Standard) y descomprimir los archivos en la carpeta raíz de nuestro sitio web, regularmente C:\wamp\www Al tener el WampServer levantado y al abrir el navegador e ir a http://localhost/Symfony/web/config.php Debemos ver algo asi:

3.- Nos recomendará que habilitemos las librerías de internacionalización “INTL” (php_intl.dll). En esta versión de Wamp solo nos toca activar esta librería ya sea por el menú de Wamp o descomentando (quitando el ;) al inicio de la línea de las extensiones donde se encuentre extension = php_intl.dll de los archivos php.ini ubicados enC:\wamp\bin\php\php5.3.8\ y en C:\wamp\bin\apache\Apache2.2.21\bin. Esto no tiene mayor problema.

4.- Por otra parte, nos exige el instalar y habilitar la librería de manejo y aceleración de carga y cache para PHP “APC” (php_apc.dll). Para esto debes primero descargar esta librería desde este link php_apc-3.1.5-5.3-vc9-x86.zip

4.1.- Debemos descomprimir el archivo  “php_apc-3.1.5-5.3-vc9-x86.zip” en el directorio de ext de PHP de tu instalación de WAMP en mi caso el directorio donde está es este: “C:\wamp\bin\php\php5.3.8\ext”.

4.2.- Luego en los archivos php.ini ubicados en C:\wamp\bin\php\php5.3.8\ y en C:\wamp\bin\apache\Apache2.2.21\bin agregar la siguiente línea de código “extension=php_apc.dll”.

Los archivos php.ini deben quedar de esta forma:

extension=php_apc.dll
...
extension=php_intl.dll
...
extension=php_mysql.dll
extension=php_mysqli.dll
...
extension=php_pdo_sqlite.dll
...
extension=php_sqlite3.dll
...
Nashville Symfony

Nashville Symfony (Photo credit: stephenyeargin)

5.- Lo que nos queda es reiniciar el WampServer y listo, tendremos nuestro Wamp configurado para correr nuestra aplicaciones con Symfony2. Entramos de nuevo a la dirección URL http://localhost/Symfony/web/config.php para verificar esto y debemos obtener esta página:



6.- Una vez instalado para poder ejecutar comando por la consola de Windows, necesitamos añadir php a los registros del sistema operativo o pueden hacer como yo,  crear un archivo llamado php.bat colocarlo en C:/windows/system32 para poder ejecutar por consola los comando de Symfony2. No deben olvidar de modificar los archivos php.ini que están en el directorio bin de php (C:\wamp\bin\php\php5.3.8) que aunque wamp no los utiliza estos comandos de symfony2 si los utilizarán. Este archivo php.bat debe tener lo siguiente en su interior

@echo off

rem *************************************************************
rem ** php CLI for Windows based systems (based on phing.bat)
rem *************************************************************

rem This script will do the following:
rem - check for PHP_COMMAND env, if found, use it.
rem - if not found detect php, if found use it, otherwise err and terminate

if "%OS%"=="Windows_NT" @setlocal

rem %~dp0 is expanded pathname of the current script under NT
set SCRIPT_DIR=C:\wamp\bin\php\php5.3.8\
set PHP_COMMAND=C:\wamp\bin\php\php5.3.8\

goto init

:init

IF EXIST ".\php.exe" (
%PHP_COMMAND% ".\php.exe" %*
) ELSE (
"%SCRIPT_DIR%\php.exe" %*
)
goto cleanup:cleanup
if "%OS%"=="Windows_NT" @endlocal
rem pause

Podemos también agregar a “php” a nuestras variables de entorno y así utilizarlo fácilmente desde la linea de comandos ejecutando el siguienete comando en nuestra terminal de Windows:

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

Sustituyendo obviamente la dirección por la ubicación donde ustedes tengan php instalado y con las modificaciones que hemos hecho en el php.ini ya realizadas. Por otra parte, si vamos a desarrollar con Symfony2 es necesario para cualquier versión que tengamos instalado el manejador de versiones git, por cierto una vez que lo hayamos instalado también podemos añadirlo a nuestras variables de entorno para que se pueda ejecutar desde nuestra línea de comandos de windows sin problemas ejecutando el mismo comando en la terminal colocando a la variable de entorno PATH la dirección del directorio /bin de nuestra instalación de git, por ejemplo sería algo así:

set PATH=%PATH%;C:\Program Files\Git\bin

Espero esto pueda ayudarnos a todos los que queramos usar Wamp para nuestras pruebas con aplicaciones web php con el framework Symfony2.

Referencias:

http://www.leccionespracticas.com/php/instalacion-de-symfony2-en-wamp-con-php5-3-extension-intl-y-acelerador-acp-resuelto/