miércoles, 5 de octubre de 2011

Acelerando la ejecucion de jquery

Ayer leí un artículo interesante, sobre cómo registrar eventos con jQuery en distintos elementos del DOM, y cómo con live() funciona más rápido que haciendo el registro luego de que termine de cargar el DOM.

http://encosia.com/dont-let-jquerys-document-ready-slow-you-down/

viernes, 23 de septiembre de 2011

Yupp CMS: creando modulos

En este artículo veremos como crear nuevos módulos para Yupp CMS.

Lo primero que tenemos es la estructura interna del CMS:
  • controllers
    • apps.cms2.controllers.CmsController.class.php
  • model
    • cms
      • cms2.model.cms.Layout.class.php
      • cms2.model.cms.Module.class.php
      • cms2.model.cms.Page.class.php
      • cms2.model.cms.PageZone.class.php
      • cms2.model.cms.Zone.class.php
  • views
    • cms
      • createModule.view.php
      • createPage.view.php
      • displayPage.view.php
      • displayPageRO.view.php
      • editModule.view.php
      • listModules.view.php
      • listPages.view.php
    • module
      • displayModule.template.php

El objetivo es crear un módulo para poder mostrar HTML y editarlo de forma visual en la web.

Lo primero que hacemos es crear la clase en el modelo, y ubicarla en model/nombreDelModulo:

YuppLoader::load('cms2.model.cms', 'Module');

class HtmlModule extends Module
{
   function __construct($args = array (), $isSimpleInstance = false)
   {
      $this->setWithTable("cms_html_module");
        
      $this->addAttribute("content", Datatypes :: TEXT);

      parent :: __construct($args, $isSimpleInstance);
   }

   public static function listAll(ArrayObject $params)
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: listAll($params);
   }

   public static function count()
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: count();
   }

   public static function get($id)
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: get($id);
   }

   public static function findBy(Condition $condition, ArrayObject $params)
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: findBy($condition, $params);
   }

   public static function countBy(Condition $condition)
   {
      self :: $thisClass = __CLASS__;
      return PersistentObject :: countBy($condition);
   }
}


El módulo se llama HtmlModule, y siempre debe extender a Module. La estructura de directorios en model quedará así:
  • model
    • cms
      • ...
    • htmlModule
      • cms2.model.htmlModule.HtmlModule.class.php

Ahora necesitamos crear un controlador que implemente las acciones particulares sobe ese módulo, como editar el contenido. El controlador debe tener el mismo nombre que el módulo. Aquí está el código del controlador:

YuppLoader::load('cms2.model.htmlModule', 'HtmlModule');

class HtmlModuleController extends YuppController {

   /**
    * Edita el contenido del modulo de HTML.
    * 
    * in: id
    * in: pageId
    */
   public function editAction()
   {
      $module = HtmlModule::get($this->params['id']);
      if (isset($this->params['doit']))
      {
         $module->setProperties($this->params);
         if (!$module->save()) print_r($module->getErrors());
         
         return $this->renderString('Modulo salvado correctamente');
      }
      
      return array('module'=>$module);
   }
}


Aquí está la estructura de directorios resultante de controladores:
  • controllers
    • apps.cms2.controllers.CmsController.class.php 
    •  apps.cms2.controllers.HtmlModuleController.class.php

 Por último, se implementan las vistas del módulo. Una vista será para la edición del contenido, y otra para la visualización del contenido del módulo. La estructura de directorios resultante es la siguiente:
  • views
    • cms
      • ....
    • module
      • displayModule.template.php
    • htmlModule
      • edit.view.php
      • displayModule.template.php

Como se puede ver, en realidad la vista de visualización del contenido del módulo es en realidad un template.

displayModule.template.php:

<?php echo $module->getContent(); ?>
<?php if ($mode=='edit') : ?>
  <div class="customModuleActions">
    <a href="'htmlModule', 'action'=>'edit', 'class'=>$module->getClass(), 'id'=>$module->getId())); ?>" alt="editar html" class="edit_html">
      <?php echo h('img', array('app'=>'cms2', 'src'=>'edit.gif')); ?>
    </a>  
  </div>
<?php endif; ?>



Este template muestra el contenido del módulo, y si estamos en modo "edit", muestra el botón para editar el contenido del módulo.


edit.view.php:

<?php

$m = Model::getInstance();

$module = $m->get('module');

YuppLoader::load('core.mvc', 'DisplayHelper');

