Featured


18
Oct 09

De YouTube a Mp3 en Linux

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_youtube

3. 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


16
Oct 09

Los secretos de las capturas de pantalla en GNOME

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 -w

Con 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:

shot1

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

shot2

Por último, si quieres todas estas opciones en una linda interfaz gráfica de usuario, ejecuta:

gnome-screenshot -i

Con la opción “-i” obtienes lo siguiente:

shot3


9
Oct 09

Tus primeros pasos con Zend Framework: Parte 2

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:

zend1

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:

zend2

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>&nbsp;</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:

zend3

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:

zend4

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:

zend5

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&aacute; 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:

zend6

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/)


8
Oct 09

Filtros y acciones más populares en WordPress

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:

  1. Las acciones (actions), que representan a hechos dentro del sistema, por ejemplo, cuando una entrada es publicada o un plugin es activado.
  2. 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

  1. admin_menu: 38,53%
  2. wp_head: 19,69%
  3. init: 17,98%
  4. admin_head: 13,01%
  5. plugins_loaded: 10,79%

Filters – Top 5

  1. the_content: 66,48%
  2. comment_text: 12,64%
  3. the_excerpt: 10,99%
  4. the_content_rss: 4,95%
  5. posts_where: 4,95%

Fuente: scompt.com

Gráficos: Google Chart API


6
Oct 09

Tus primeros pasos con Zend Framework: Parte 1

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:

1

En la Parte 2 de esta serie veremos como crear nuestro primer proyecto.