» Publishers, Monetize your RSS feeds with FeedShow: More infos (Show/Hide Ads)
No es un misterio que la gran mayoría de los problemas de seguridad comienzan por errores de los mismos usuarios. Uno de estos errores más comunes es la generación de claves débiles o fáciles de adivinar.
Para que generes claves confiables y seguras existe una pequeña aplicación de linea de comandos en Linux: pwgen
Lo primero que hacemos es instalar el programa:
apt-get install pwgen (si estamos en un sistema Debian o derivado como Ubuntu)
Una vez instalado ya podemos generar nuestra primera clave. Vamos a la linea de comandos y ejecutamos:
pwgen -1
En mi caso obtuve la clave: “ogie9Ahl”, bastante segura ¿no?. Pero eso no es todo, veamos algunas opciones que nos entrega el programa:
- -c: Incluye al menos una letra mayúscula en la clave a generar
- -A: No incluye letras mayúsculas
- -n: Incluye al menos un número
- -0: No incluye números
- -y: Incluye al menos un símbolo en la clave
- -1: No muestra las claves en columnas (por defecto muestra grupos de claves en columnas)
- -v: No utiliza vocales con el fin de evitar que se generen por accidente palabras desagradables
Por ejemplo con el comando:
pwgen -cny1v
… obtuve la clave: ^N-#6RZ,
Ahora necesito una aplicación que me ayude a recordar esas claves 
Entradas Relacionadas
Google ha liberado una herramienta muy interesante para la optimización de código Javascript: “Closure compiler”.
Para utilizar esta herramienta sigue estos pasos:
1. Accede a la herramienta Closure compiler
2. Por defecto el programa te muestra una función para que pruebes como se realiza la optimización:
3. Presiona “Compile” para que veas como funciona:
4. Podrás ver como se reduce el tamaño del script, lo cual se consigue eliminando comentarios, espacios y renombrando símbolos.
Entradas Relacionadas
He estado probando Mandriva 2010 y como siempre me parece que es la mejor distribución para un nuevo usuario que viene desde Windows (incluso me parece mejor que Ubuntu y sus derivados).
Una de las alternativas que te da esta distribución es elegir entre el menú clásico de KDE o su nuevo menú llamado KickOff. A continuación unas capturas que muestran al menú clásico y el nuevo:
El menú clásico
Activando KickOff
El menú KickOff
Artículos Aleatorios
Lo que haremos hoy es agregar una nueva fuente a tu sistema de una manera muy sencilla. Pare esto usaremos una fuente que encontré en Internet que se parece a la que usa la selección de fútbol de Argentina en sus camisetas: la Pump Triline.
Para agregar una nueva fuente hacemos lo siguiente:
1. Creamos (si no existe) el directorio “.fonts” dentro de nuestro “home”. Nos quedará algo como: /home/tu_usuario/.fonts
Recuerda que los directorios que comienzan con un punto son ocultos. Para verlos vas al menú de Nautilus>”Ver”>”Mostrar archivos ocultos”
2. Dentro del directorio “.fonts” copias tu nueva fuente. En nuestro caso es: PumpTrilineDOT-Regular.otf
3. Listo!, ya puedes usarla para lo que quieras.
Entradas Relacionadas
- Por quinta vez, Red Hat ocupa el 1º lugar como Proveedor de Software en el Estudio de la revista CIO Insight. [alcancelibre.org]
- IBM’s Answer To Windows 7 Is Ubuntu Linux [slashdot.org]
- Red Hat passes Microsoft’s stock price, now what? [cio.com.au]
Entradas Relacionadas
MySQL Workbench es una belleza de programa si quieres diseñar bases de datos. Es fácil de usar, multiplataforma, con buen soporte y de código abierto, ¿qué más puedes pedir?.
Jugando con la opción “Reverse Engineer” de Workbench exporté este diseño de las tablas de Wordpress (click para agrandar):
Artículos Aleatorios
Para descargar un video de YouTube y pasarlo a formato mp3 basta con que sigas los siguientes pasos:
1. Instala youtube-dl
apt-get install youtube-dl
2. Descarga tu video con el siguiente comando:
youtube-dl http://url_del_video_en_youtube3. Este comando descargará el video en formato .flv, para pasarlo a mp3 descargas el conversor mmc desde aquí: http://www.miksoft.net/mobileMediaConverterDown.htm
Te recomiendo que en las opciones de mmc uses ‘Audio Frequency’ con un valor de 32000, para obtener mejores resultados.
Fuente: telenekos.wordpress.com
Artículos Aleatorios
La aplicación que nos ayuda a hacer capturas de pantalla en GNOME (”gnome-screenshots”) no sólo captura todo nuestro escritorio, también tiene características adicionales que nos permiten hacer cosas más interesantes.
Una de las opciones más conocidas es la captura de pantalla con un retraso de tiempo. Desde la línea de comandos ejecuta lo siguiente:
gnome-screenshot -d 3
Este comando tomará una captura de tu pantalla con un retraso de 3 segundos. Interesante, pero hay más. Ahora ejecuta lo siguiente:
gnome-screenshot -wCon la opción “-w” capturará sólo la pantalla que esté activa y nada más. Esto es muy útil cuando hacemos tutoriales y queremos capturar sólo la ventana de un programa.
Ahora prueba con lo siguiente:
gnome-screenshot -w -e shadow
Este comando capturará la ventana actual y le aplicará un efecto de sombra bastante elegante. Por ejemplo, capturé la ventana de la terminal con este efecto:
Si lo que quieres agregar es un borde a tu captura intenta lo siguiente (nota: los efectos funcionan sólo junto a la opción “-w”)
gnome-screenshot -w -e border
Por último, si quieres todas estas opciones en una linda interfaz gráfica de usuario, ejecuta:
gnome-screenshot -iCon la opción “-i” obtienes lo siguiente:
Artículos Aleatorios
- PHPAnywhere: editor PHP en línea fácil de usar y con múltiples funcionalidades.
- PHP Quick Profiler: es un pequeño programa que te entrega información sobre desempeño y comportamiento de tus aplicaciones PHP.
- Netbeans con soporte Symfony: Netbeans es un gran IDE y Symfony es un gran framework, por eso es tan bueno que el primero ofrezca soporte para el segundo
- The Underground PHP and Oracle Manual: manual desarrollado por la misma Oracle orientado a desarrolladores PHP.
- DeveloperWorks IBM: este portal es un muy buen lugar para encontrar tutoriales de alta calidad. Un ejemplo: Cloud computing with PHP, Part 1: Using Amazon S3 with the Zend Framework.
- Guía para instalar Drupal en Amazon EC2: una mezcla muy potente y flexible, seguro ya tienes en mente en que proyecto aplicar estas tecnologías.
- 7 Most Important PHP.INI Settings: así como con los 7 enanitos el punto séptimo de esta entrada la cierro con una lista de las 7 principales variables de configuración de PHP. Muy interesante.
7 Most Important PHP.INI Settings
Entradas Relacionadas
- Escándalo en Canadá: Derrochan 1.000 millones de dólares por no usar software OpenSource [noticiate.com]
- Linux recomendado para banca [muycomputer.com]
- La bolsa londinense migra de Windows a Linux [diarioti.com]
- Dell vuelve a ofrecer ordenadores con Linux preinstalado [barrapunto.com]
- Asus apuesta por Moblin, el SO de Linux [portatiles.es]
- Herramientas open source para crear una tienda [puertopixel.com]
- Recomiendan utilizar GNU/Linux para banca electrónica [alcancelibre.org]
Entradas Relacionadas
En la primera parte de esta serie vimos que son los frameworks, las razones para usar Zend Framework y, finalmente, analizamos como instalarlo. En este artículo crearemos nuestro primer proyecto. Vamos a eso.
Nota: se asume que conoces el Modelo Vista Controlador.
Nuestro Primer Proyecto
Zend Framework tiene una clase llamada “Bootstrap” que nos permite iniciar los recursos que utilizaremos en nuestro proyecto, la ubicación de esta clase es: /var/www/zf/primer-proyecto/application/Bootstrap.php.
Lo primero que haremos es agregar al Bootstrap la funcionalidad de autocarga de recursos:
// /var/www/zf/primer-proyecto/application/Bootstrap.php <?php class Bootstrap extends Zend_Application_Bootstrap_Bootstrap { protected function _initAutoload() { $moduleLoader = new Zend_Application_Module_Autoloader(array( 'namespace' => '', 'basePath' => APPLICATION_PATH)); return $moduleLoader; } }
En nuestras aplicaciones con Zend Framework tenemos controladores (controllers) y dentro de ellos existen acciones (actions), así si por ejemplo estuviéramos programando un blog y llamamos a: http://localhost/zf/primer-proyecto/public/entradas/agregar, el controlador sería “entradas” y la acción “agregar”.
Para nuestro proyecto inicial lo que haremos es un directorio de contactos, es decir, una aplicación simple que nos servirá para gestionar la información relacionada con las personas que conocemos. Como es un proyecto simple nos basta con trabajar con el controlador por defecto (“index”) y dentro de este las siguientes acciones:
Creando el controlador
Para crear nuestras acciones basta con abrir una terminal, acceder al directorio de nuestro proyecto (/var/www/zf/primer-proyecto/application/controllers) y ejecutar los siguientes comandos:
zf create action add index zf create action edit index zf create action delete index
Estos crearan las acciones “add”, “edit” y “delete” dentro del controlador “index”. Si todo se realizó correctamente deberías poder ver dentro del directorio application/controllers un archivo llamado “IndexController.php” que contiene las acciones antes mencionadas:
<?php class IndexController extends Zend_Controller_Action { public function init() { /* Initialize action controller here */ } public function indexAction() { // action body } public function addAction() { // action body } public function editAction() { // action body } public function deleteAction() { // action body } }
Estos mismos comandos además de crear el controlador y sus acciones también crea las vistas que mas tarde utilizaremos.
Resumiendo ya tenemos la siguiente estructura:
Si pruebas cada URL deberías ver el siguiente mensaje (con excepción de la primera URL que tiene aún la vista por defecto de Zend Framework)
View script for controller index and script/action name delete
Creando el modelo
En el apartado anterior definimos el esquema general del controlador y ahora es tiempo que trabajemos en el modelo.
Lo primero es que configuremos la información de nuestra base de datos, para esto abrimos el archivo: “/var/www/zf/primer-proyecto/application/configs/application.ini” y agregamos dentro de “[production]” (antes de “[staging : production]”), lo siguiente:
resources.db.adapter = PDO_MYSQL
resources.db.params.host = localhost
resources.db.params.username = usuario
resources.db.params.password = clave
resources.db.params.dbname = nombrebasededatos
A continuación crearemos la tabla que almacenará nuestros contactos. Para esto podemos usar phpmyadmin o el programa de tu preferencia:
CREATE TABLE `zfdb`.`contacts` ( `id` INT NOT NULL AUTO_INCREMENT , `name` VARCHAR( 30 ) NOT NULL , `lastname` VARCHAR( 30 ) NOT NULL , `email` VARCHAR( 60 ) NOT NULL , PRIMARY KEY ( `id` ) )
Además agregaremos una entrada a la tabla para tener datos con los que trabajar:
INSERT INTO contacts (name,lastname,email) VALUES ('Juan','Perez','juan@perez.com'), ('Maria','Gonzalez','maria@gonzalez.com'), ('Sofia','Alvarez','sofía@alvarez.com'), ('Pedro','Sanchez','pedro@sanchez.com');
Una vez realizado esto podemos generar nuestro modelo creando el siguiente archivo:
<?php class Model_Table_Contacts extends Zend_Db_Table { protected $_name = 'contacts'; public function getContact($id) { $id = (int)$id; $row = $this->fetchRow('id = ' . $id); if (!$row) { throw new Exception("No se encuentra la fila $id"); } return $row->toArray(); } public function addContact($name, $lastname, $email) { $data = array( 'name' => $name, 'lastname' => $lastname, 'email' => $email, ); $this->insert($data); } function updateContact($id, $name, $lastname, $email) { $data = array( 'name' => $name, 'lastname' => $lastname, 'email' => $email, ); $this->update($data, 'id = '. (int)$id); } function deleteContact($id) { $this->delete('id =' . (int)$id); } }
Así dentro del modelo tendremos los métodos que nos ayudarán a interactuar con nuestra base de datos.
Creando las vistas
En Zend Framework encontramos las vistas en el directorio “views” y se organizan de la forma: views/scripts/{nombredelcontrolador}/{nombredelaaccion}.phtml .
Como te habrás dado cuenta nuestras vistas ya están creadas (ocurrió cuando creamos el controlador en el punto 4.1), ahora corresponde que nos ocupemos del “layout”.
En la mayoría de los proyectos hay partes de código HTML que se repite para todas las vistas, por ejemplo: un encabezado, una columna lateral y el pie de página. Para evitar repetir código es que existe la posibilidad de crear un “layout” o plantilla donde colocaremos el código común y desde donde llamaremos las vistas.
Lo primero que debemos hacer es crear el directorio: “application/layouts/” y agregar en nuestro archivo de configuración (configs/applications.ini) la siguiente linea (justo después de la configuración de la base de datos que agregamos):
resources.layout.layoutpath = APPLICATION_PATH “/layouts”
También agregaremos las definiciones generales para nuestro layout editando la clase Bootstrap (“/application/Bootstrap”) y agregando lo siguiente:
function _initViewHelpers() { $this->bootstrap('layout'); $layout = $this->getResource('layout'); $view = $layout->getView(); $view->doctype('XHTML1_STRICT'); $view->headMeta()->appendHttpEquiv('Content-Type', 'text/html;charset=utf-8'); $view->headTitle()->setSeparator(' - '); $view->headTitle('Primeros pasos en Zend Framework'); }
Por último crearemos el archivo de nuestro “layout” en “/application/layouts/layout.phtml”:
<?php echo $this->doctype(); ?> <html> <head> <?php echo $this->headMeta(); ?> <?php echo $this->headTitle(); ?> </head> <body> <h1><?php echo $this->escape($this->title); ?></h1> <?php echo $this->layout()->content; ?> </body> </html>
Con esto finalizamos lo relacionado con la estructura del sistema, en adelante nos corresponde “darle vida” a sus funcionalidades.
Implementando las funcionalidades
En esta quinta parte analizaremos como implementar las funcionalidades de nuestro sistema, es decir, como mostrar, agregar, editar y eliminar nuestros contactos.
Mostrando los contactos
El primer paso es agregar la lógica de la funcionalidad en la acción del controlador, por lo que vamos a “/application/controllers/IndexController.php” y agregamos lo siguiente en nuestra acción por defecto (“indexAction”):
// action body // Título de la vista $this->view->title = "Mis Contactos"; // Iniciamos una instancia del nuestro modelo $contacts = new Model_Table_Contacts(); // Asignamos a la vista el resultado de consultar por todos los registros $this->view->contacts = $contacts->fetchAll();
El segundo paso es ir a la vista para esta acción (“/application/ views/ scripts/ index/ index.phtml”) y cambiamos su contenido por el siguiente:
<p><a href="<?php echo $this->url(array('controller'=>'index','action'=>'add'));?>">Agregar contacto</a></p> <table> <tr> <th>Nombre</th> <th>Apellido</th> <th>Correo</th> <th> </th> </tr> <?php foreach($this->contacts as $contact) : ?> <tr> <td><?php echo $this->escape($contact->name);?></td> <td><?php echo $this->escape($contact->lastname);?></td> <td><?php echo $this->escape($contact->email);?></td> <td> <a href="<?php echo $this->url(array('controller'=>'index','action'=>'edit','id'=>$contact->id));?>">Editar</a> <a href="<?php echo $this->url(array('controller'=>'index','action'=>'delete','id'=>$contact->id));?>">Borrar</a> </td> </tr> <?php endforeach; ?> </table>
Ahora si abrimos la página de inicio (“http://localhost/zf/primer-proyecto/public/index/”) nos deberíamos encontrar con lo siguiente:
Agregando contactos
Para agregar contactos crearemos un formulario en “/application/forms/Contact.php ”:
<?php // Creamos una clase que extiende el componente Zend_Form class Form_Contact extends Zend_Form { public function __construct($options = null) { parent::__construct($options); $this->setName('contact'); $id = new Zend_Form_Element_Hidden('id'); $name = new Zend_Form_Element_Text('name'); $name->setLabel('Nombre') ->setRequired(true) ->addFilter('StripTags') ->addFilter('StringTrim') ->addValidator('NotEmpty'); $lastname = new Zend_Form_Element_Text('lastname'); $lastname->setLabel('Apellido') ->setRequired(true) ->addFilter('StripTags') ->addFilter('StringTrim') ->addValidator('NotEmpty'); $email = new Zend_Form_Element_Text('email'); $email->setLabel('Correo') ->setRequired(true) ->addFilter('StripTags') ->addFilter('StringTrim') ->addValidator('NotEmpty'); $submit = new Zend_Form_Element_Submit('submit'); $submit->setAttrib('id', 'submitbutton'); $this->addElements(array($id, $name, $lastname, $email, $submit)); } }
Ahora sólo nos resta agregar en nuestro controlador la lógica de la acción destinada a agregar contactos (addAction):
public function addAction() { $this->view->title = "Agregar un nuevo contacto"; $form = new Form_Contact(); $form->submit->setLabel('Agregar'); $this->view->form = $form; if ($this->getRequest()->isPost()) { $formData = $this->getRequest()->getPost(); if ($form->isValid($formData)) { $name = $form->getValue('name'); $lastname= $form->getValue('lastname'); $email= $form->getValue('email'); $contact = new Model_Table_Contacts(); $contact->addContact($name, $lastname, $email); $this->_redirect('/'); } else { $form->populate($formData); } } }
Por último, en la vista de la acción “agregar” (/views/scripts/index/add.phtml) incluíremos:
<?php echo $this->form ;?>
Si vamos a http://localhost/zf/primer-proyecto/public/index/add deberíamos ver lo siguiente:
Editando los contactos
La acción dedicada a la edición de nuestros contactos es muy similar a la ocupada para agregarlos. Luego en “editAction()” agregaremos lo siguiente:
public function editAction() { // action body $this->view->title = "Editar contacto"; $form = new Form_Contact(); $form->submit->setLabel('Guardar'); $this->view->form = $form; if ($this->getRequest()->isPost()) { $formData = $this->getRequest()->getPost(); if ($form->isValid($formData)) { $id = (int)$form->getValue('id'); $name = $form->getValue('name'); $lastname = $form->getValue('lastname'); $email = $form->getValue('email'); $contacts = new Model_Table_Contacts(); $contacts ->updateContact($id, $name, $lastname, $email); $this->_redirect('/'); } else { $form->populate($formData); } } else { $id = $this->_getParam('id', 0); if ($id > 0) { $contacts = new Model_Table_Contacts(); $form->populate($contacts->getContact($id)); } } }
Mientras que en la vista de esta acción (/views/scripts/index/edit.phtml)
<?php echo $this->form ;?>
Al visitar http://localhost/zf/primer-proyecto/public/index/edit deberíamos encontrar lo siguiente:
Borrando contactos
Por último necesitamos implementar una funcionalidad para eliminar registros en nuestro sistema. Para esto en el controlador definiremos la acción “deleteAction”:
public function deleteAction() { // action body $this->view->title = "Eliminar contactos"; if ($this->getRequest()->isPost()) { $del = $this->getRequest()->getPost('del'); if ($del == 'Yes') { $id = $this->getRequest()->getPost('id'); $contacts = new Model_Table_Contacts(); $contacts->deleteContact($id); } $this->_redirect('/'); } else { $id = $this->_getParam('id', 0); $contacts = new Model_Table_Contacts(); $this->view->contact = $contacts->getContact($id); } }
Mientras que en la vista incluiremos un mensaje de confirmación del registro que se quiere borrar:
<p>Está seguro de querer borrar el contacto: <?php echo $this->escape($this->contact['name']); ?> <?php echo $this->escape($this->contact['lastname']); ?>? </p> <form action="<?php echo $this->url(array('action'=>'delete')); ?>" method="post"> <div> <input type="hidden" name="id" value="<?php echo $this->contact['id']; ?>" /> <input type="submit" name="del" value="Yes" /> <input type="submit" name="del" value="No" /> </div>
Al intentar borrar un contacto nos debería mostrar la siguiente confirmación:
En este artículo hemos visto como desarrollar una pequeña aplicación usando Zend Framework. Si bien el uso de estas herramientas nos permiten mantener en orden un proyecto y, además, aumentar la velocidad de desarrollo, también se debe considerar el tiempo que hay que invertir en su aprendizaje.
Si quieres profundizar en Zend Framework un buen comienzo es el sitio oficial del proyecto y su documentación (http://framework.zend.com/). Además te recomiendo el libro que utilicé como base para este artículo: “Zend Framework in Action” (http://www.zendframeworkinaction.com/)
Artículos Aleatorios
- MercadoLibre migra a Oracle Unbreakable Linux [vivalinux.com.ar]
- Europa, líder en Open Source [muycomputerpro.com]
- Open Source es una herramienta muy poderosa para la evolución del Software. Vinton Cerf-”Padre de la Internet” [cofradia.org]
- Red Hat domina el 75% del mercado comercial de GNU/Linux. [alcancelibre.org]
London Stock Exchange dumps Windows for Linux [computerworld.com]
Motorola dice que es mucho mejor Android que Windows Mobile [movilzona.es] - Red Hat y Microsoft amplían las opciones de interoperabilidad de la virtualización. [alcancelibre.org]
- Linux en las empresas: 5 mitos desmontados [muypymes.com]
- The OpenBlockS 600 is a Linux server that fits in your palm [computerworld.com]
Artículos Aleatorios
Si necesitas implementar una funcionalidad que no viene por defecto en Wordpress lo más sencillo es que busques en el directorio de plugins y si aún no encuentras puedes desarrollar uno tu mismo.
Si bien espero escribir artículos específicamente dedicados al desarrollo de plugins, te puedo adelantar que una de las principales herramientas para el desarrollo son los “hooks”, los cuales nos permiten conectarnos o “engancharnos” a Wordpress. De estos existen dos tipos:
- Las acciones (actions), que representan a hechos dentro del sistema, por ejemplo, cuando una entrada es publicada o un plugin es activado.
- Los filtros (filters), como su nombre lo indica nos ayudan a filtrar un contenido en particular, al cual podemos agregar algo o cambiar su formato. Por ejemplo, podríamos filtrar el texto principal de las entradas y agregarle el perfil detallado del usuario.
Las posibilidades sólo están limitadas a tu imaginación ya que la cantidad de hooks es enorme, pero quizás te estarás preguntando cuales son los más usados. A continuación el “top 5″ en cada caso:
Actions – Top 5
- admin_menu: 38,53%
- wp_head: 19,69%
- init: 17,98%
- admin_head: 13,01%
- plugins_loaded: 10,79%
Filters – Top 5
- the_content: 66,48%
- comment_text: 12,64%
- the_excerpt: 10,99%
- the_content_rss: 4,95%
- posts_where: 4,95%
Fuente: scompt.com
Gráficos: Google Chart API
Entradas Relacionadas
Ya que el logo que estaba usando no me convencía mucho decidí experimentar con GIMP a ver que salía.
Así era el logo anterior:
Me gustaba pero no me convencía porque no reflejaba el origen del nombre de este blog, el cual es la película de Q. Tarantino: “Kill Bill” y la coincidencia con el nombre del fundador de Microsoft 
. Así que comencé a agregar espadas japonesas, colores y fuentes que me acercaran a lo que buscaba. Aquí la “evolución”:
Finalmente me quedé con esta última opción principalmente porque queda mejor en fondos oscuros. Por ejemplo:
Artículos Aleatorios
- La coexistencia de Windows y Linux en las empresas [tecnologiapyme.com]
- El Programa Compartel instala 10.000 servidores Linux en Colombia [vivalinux.com.ar]
- Paraguay adoptará el Modelo de Software Público de Brasil [vivalinux.com.ar]
Entradas Relacionadas
Programar debería ser divertido y desafiante, pero cuando reinventamos la rueda o perdemos tiempo en actividades repetitivas y poco creativas, la diversión se esfuma rápidamente.
Los frameworks de desarrollo nos entregan un esquema general de trabajo y código que podemos reutilizar para evitar la reescritura de funcionalidades comunes, permitiéndonos así enfocarnos en desarrollar sólo lo exclusivamente necesario.
En este artículo podrás conocer uno de los principales framework para PHP: Zend Framework. Primero veremos su configuración y, en la segunda parte, el desarrollo de una aplicación de demostración.
1. ¿Qué son los Frameworks?
Mientras más tiempo pasamos programando más clases, funciones y herramientas vamos acumulando, hasta llegar al punto en que tenemos un sistema que aplicamos a cualquier proyecto. El problema con esto es que generalmente tenemos una especie de Frankestein que está hecho de muchas partes (de terceros o programados por nosotros mismos), lo cual implica que sea difícil tenerlo actualizado y funcionando en forma correcta y segura.
Los frameworks, como su nombre lo indica, nos entregan una estructura, armazón o marco para desarrollar nuestros proyectos. En otras palabras, nos entregan una serie de clases, funciones o librerías, que junto a convenciones comunes, se organizan bajo una estructura sobre la cual desarrollamos nuestros proyectos.
Entre las ventajas de usar frameworks, se pueden contar:
- Facilita integrar a otros personas a tus proyectos ya que se comparten convenciones de desarrollo comunes.
- No nos preocupamos de mantener actualizadas las distintas partes.
- No reinventar la rueda, ya que aprovechamos los componentes existentes aumentando la velocidad de desarrollo.
Como desventajas se pueden nombrar:
- Agrega código adicional que no es tuyo.
- Hay que invertir tiempo en aprender a usarlos.
- En algunos casos una aplicación desarrollada con un framework puede ser más lenta (en cuanto a rendimiento) que una diseñada y desarrollada desde cero.
2. ¿Por qué usar Zend Framework?
Existe una gran oferta de frameworks para PHP, unos más maduros que otros, con más documentación que otros o con mejor rendimiento que otros. Igualmente en Internet podemos encontrar una gran cantidad de información comparativa y, en general, opiniones sobre cual es superior al resto.
Luego de haber probado: Symfony, CakePHP, Codeigniter, Kohana y Zend Framework, me queda sólo una conclusión clara: la decisión de cual es el mejor, sólo la puedes tomar tu probando cada uno y analizando cual se adapta mejor a tus necesidades actuales.
En mi caso elegí Zend Framework por las siguientes razones:
- En general muy buena documentación
- Una comunidad activa
- Tiene el respaldo de la compañía que está detrás de PHP: Zend Technologies Ltd.
- Gran cantidad de componentes, incluidos algunos de Microsoft, Google y Adobe
- Soporta PHP 5>
Si bien tiene varias ventajas, una de sus desventajas es que es un poco más difícil de aprender que otras alternativas, como por ejemplo Codeigniter (CI) y, además, existen reportes que indican que también tiene un rendimiento menor que el mismo CI.
3. Preparando el Sistema
Nota: Antes de comenzar con la preparación del sistema se asume que el lector conoce la programación orientada a objetos en PHP y el Modelo Vista Controlador (MVC). Además, el proceso de configuración inicial está orientado a sistemas Linux aunque su replicación en sistemas Windows no debería tener mayores complicaciones.
Para preparar nuestro sistema para comenzar a trabajar con Zend Framework debemos verificar que cumplimos con sus requerimientos:
- PHP versión 5.2.4 o superior
- Servidor que soporte mod_rewrite
Luego de asegurarnos de cumplir con los requerimientos descargamos Zend Framework desde: http://framework.zend.com/download/latest (te recomiendo la versión “minimal”).
Una vez descargado y descomprimido nos encontramos con el siguiente árbol de directorios:
- /bin: contiene ejecutables que nos ayudan a realizar algunas actividades comunes, como por ejemplo crear nuevos proyectos.
- /library: contiene todos los componentes de Zend Framework.
- INSTALL.txt: se indican los requerimientos y recomendaciones para la instalación del framework.
- LICENCE.txt: texto de la licencia.
- README.txt: informa sobre los cambios de la versión descargada respecto a la anterior.
Lo primero que haremos es mover el directorio de Zend Framework a un lugar de nuestra preferencia (por ejemplo, nuestro /home) y agregaremos un alias para los ejecutables. Abrimos una terminal y ejecutamos:
gedit $HOME/.bashrc alias zf=/home/tu-usuario/ZendFramework-1.9.0-minimal/bin/zf.sh // Guardamos y cerramos // Cerramos tambien la terminal
Para probar que hemos realizado todo correctamente abrimos una terminal y ejecutamos lo siguiente:
zf show version
Si todo está correcto debería aparecer el mensaje: “Zend Framework Version: 1.9.0”.
Ya con esto estamos en condiciones de iniciar nuestros proyectos en Zend Framework. Para esto primero vamos al lugar donde crearemos el proyecto (el directorio de nuestro servidor Web). Desde la terminal ejecutamos:
cd /var/www/zf
Una vez dentro de nuestro directorio de trabajo crearemos nuestro primer proyecto:
zf create project primer-proyecto
Si todo va bien deberías ver el mensaje: “Creating project at /var/www/zf/primer-proyecto” y dentro del directorio /var/www/zf/primer-proyecto deberías encontrar lo siguiente:
- /application: contiene los directorio destinados a nuestra aplicación
- /library: debe contener todos los componentes de Zend Framework
- /public: este directorio es el único que debería tener acceso público
- /tests: directorio destinado a pruebas para tu aplicación.
Como te habrás dado cuenta, en tu proyecto el directorio /library está vacío y como se explicó en el párrafo anterior este debe contener todos los componentes del framework. Luego es necesario que vayamos al directorio que descomprimimos inicialmente (y que lo tenemos en “/home/tu-usuario/ZendFramework-1.9.0-minimal/”) y copiemos el contenido del directorio /library en el de nuestro proyecto.
Si prefieres, en lugar de copiar el directorio /Zend, puedes hacer un enlace simbólico, disminuyendo así el espacio a ocupar.
Si ahora vas a tu navegador y abres http://localhost/zf/primer-proyecto/public/ deberías ver el siguiente mensaje de bienvenida:
En la Parte 2 de esta serie veremos como crear nuestro primer proyecto.
Entradas Relacionadas
Anteriormente en esta guía:
- En el “Paso 0” analizamos la parte teórica de Linux y el software de Código Abierto, incluyendo las razones que te deberían permitir saber si este tipo de sistemas es o no adecuado para ti.
- En el “Paso 1“, comenzamos la migración de una manera simple y gradual. El objetivo principal en ese paso fue que utilizaras aplicaciones libres sobre Windows, reemplazando tus programas cerrados por alternativas de código abierto (por ejemplo, IExplorer por Firefox).
- En este tercer paso ( “Paso 2″), iniciamos el acercamiento al uso de Linux, pero lo sólo como un reconocimiento inicial. De esta manera vimos como probar Linux pero sin tener que instalar ni hacer modificaciones profundas en tu actual sistema.
Una vez que hemos probado Linux en modo Live el suficiente tiempo como para sentirnos cómodos y ya sabemos cual distribución es la que mejor se adapta a nuestras necesidades, pasaremos a la siguiente etapa: El “Paso 3″, La instalación de Linux en nuestro sistema.
Al igual que en todos los pasos de esta guía, la idea principal es que la migración sea gradual y sin riesgos. Es por esto que la instalación la realizaremos en formato dual, es decir, instalaremos Linux junto a Windows, de tal forma que al encender tu equipo se te preguntará con cual sistema deseas arrancar. La idea es tener lo que se conoce como un arranque dual:
La Instalación
La primera vez que instalé Linux estuve prácticamente toda una noche intentando hacer funcionar todo en mi PC de 1GB de disco duro (y pensar que con 1GB alcanzaba en ese tiempo )
Afortunadamente desde ese entonces las cosas han cambiado y hoy la gran mayoría de las distribuciones es muy fácil de instalar. Sin embargo, uno de los pasos de la instalación en la que debemos tener cuidado es el particionado del disco, pero no te asustes que tampoco es la gran cosa 
Ahora eres agricultor
Cuando un agricultor decide que en su terreno quiere cultivar zanahorias basta con que plante las semillas y luego coseche, ¿cierto? (bueno siempre que no tenga una plaga de conejos). Pero, ¿qué ocurre si quiere plantar también lechugas?. El no va y mezcla los cultivos, no lanza las semillas por todo el campo esperando que crezca una zanahoria y a su lado un par de lechugas, lo que hace es dividir su terreno en dos segmentos cuyo tamaño dependerá de cuanto quiere destinar a uno y a otro.
A la hora de la instalación harás lo mismo que el granjero: dividirás tu “terreno” (disco duro) para poder “plantar” (instalar) “lechugas” (Linux) junto a tus “zanahorias” (Windows). Ahora que si eres un “granjero” con más recursos y tienes dos o más “campos” (discos duros) disponibles entonces podrás destinar uno completo a Linux y no tendrás que agregar particiones a un mismo disco. Cualquiera sea la opción que tomes, la idea y el resultado es el mismo: definir un espacio claramente acotado para tu instalación de Linux.
Para realizar el particionado tienes al menos 2 opciones:
- Ocupas un programa de particionado que funcione sobre Windows para ahí preparar tu disco duro y definir las particiones, o
- Ocupas el particionador integrado en el proceso de instalación que la mayoría de las distribuciones traen.
Te recomiendo la segunda opción por su simpleza y porque nunca me ha fallado
A esta altura seguramente te estás haciendo tres preguntas: ¿Cuántas particiones hago?, ¿Cuánto espacio le doy a cada partición?, ¿Existe vida extraterrestre?. Te voy a ayudar con las dos primeras, porque la tercera es muy fácil.
- ¿Cuántas particiones hago?. Como recomendación te diría que hagas las siguientes particiones:
- Una para Linux: Aquí es donde instalarás el sistema base
- Una para tu /home en Linux: En Linux cada usuario tiene sus documentos y archivos de configuración dentro del directorio /home. Por ejemplo, si tu nombre de usuario es “jperez”, tus documentos y archivos estarán en “/home/jperez”. La idea de dejar una partición aparte es para que si quieres o necesitas reinstalar Linux, tus archivos quedan si ser tocados.
- Una para swap: La memoria “swap” o de intercambio es la que ocupa el sistema cuando nos quedamos cortos de RAM.
- Una para tu Wintendo actual: En este espacio se queda tu actual sistema para que lo ocupes cuando lo necesites.
- ¿Cuánto espacio le doy a cada partición?
- Partición para Linux: para calcular cuanto dar recuerda que esta partición será la que se usará para instalar los programas. También dependerá de que distribución selecciones y que uso le darás
- Partición para tu /home en Linux: en este caso recuerda que esta partición mantendrá todos tus archivos y no debería tener ningún programa instalado en ella.
- Partición para swap: se recomienda que asignes el doble de tu RAM actual.
- Partición para tu Wintendo actual: dependiendo del uso que le des le debes dejar algo de espacio para seguir guardando tus archivos y las actualizaciones del sistema.
Para profundizar más en este tema es muy recomendable que leas este artículo.
Ahora que tenemos medianamente claro que es el particionado veamos el proceso de instalación:
- Lo primero es que descargues la imagen ISO de la distribución que vas a instalar
- Luego grabas (quemas) la imagen ISO en un CD o DVD (importante: al grabar debes seleccionar la opción “grabar como imagen” o similar en tu programa. Más información aquí)
- Colocas el CD/DVD en tu lector y reinicias. Debería arrancar desde el CD, si no lo hace seguramente es que tu BIOS no está configurada para arrancar primero con el lector de CD/DVD.
- Inicias el proceso de instalación.
Para que quede más claro veremos a continuación el proceso de instalación completo con capturas de pantalla. Este es el proceso que se sigue en mi proyecto ESUN Linux (texto e imágenes extraído de la wiki de ese proyecto). En otras distribuciones no debería variar mucho el proceso:
Seleccionamos nuestro idioma
En segundo lugar seleccionamos nuestra zona horaria:
Luego de la zona horaria seleccionaremos la distribución de nuestro teclado. Para asegurarte de que has seleccionado correctamente puedes probar escribiendo en el campo disponible en la zona inferior:
Uno de los pasos más importantes es la preparación del disco duro y la selección de la partición que usaremos para instalar el sistema. Una partición no es más que una división del disco que utilizamos para un fin en particular. Un disco puede tener 1 partición (el disco completo) o varias particiones, es decir, el disco dividido en varias secciones. El instalador te ofrece tres alternativas de particionado:
- “Guiado – cambia tamaño del disco”: es la primera opción y es útil cuando tienes otro sistema ya instalado. Esta opción te permitirá usar el espacio que queda disponible, creando dos particiones, una en la que dejará el sistema que ya tenías instalado y otra en la que se instalará tu nuevo sistema.
- “Guiado – utilizar todo el disco”: esta opción es recomendable si quieres dejar en tu equipo solamente el sistema que estás instalando. Se debe considerar que si seleccionas esta opción y tu equipo tiene instalado otro sistema, este será borrado.
- “Manual”: puedes utilizar esta opción si previamente realizaste el particionado de tu disco y quieres tener un mayor control sobre la selección de las particiones.
En el paso 5 el programa de instalación nos pide nuestros datos personales:
- Nuestro nombre
- El nombre de usuario y la clave con los cuales nos identificaremos en el sistema (obviamente es muy importante que recordemos estos datos)
- Y finalmente un nombre para el equipo
- Opcionalmente podemos seleccionar que se inicie automáticamente la sesión (generalmente usado en sistemas de kioskos interactivos)
El penúltimo paso nos pregunta si queremos importar los documentos y configuraciones de cuentas que existan en otros sistemas presentes en el equipo. Si no se necesita importar solo se presiona el botón “Adelante”.
Por último se nos muestra un resumen con todas las opciones que hemos seleccionado. Si estamos de acuerdo con todo presionamos “Instalar” y esperamos a que el proceso concluya (cerca de 20 minutos según las características del equipo).
Una vez presionado el botón “instalar” el proceso comienza:
Una vez concluida la instalación, se nos pedirá que retiremos el CD del lector y que reiniciemos el equipo.
Al reiniciar, si tenemos más de un sistema operativo, se nos preguntará cual deseamos utilizar, de lo contrario arrancará directamente con el que acabamos de instalar.
Este mismo proceso lo puedes ver en video para distintas distribuciones. Por ejemplo:
Instalación de Fedora Linux:
Instalación de OpenSUSE
En el próximo capítulo
En la siguiente entrega de esta serie veremos que tareas nos quedan luego de realizar nuestra instalación. De esta manera algunos puntos que se abordarán son:
- Ya instalé Linux junto a Windows, ¿ahora qué?
- ¿Qué diferencias en el uso diario existen entre Windows y Linux?
- Árbol de directorios (FHS)
- Instalación de programas
- Seguridad del sistema
- ¡Tengo dudas!, ¿dónde obtengo ayuda?
- Como aprovechar las ventajas de Linux
Para el tema de las diferencias te puedo adelantar que los sistemas operativos son como los autos
Entradas Relacionadas
Coincidentemente el día de hoy encontré tres artículos muy buenos sobre seguridad y corrección de errores en PHP. Los tres muy recomendados:
- Practical Testing in PHP (Serie)
- Simple Techniques to Lock Down your Website
- PHP Security: Are you paying attention?
Entradas Relacionadas
- Red Hat presenta en Madrid, con IBM, su oferta de soluciones open source para el sector financiero [financialtech-mag.com]
- Nokia se encadena a QT [diegocg.blogspot.com]
- La compañía CMS Open Source Interactivetools crea una nueva sección en su sitio Web para que sus clientes puedan acceder a nuevas aplicaciones de CMS Builder [ecm-spain.com]
- En plena crisis se hace dinero con Linux [akronoticias.com]
- 2009 Coverity Scan Open Source Report [coverity.com]
Entradas Relacionadas
Si quieres un fondo de pantalla chilensis te dejo uno a partir de una foto que tomé hace un tiempo (si quieres la versión sin el tux, la encuentras aquí):
Por si tiene curiosidad la foto es de la bandera que se ve acá:
Entradas Relacionadas