?>
<html>
  <head>
    <style>
      body {
         padding: 5px;
      }
    </style>
    
    <?php echo h('js', array('app'=>'cms2', 'name'=>'jquery/jquery-1.5.1.min')); ?>
    <?php echo h('js', array('app'=>'cms2', 'name'=>'jquery/jquery.form-2.84')); ?>
    <script type="text/javascript">
      
      // Funcion que va a llamar el editor cuando termine de cargar (ver config del TinyMCE)
      var htmlinit = function() {
         
         parent.modalReady(document); // Notifica para que el parent actualice el tamanio del iframe
      }
      
      $(document).ready( function() {
        
        // Para que actualice el textarea con el contenido del TinyMCE, antes de mandarlo por ajax.
        // Ref: http://maestric.com/doc/javascript/tinymce_jquery_ajax_form
        $('#editForm').bind('form-pre-serialize', function(e) {
            
            tinyMCE.triggerSave();
        });
        
        // Submitea el form por ajax
        $('#editForm').ajaxForm({
          
          // Cuando el servidor responde ok, quiero actualizar
          // automaticamente el HTML del modulo sin hacer F5.
          success: function (res, status, response) {
             
            // Este es el modulo que cambia en el dom
            var module = $('#getClass().'__'.$module->getId(); ?>', parent.document);
             
            // Tengo que pedir al servidor el HTML actualizado para este modulo
            // Luego meto el actualizado en el dom, antes del que cambie
            // Luego elimino el modulo viejo del dom para que quede solo el actualizado
            
            $.ajax({
              url: ''cms', 'action'=>'moduleContent', 'params'=>array('class'=>$module->getClass(), 'id'=>$module->getId()))); ?>',
              success: function (newModuleContent, status) {
                
                // Actualiza solo el contenido!
                module.children('.moduleContent').html(newModuleContent);

                // Obtengo ventana modal
                var modal = $('#modal', parent.document); // Selecciona ventana
                
                // Cierra ventana modal
                modal.fadeOut('slow').css('display', 'none').children('iframe').attr('src', '');
              }
            });
          }
        });
      });
      
    </script>
  </head>
  <body>
    <form id="editForm" method="post" action="'edit')); ?>">
      <input type="hidden" name="id" value="getId(); ?>" />
      <input type="hidden" name="pageId" value="get('pageId'); ?>" />
      <?php DisplayHelper::html( 'content', $module->getContent() ); ?>
      <input type="submit" name="doit" value="Guardar" />
    </form>
  </body>
</html>


Eso es todo. Cualquiera puede desarrollar sus propios módulos, por ejemplo un cliente de twitter, un visualizador de videos de youtube, un blog, un albúm de fotos, etc, el límite es la imaginación!

.

viernes, 2 de septiembre de 2011

Yupp CMS: un nuevo comienzo

Hace ya varios años que vengo desarrollando en PHP, y desde el principio comencé a experimentar distintas técnicas para el desarrollo de sitios web dinámicos. La culminación de esa investigación dio lugar a mi primer proyecto de CMS. Luego de seguir avanzando en mi formación universitaria, y conociendo diversas tecnologías, me di cuenta que aquel primer CMS no era suficiente, y tratando de hacerlo más genérico y extensible fue que comencé el proyecto Yupp Framework (si, todo esto comenzó como una librería que sería el core de un CMS).

Ahora Yupp tiene vida propia y superó mis expectativas como proyecto, convirtiéndose en una herramienta muy potente para el desarrollo PHP en general. Ahora estoy volviendo a las raíces, y con todo lo aprendido de los distintos intentos de CMS, y de la experiencia acumulada durante años, me lancé a lograr algo mejor, más genérico, más extensible, más fácil de usar, más dinámico, o sea la herramienta perfecta. Claro está, que la herramienta perfecta para unos puede no serlo para otros, desde mi humilde lugar lo que quiero es bajar a tierra todas esas "grandes ideas" y ponerlas en una herramienta que me facilite en el trabajo diario.

Aquí están algunas capturas de pantalla del prototipo que tengo hasta ahora. Es una aplicación para Yupp Framework v0.4, donde desarrollé varias funcionalidades básicas, y aunque faltan otras tantas, se puede usar.

Todos los que quieran colaborar con el proyecto, por favor contesten este hilo de discusión.

Esta primer captura de pantalla muestra una página del portal en modo "edición", donde hay zonas que se ven de colores (rojo, violeta, azul, etc), y cada zona puede contener varios módulos (las cajitas celestes).
Los módulos pueden ser de 3 tipos: html, menú y google maps. Estos son solo algunos que desarrollé para probar el concepto, la idea es que sea algo con extensibilidad ilimitada y cualquiera pueda crear sus propios módulos fácilmente, extendiendo así la funcionalidad del CMS.



Los módulos pueden arrastrarse y soltarse en distintas zonas, lo que ayuda a que rápidamente un editor pueda ubicar los módulos en las zonas correctas. En la siguiente imagen se ve como el módulo html que contenía el banner en la zona superior, es movido a la zona intermedia.



Esta tercer captura de pantalla muestra la edición del contenido de un módulo de html.



Y esta cuarta captura muestra el resultado luego de la edición del contenido del módulo de html.



Otra funcionalidad que provee este prototipo, es el cambio de layout con un clic. Un layout define la estructura general de las páginas, con las zonas donde se pueden ubicar distintos módulos. Un programador puede generar nuevos layouts, e instalarlo en el CMS. Incluso los diseñadores gráficos no programadores, podrían generar layouts. La siguiente imagen muestra el cambio de layout con respecto a las imágenes anteriores:


Esta imagen muestra otro cambio de layout:



Un editor podría crear nuevos módulos y agregarlos en distintas zonas con un par de clics.



La siguiente imagen muestra el módulo luego de creado:



El editor podría también crear subpáginas para la página actual:



Las subpáginas de la página actual aparecen en el menú en la parte inferior:



Por último, si salimos del modo "edición", podemos ver la página en modo "visualización":




lunes, 22 de agosto de 2011

Aplicacion para gestion de contenido con tags

Este fin de semana desarrollé un prototipo de un sistema de gestión de contenido, concentrándome en las funcionalidades de agregar y quitar tags del contenido.

Aquí les dejo la aplicación para descargar y probar.

El objetivo fue evaluar que tan costoso era implementarlo en Yupp framework, y el resultado fue el siguiente:
  • Aplicación: Yupp/Ajax/jQuery/MySQL
  • Dedicación: 4 horas
  • Funcionalidades principales: crear tags, agregar tags a varios videos (contenido), quitar una tag de un video
  • Funcionalidades de soporte: obtener todas las tags existentes, obtener las tags para cada video

Lo que logré fue algo así:



A continuación les cuento un poco cómo lo hice:

Estructura de la aplicación:
  • bootstrap
    • apps.resman.bootstrap.Bootstrap.script.php
  • controllers
    • apps.resman.controllers.TagsController.class.php
    • apps.resman.controllers.VideoController.class.php
  • javascript
    • jquery-1.6.2.min.js
    • jquery.form-2.84.js
  • model
    • resman.model.Tag.class.php
    • resources
      • resman.model.resources.Video.class.php
  • views
    • video
      • list.view.php
  • app.xml


Como pueden ver, es una aplicación pequeña, con un par de controllers, un par de clases de modelo persistente, una vista y un par de archivos javascript, uno es el famoso framework javascript jQuery y el otro el plugin para gestionar formularios y poder hacer envíos por ajax, en lugar del clásico submit que nos hace tener que recargar toda la página, y hacerlo por ajax mejora enormemente la experiencia del usuario.

En el archivo de bootstrap se crean algunos videos y la etiqueta que guarda todas las etiquetas del sistema (luego explico como es esto). Como esto es una prueba y no es un gestor de contenidos completo se deben crear los videos en el bootstrap. Si fuera un gestor de contenidos completo, tendría funcionalidades para poder crear, modificar y eliminar videos y otros tipos de contenidos como archivos, links, etc.

En el bootstrap tenemos:

// Incluye clases del modelo persistente
YuppLoader::load('resman.model', 'Tag');
YuppLoader::load('resman.model.resources', 'Video');

// Crea videos de prueba
$videos = array();

$videos[] = new Video(array(
  'name'=>'La Coka Nostra - That\'s coke',
  'comment'=>'excelente!',
  'embedCode'=>'<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/HaVf_yrq6Q0" width="560"></iframe>',
  'link'=>'http://youtu.be/HaVf_yrq6Q0'
));
$videos[] = new Video(array(
  'name'=>'Snoop Dog - Vato',
  'comment'=>'hardcore',
  'embedCode'=>'<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/D_9Dfh2Hf-A" width="560"></iframe>',
  'link'=>'http://youtu.be/D_9Dfh2Hf-A'
));
$videos[] = new Video(array(
  'name'=>'Snoop Dog - Drop it like it\'s hot',
  'comment'=>'chambalala',
  'embedCode'=>'<iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/LfgMC6F0FVo" width="420"></iframe>',
  'link'=>'http://youtu.be/LfgMC6F0FVo'
));

// Guarda en la base los videos de prueba
foreach ($videos as $video)
{
   $video->save();
}

// Crea la instancia global con todas las tags
$globalTags = new Tag(array('tags'=>''));
$globalTags->save();


Antes comentaba que se crea una instancia de Tag que va a guardar todas las tags que se crean en el sistema, la idea es que desde esas tags se seleccionen las tags que se le van a poner a los videos.


Las tablas que generan las clases del modelo persistente son las siguientes:

Tabla de videos con los 3 videos creados en el bootstrap:


id name comment embedCode link class deleted
1 La Coka Nostra - That's coke excelente! <iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/HaVf_yrq6Q0" width="560"></iframe> http://youtu.be/HaVf_yrq6Q0 Video 0
2 Snoop Dog - Vato hardcore <iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/D_9Dfh2Hf-A" width="560"></iframe> http://youtu.be/D_9Dfh2Hf-A Video 0
3 Snoop Dog - Drop it like it's hot chambalala <iframe allowfullscreen="" frameborder="0" height="345" src="http://www.youtube.com/embed/LfgMC6F0FVo" width="420"></iframe> http://youtu.be/LfgMC6F0FVo Video 0


Tabla de tags con la tag que tiene todas las tags creadas en el sistema (la que tiene objClass y objId en NULL), y las tags creadas para cada uno de los videos. Todas las tags de cada video se guardan codificadas en la columna "tags", separadas por coma. Estas son las tags que aparecen en la captura de pantalla que puse más arriba.

id objClass objId tags class deleted
1 NULL NULL papa,pepe,popo,pupu,caradura,sampatrucha Tag 0
2 Video 1 popo,sampatrucha,pepe Tag 0
3 Video 2 sampatrucha,caradura,pepe Tag 0
4 Video 3 popo,sampatrucha,caradura Tag 0


Podría repasar toda las funcionalidades, pero aquí les dejo la aplicación para descargar, donde pueden ver el código y probar de instalarla en Yupp Framework 0.4, además el código está lleno de comentarios.

La idea central era mostrar que con aproximadamente 300 líneas de código, entre PHP y Javascript, y en 4 horas, se pueden lograr funcionalidades muy interesantes, que agilizan la experiencia del usuario, y que tienen gran usabilidad.

lunes, 20 de junio de 2011

Google code search una herramienta excelente

Google code search es una herramienta de Google para buscar código fuente dentro de los proyectos alojados en Google code. Por ejemplo, Yupp Framework es un proyecto de código abierto alojado en Google code.

Ingresando al buscador de código, podemos ingresar el siguiente texto: "helper ajax_link package:http://yupp\.googlecode\.com". Al buscar, vamos a obtener una lista de resultados. Haciendo clic en alguno de los resultados de esa lista, podemos acceder al código fuente:

Luego podemos recorrer el código fuente de uno o más archivos donde se dieron resultados para nuestra búsqueda, o también podemos realizar otras búsquedas.

Esta es una excelente herramienta para encontrar en pocos segundos el código fuente exacto que estamos buscando.

viernes, 17 de junio de 2011

Ideas para mejorar el framework

   
En esta página de la wiki, dejé algunas ideas para mejorar el framework, su usabilidad y funcionalidad: http://code.google.com/p/yupp/wiki/IdeasDeMejoras

Me gustaría hacer una evaluación de las cosas que más les gustaría que el framework incluya, a modo de "lluvia de ideas", para luego poder elegir las más interesantes y poder implementarlas como parte del framework.

Lo que más valor puede agregar en este momento al framework, creo que es la "arquitectura de plugins" (descrita en el link previo). La idea es poder extender el framework indefinidamente, pero de forma controlada y gestionable, mediante "plugins" o "agregados". Por ejemplo, en el Yupp Connect que hicimos hace pocos días, hablamos de poder contar con un "módulo" de gestión de usuarios y permisos, que cualquier aplicación pudiera usar. Este es un claro ejemplo de lo que llamo "plugin": algo que no es parte del core o núcleo del framework, pero que tampoco es una aplicación, sino que es algo que está en el medio y que las aplicaciones pueden usar.


¿Cómo seguimos?
  1. Lee las "ideas de mejoras" que hay publicadas en la wiki, comenta al respecto en la misma wiki o respondiendo a este hilo. Los comentarios se convertirán en mejoras a las ideas propuestas. 
  2. Proponé nuevas ideas para extender y mejorar el framework respondiendo a este hilo de discusión. Todas las ideas serán tomadas en cuenta y debatidas para lograr especificarlas lo más posible, luego haremos una votación en la comunidad para detectar las ideas más útiles o novedosas. Estas serán en las que nos concentraremos para su desarrollo.
  3. Si tienes algún desarrollo ya hecho, que pueda servir para integrar con el framework, también puedes proponerlo, y entre todos los podemos evaluar. Lo que se debe considerar en este caso, es que el dueño del código debe dar soporte al mismo y documentación, además deberá ayudar en la integración con el framework. Esto es para mantener el nivel del framework y no integrar código que no tiene documentación y al que nadie puede dar soporte.

¡Espero sus comentarios e ideas!
  
 

viernes, 10 de junio de 2011

Nuevo Yupp PHP Framework v0.4

Estamos muy contentos de anunciar la liberación de la nueva versión de Yupp PHP Framework.


En esta versión se incluyen varias mejoras y correcciones que hacen al framework más simple de usar y más completo en cuanto a su funcionalidad de base. Además hemos actualizado la documentación de referencia para facilitar la tarea de quienes están comenzando a usar el framework.

Como siempre, el framework podrá ser descargado desde nuestro sitio en Google Code:
http://code.google.com/p/yupp/

Aquí podrás encontrar los detalles de los cambios y mejoras hechos en esta nueva versión:
http://code.google.com/p/yupp/wiki/Hoja_de_ruta#v0.4:_codename_Genesis_3_%28liberado%29

Las notas de la versión con detalles de las pruebas realizadas, de la instalación del framework y mucha información útil para comenzar a usar el framework, las puedes encontrar aquí:
http://code.google.com/p/yupp/wiki/YuppPHPFrameworkv04

La documentación actualizada la puedes encontrar aquí:
http://www.simplewebportal.net/yupp_framework_php_doc/

Pronto estaremos actualizando las aplicaciones en nuestro sitio de Yupp Apps para aprovechar al máximo las novedades de esta versión del framework:
http://code.google.com/p/yupp-apps/

Como siempre, todas las consultas y comentarios serán recibidas en nuestro sitio de Google Groups:
http://groups.google.com/group/yuppframeworkphp

martes, 31 de mayo de 2011

Yupp Connect

¿Cuál es la idea?

Tomar un par de horas para hablar del framework, de cómo usarlo, de cómo se podría adaptar para encarar sus proyectos, resolver dudas de programación o simplemente charlar de conceptos generales en tecnología, mejores prácticas, gestión de proyectos, patrones de diseño, etc.


¿Cómo y cuando?

Nos conectamos por Skype (mi usuario es simplewebportal.net).

La primera charla la hacemos el miércoles 8 de Junio, a las 15 horas de Montevideo (puedes ver tu horario local aquí: http://timeanddate.com/worldclock/).

Un par de días antes, voy a crear un hilo de discusión donde quienes estén interesados en conectarse, pueden proponer temas. Igualmente, para romper el hielo, voy a proponer un par.


¿Qué se espera de ti?

Primero que nada, ponerle buena onda. Luego, el objetivo es charlar de cosas interesantes para ti, de tus proyectos, de tus dudas sobre el framework y su funciomiento, de problemas que tratas de resolver o que te gustaría resolver en el futuro usando el framework, del futuro del framework como proyecto, entre otros.


Más info.

Temas:



Hasta el miércoles!,
Pablo.

PD: esto se haría aparte, no sustituyendo, a las charlas por LiveStream (http://www.livestream.com/yuppphpframework) sobre el framework.

lunes, 23 de mayo de 2011

Google Code Playground



Google Code Playground es un sitio de pruebas en vivo, por donde todo programador que quiera utilizar APIs de Google debería pasar.

Este sitio presenta ejemplos de casi todas las APIs de Google, incluyendo:

Ya sea que vamos a jugar un poco, o que vamos a utilizar las APIs de Google para nuestros proyectos, este es un sitio para tener siempre en las bookmarks...

sábado, 21 de mayo de 2011

Videos del tutorial virtual

Estimados, aquí dejo las dos partes del tutorial para quienes no pudieron estar en el momento de la emisión. Las consultas que tengan las pueden realizar en nuestro grupo.


Watch live streaming video from yuppphpframework at livestream.com


Watch live streaming video from yuppphpframework at livestream.com

jueves, 19 de mayo de 2011

Link para el tutorial virtual de hoy

El tutorial virtual de Yupp PHP Framework de hoy, a las 18:30 (GMT -03:00) lo hacemos por LiveStream http://www.livestream.com/yuppphpframework

De haber problemas, lo haremos por skype con solo sonido. Mi usuario de skype es simplewebportal.net

Saludos,
Pablo.

viernes, 13 de mayo de 2011

Día y hora del tutorial virtual de Yupp

Estimados,

El tutorial virtual del framework se llevará a cabo el día jueves 19 de mayo a las 1830 (hora de Montevideo, GMT -03:00). Por favor verifiquen su uso horario para saber a qué hora local corresponde. Por ejemplo, Buenos Aires está en el mismo uso horario que Montevideo. Caracas está en GMT -04:30, o sea que la hora local de inicio en Caracas será a las 1700. Para ver la diferencia horaria en distintas ciudades, les dejo este sitio: http://timeanddate.com/worldclock/

La idea es que lo hagamos en una hora y media, dos horas máximo con preguntas y comentarios. Por favor agenden ese día, y no se preocupen si no pueden a esa hora, que ya haremos otros eventos de este tipo.

Yo estaré conectado un rato antes para realizar pruebas. Quienes puedan estar antes, les agradezco, así podemos verificar que la comunicación es correcta.

El evento lo haremos por UStream (http://www.ustream.tv/channel/yupp-php-framework), y en caso de haber problemas, tenemos la alternativa de LiveStream (http://www.livestream.com/yuppphpframework). El plan C, si nada funciona correctamente, sería mediante skype. Mi usuario en skype es: simplewebportal.net

Todos los que se anotaron al tutorial, recibirán este mismo correo, y además el link para descargar todo el material necesario para el tutorial. Este material será publicado luego del tutorial para todos quienes quieran tenerlo y no hayan podido estar. Este incluye: documentación, presentación guía, última versión del framework, y aplicaciones de ejemplo con las que estaremos jugando un poco.

La idea de este primer tutorial virtual es que sea muy llevado de la mano, para que todos los que recién empiezan con el framework puedan  sus primeros pasos sobre firme, entender algunos conceptos clave, y
llegar a crear aplicaciones sencillas. Luego haremos otros eventos virtuales, donde tocaremos temas concretos y más complejos, y dará más para la discusión. La idea que esta segunda parte la podamos hacer en un par de semanas luego de este evento. Luego daré una lista de temas que les pueden interesar, así tocamos primero los temas que más les interesen.

No está de más decir que estos eventos son gratuitos y totalmente libres para todos quienes quieran acercarse al proyecto para concerlo, probarlo, evaluarlo y usarlo. El objetivo de estos eventos es consolidar la comunidad Yupp, para darle continuidad al proyecto, y poder mejorarlo entre todos.

Muchas gracias a todos, espero que podamos hacer de este primer evento un éxito, ¡y que sea el primero de muchos!

¡Un saludo desde mi paisito Uruguay!
Pablo.

viernes, 29 de abril de 2011

Tutorial de Yupp Framework version virtual

Estoy armando una versión virtual del tutorial. Les cuento un poco lo que pasó en la versión presencial y las ideas para el virtual, cualquier comentario o duda es todo bienvenido.

Hace unos días hicimos un taller de Yupp PHP Framework en Montevideo, Uruguay.

La idea fue dar a conocer el framework a quienes no lo conocían, e ir de conceptos básicos de funcionamiento, instalación y configuración, hasta la creación de una aplicación web completa con algún grado de dificultad.

Los participantes llevaron sus notebooks, y les dimos todo el material necesario para que pudieran instalar el framework y ejecutar los ejemplos en sus propias computadoras.

Muchos desarrolladores me han preguntado si se podría hacer el evento en otros países, y tengo ganas de organizar algo virtual para que todos puedan participar (aunque sea por curiosidad) desde sus casas u oficinas. Voy a pensar un poco más cómo podría implementarse esto. Si tienen sugerencias, son bienvenidas. Por ahora sería:

- Audio por Skype
- Visualización de documentos y presentaciones por Google Docs
- Consultas por chat (Google Talk o mismo Skype)
- Todo el material lo tienen para descargar por lo que pueden seguirlo cada uno localmente

Por ahora dejo disponible todo el material del taller que puede descargarse aquí: http://yuppframework.blogspot.com/2011/04/post-mortem-del-tutorial-de-yupp.html
Esto contiene un documento hecho especialmente para el taller, la presentación, el framework, aplicaciones de ejemplo y el software de base necesario (usamos WAMP y Notepad++).

He creado un formulario para organizar a los interesados en participar del evento virtual, si quieren participar pueden poner sus datos aquí: https://spreadsheets.google.com/spreadsheet/viewform?formkey=dFlpbW8ySVljS1dPZmNaaGJpOTFQREE6MQ



sábado, 23 de abril de 2011

Post mortem del tutorial de Yupp

El pasado viernes 15 de abril se llevó a cabo el primer tutorial de Yupp PHP Framework "manos a la obra con Yupp Framework".

La idea central fue empapar a los asistentes en el uso del framework y sus posibilidades, por esta razón fuimos desde la instalación del framework a la creación de una aplicación web simple, pero con algún nivel de complejidad en la parte de ORM.

A los asistentes se les entregó todo el material, que también está disponible en línea para todos los que deseen tenerlo. Este material consiste en el software de base necesario, en la versión "trunk" del framework, un documento especialmente diseñado para el tutorial, la presentación utilizada, y una serie de aplicaciones. Las aplicaciones son en realidad, distintas versiones de la misma aplicación, la cual evoluciona a medida que avanza en tutorial, agregando complejidad para mostrar distintos aspectos del framework.

Gracias a esta primer experiencia, la idea es mejorar el tutorial y repetirlo en Uruguay y en la región. Muchos desarrolladores argentinos me han consultado sobre hacerlo ahí. Ojalá podamos organizar algún evento pequeño con la comunidad argentina de desarrolladores web.

Aquí dejo un par de fotitos del evento:


miércoles, 6 de abril de 2011

Tutorial Yupp PHP Framework: manos a la obra

Sobre el evento:

El objetivo de este tutorial es mostrar cómo se trabaja con el framework, simplificando tareas repetitivas y disminuyendo al máximo las necesidades de configuración.

La entrada es libre y gratuita. Se aconseja traer laptop/notebook para poder realizar pruebas de instalación e implementar algunas aplicaciones sencillas. Para quienes tengan Windows, se aconseja tener WAMP (http://www.wampserver.com) instalado.

Dictado por Ing. Pablo Pazos Gutiérrez (http://www.linkedin.com/in/pablopazosgutierrez).

Apoya: LINS (http://www.fing.edu.uy/inco/grupos/lins/projects.html)


Día y hora:

Viernes 15 de abril de 2011, a las 20 horas.


Lugar:
En el salón C11 del edificio polifuncional Faro (Julio Herrera y Reissig 631, al lado de Facultad de Ingeniería http://www.fing.edu.uy/)

Ver en Google Maps


Temario:
  • Fundamentos de patrones MVC y ORM
  • Fundamentos de programación ágil y aplicaciones web
  • Instalación y configuración del framework
  • Estructura de Yupp Framework
  • URLs en Yupp
  • Creando una aplicación simple: hello world
  • Estructura de las aplicaciones Yupp
    • Configuración de la base de datos por aplicación
    • Script de bootstrap
    • Scripts de testing
  • Model:
    • Creando modelos de datos complejos: hasOne, hasMany, herencia
    • Creando restricciones sobre campos y relaciones
  • View:
    • Fundamentos de implementando vistas.
    • Uso de helpers.
    • Helpers layout y template.
    • Integración de liberías Javascript.
    • Vistas scaffolded.
  • Controller:
    • Convenciones.
    • Render vs Redirect.
    • Recibiendo archivos.
    • Devolviendo XML o JSON.
    • Acciones scaffolded.
  • Mejoras para las próximas versiones de Yupp PHP Framework.


Sobre Yupp:

Yupp PHP Framework es una herramienta ágil para el desarrollo de aplicaciones web orientadas a objetos. Yupp implementa el patrón arquitectónico Modelo-Vista-Controlador, y posee una herramienta ORM para la persistencia de objetos. Yupp está desarrollado sobre PHP5 y trabaja con distintos DBMS como MySQL, PostgreSQL y SQLite. Por más info:

Una característica a destacar es que este framework fue desarrollado en Uruguay.


Por más información:

martes, 15 de marzo de 2011

Tutorial manos a la obra con Yupp

Estamos preparando un tutorial para el mes de abril con el objetivo de dar los fundamentos básicos para el desarrollo de aplicaciones web usando Yupp PHP Framework.

Si bien la temática aún no está 100% definida, el hilo de temas será muy parecido al siguiente:
  • Fundamentos de patrones MVC y ORM
  • Fundamentos de programación ágil y aplicaciones web
  • Instalación y configuración básica del framework
  • Estructura del framework
  • URLs en Yupp
  • Creando una aplicación simple: hello world
  • Estructura de las aplicaciones Yupp
  • Model:
    • Creando modelos de datos complejos: hasOne, hasMany, herencia
    • Creando restricciones sobre campos y relaciones
  • View:
    • Fundamentos de implementando vistas.
    • Uso de helpers.
    • Helpers layout y template.
    • Integración de liberías Javascript.
    • Vistas scaffolded.
  • Controller:
    • Convenciones.
    • Render vs Redirect.
    • Recibiendo archivos.
    • Devolviendo XML o JSON.
    • Acciones scaffolded.
  • Mejoras para las próximas versiones del framework.

Este temario podrá variar de aquí al evento.

El lugar será en Facultad de Ingeniería, Universidad de la República, Montevideo, Uruguay. Luego publicaremos el día y hora exactos.

 .

martes, 1 de marzo de 2011

Nuevo Yupp PHP Framework v0.3

Estamos muy contentos de anunciar la liberación de la nueva versión de Yupp PHP Framework.


En esta versión se incluyen varias mejoras y correcciones que hacen al framework más simple de usar y más completo en cuanto a su funcionalidad de base. Además hemos actualizado la documentación de referencia para facilitar la tarea de quienes están comenzando a usar el framework.

Como siempre, el framework podrá ser descargado desde nuestro sitio en Google Code:
http://code.google.com/p/yupp/

Aquí podrás encontrar los detalles de los cambios y mejoras hechos en esta nueva versión:
http://code.google.com/p/yupp/wiki/Hoja_de_ruta#v0.3:_codename_Genesis_2_%28liberado%29

Las notas de la versión con detalles de las pruebas realizadas, de la instalación del framework y mucha información útil para comenzar a usar el framework, las puedes encontrar aquí:
http://code.google.com/p/yupp/wiki/YuppPHPFrameworkv03

La documentación actualizada la puedes encontrar aquí:
http://www.simplewebportal.net/yupp_framework_php_doc/

Pronto estaremos actualizando las aplicaciones en nuestro sitio de Yupp Apps para aprovechar al máximo las novedades de esta versión del framework:
http://code.google.com/p/yupp-apps/

Como siempre, todas las consultas y comentarios serán recibidas en nuestro sitio de Google Groups:
http://groups.google.com/group/yuppframeworkphp


¡Hasta pronto!

martes, 15 de febrero de 2011

Inminente liberación de Yupp v0.3

Llegamos a un punto donde la próxima liberación de Yupp PHP Framework se hace inminente.

Desde la versión anterior (Yupp Genesis v0.2.5) se han hecho varias correcciones, verificaciones y agregado nuevas funcionalidades. En nuestra wki se pueden encontrar los cambios realizados: http://code.google.com/p/yupp/wiki/Hoja_de_ruta#v0.3:

La nueva versión de Yupp seguramente estará disponible para descargar luego de actualizar las notas de la versión y la documentación del proyecto: http://www.simplewebportal.net/yupp_framework_php_doc/

Igualmente, todo el código fuente de esta nueva versión ya se encuentra en nuestro repositorio de versiones: http://yupp.googlecode.com/svn/YuppPHPFramework/

La versión 0.3 de Yupp Framework será conocida por el nombre clave: Yupp Genesis v2.

miércoles, 2 de febrero de 2011

Movix: gestor de peliculas hecho en Yupp

Movix es una pequeña aplicación que implementé para gestionar mi colección de películas, de modo de saber qué películas tengo y tener un mecanismo fácil para buscar y ordenar películas cuando tengo ganas de ver algo específico.



Esta aplicación básicamente es un proxy que realiza búsquedas de películas en IMDB (http://www.imdb.com), y mediante técnicas de web scrapping, obtiene el contenido buscado y lo guarda en la base de datos local. Nada del otro mundo. La aplicación completa no supera los 127 KB.

Una de las características que más me gustó como quedó implementada es la de mostrar el ranking de la película como una barra coloreada, donde si la película recibe una puntuación de más de 75% se ve en verde y de menos del 30% se ve en rojo, pasando por un par de grados intermedios. Además se puede ordenar por ranking (ver las mejores rankeadas primero). Otra característica útil es la de filtrado por género, de modo que puedo querer una de "acción", y ordenando por rankeo puedo elegir entre las mejores.

Aquí se puede descargar esta y otras aplicaciones: http://code.google.com/p/yupp-apps/

Nota: si bien es una aplicación funcional, no está garantizado que funcione en el 100% de las búsquedas, debido a que las reglas de obtención de la información son estáticas y las páginas de IMDB pueden cambiar en cualquier momento, de todos modos se puede ir adaptando la aplicación a los cambios de IMDB.