Mostrando entradas con la etiqueta symfony. Mostrar todas las entradas
Mostrando entradas con la etiqueta symfony. Mostrar todas las entradas

martes, 9 de septiembre de 2008

Experimentado con ArgoUML y CodeIgniter

Llevaba bastante tiempo con ganas de probar Codeigniter. Después de comparar Symfony y Zend Framework hace unos cuantos meses, alguien me sugirió hacerlo. Por cierto con los avances que han tenido cada uno de estos proyectos dicha comparativa está prácticamente obsoleta.

La semana pasada empecé a trastear con CodeIgniter y volví a darle vueltas a la cuestión de que no tuviera una serie de comandos para ayudar con la generación de controladores, modelos, etc. Así que se me ocurrió utilizar mi querido ArgoUml para "pintar" las clases y después generarlas en los directorios del proyecto.

El genearador de código PHP

Entonces me di de bruces con lo que para mí es un viejo problema en la generación de clases de ArgoUML: añade el prefijo "class." al nombre de tu clase como nombre de fichero. Es decir, si tu clase se llama Clientes obtendrás un fichero de nombre class.Clientes.php. Me topé por primera vez con esto en un proyecto llevado a cabo en mi trabajo en el que la capa de presentación está hecha en Flex y el resto en PHP. Nos encontramos con la restricción, por parte de AmfPHP, de que el nombre de las clases y los ficheros que la contienen debe ser el mismo. Esta misma obligación nos la encontramos en CodeIgniter, o sea, nuestra clase Clientes deberá encontrarse en el fichero clientes.php.

Otro convenio utlizado por ArgoUML me terminaría afectado: el nombre de las clases generadas tiene antepuesto toda la cadena de paquetes de la que depende. Me explico: si nuestra clase Clientes pertenece al paquete modelo, tomará como nombre modelo_Clientes.

Estuve pensando como salvar esta dificultades pero las cosas que se me ocurrían no eran muy limpias. Finalmente opté por una solución que tampoco es como para estar orgulloso pero me pareció con bastante diferencia la mejor: recompilar el módulo generador de código PHP de ArgoUML a mi gusto.

¡Viva el código libre! Un par de cambios y a volar

Pues nada a navegar por la página de Argo y buscar el código fuente del subproyecto ArgoUML-PHP. No cuesta mucho dar con el repositorio SVN así que un checkout y ya tenía el código en mi PC.

Después de esto tengo que reconocer que la cosa fue bastante fácil, si no, os aseguro que la pereza hubiese podido conmigo. El código descargado viene con el archivo de proyecto para abrirlo en Eclipse. Nos encotraremos algún problema de dependencias con archivos .jar que podremos obtener de la propia instalación de Argo. Una vez resueltas sólo hay que abrir el fichero NameGenerator.java y localizar dos porciones de código.

La primera corresponde a la nomenclatura de las clases con el prefijo de paquetes. Hay que comentar el código tal como veis aquí:


public static final String generateClassifierName(Object modelElement) {
if (!Model.getFacade().isAClassifier(modelElement)) {
throw new ClassCastException(modelElement.getClass()
+ " has wrong object type, Classifier required");
}

String sName = Model.getFacade().getName(modelElement);

/*String sPackageName = generatePackageName(modelElement);
if (sName != null && sPackageName != null
&& sPackageName.length() > 0) {
sName = sPackageName + "_" + sName;
}*/

return sName;
}


El segundo cambio es el del nombre del fichero:


if (iMajorVersion > 4) {
if (Model.getFacade().isAInterface(modelElement)) {
sFilename += "interface.";
} else if (Model.getFacade().isAClass(modelElement)) {
sFilename += "class.";
} else {
sFilename += "unknown.";
}
}


se cambia la cadena "class." por la vacía y resuelto.

Después de hacer esto creamos nuestro .jar y sustituimos el existente en el directorio /ext de la intalación de ArgoUML. Al principio el programa no me lo cogía, al generar código no me aparecían las opciones PHP4 ni PHP5, finalmente lo resolví eliminado el archivo manifest del .jar.



Modelando

Lo primero que tendremos que hacer es imitar la parte de la estructura de CodeIgniter que nos interesa. Para ello crearemos un proyecto nuevo en Argo y después un paquete llamado models y otro llamado cotrollers. Hacemos esto para que llegados al momento de generar código asignemos como ruta nuestro path a Codeigniter/system/application y cada una de las clases vayan a su directorio correspondiente.



Aviso que necesitaremos añadir al path de PHP la ruta hasta CodeIgniter/system/application por la forma en la que Argo nos escribirá los requires entre clases.

Ya solo nos queda un quebradero de cabeza. Todas nuestras clases de controlador deberían heredar de la clase Controller de CodeIgniter pero si representamos la misma en nuestro modelo se nos creará un require de una clase que no debería existir (ya está definida en el framework). La solución que se me ocurrió para esto fue añadir una clase adaptador MiController que hereda de Controller de Codeigniter. Esta clase la generaremos sólo una vez ya que después le añadiremos en el editor "extends Controller" y si volvemos a generarla machacaremos el cambio y tendremos que volver a escribirlo. Después todas las clases controlador que creemos heredarán de MiController.


class MiController extends Controller
{
// --- ASSOCIATIONS ---


// --- ATTRIBUTES ---

// --- OPERATIONS ---

/**
* Short description of method __construct
*
* @access public
* @return mixed
*/
public function __construct()
{
// section -87--2--75--55--89caeb7:11c46a97fcc:-8000:00000000000008BA begin
parent::__construct();
// section -87--2--75--55--89caeb7:11c46a97fcc:-8000:00000000000008BA end
}

}


Lo mismo nos ocurrirá con las clases modelo pero la solución es exáctamente la misma.


class MiModelo extends model
{
// --- ASSOCIATIONS ---


// --- ATTRIBUTES ---

// --- OPERATIONS ---

/**
* Short description of method __construct
*
* @access public
* @author Depto. Web/WAP de Alvento Soluciones, <guillermo@alvento.com>
* @return mixed
*/
public function __construct()
{
// section -87--2--75--55-438df237:11c46b7f1db:-8000:0000000000000878 begin
parent::Model();
// section -87--2--75--55-438df237:11c46b7f1db:-8000:0000000000000878 end
}

} /* end of class MiModelo */


Una vez hecho esto podremos modelar tranquilamente creando nuestras clases, modificándolas en Argo y volviendo a generar el código sin perder lo que hayamos escrito en el IDE (como ya expliqué en su día)




martes, 22 de abril de 2008

Posts de interés

No os voy a contar mi vida. Sólo diré que estoy en horas bajas y no puedo terminar ninguno de los artículos que tengo pendientes, así que os dejo algunos posts interesantes que he leído estas últimas semanas.

Joomla y capa de presentación para móviles. De uno de los tipos que más sabe sobe presentación móvil. Interesante artículo para aquellos que quieran adaptar su aplicación Joomla a terminales móviles.

Presentación
sobre testeos con PHPUnit, DBUnit, etc. Una buena lectura para iniciarse con PHPUnit y demás-

Guerra de frameworks. Respuesta de un desarrollador Symfony a otr de Rubi on Rails ¿Que puedo decir? si alguien se enzarza en una guerra dialéctica más vale saber de que se habla.


Peticiones simultaneas en PHP usando CURL. En realidad no son tan simultaneas y recomiendo probar su viabilidad antes de implantarlo. En nuestro caso finalmente lo desechamos.

Situación del UML. Esta es la causa de mi anterior post sobre el uso de UML.

Modelo de contrato ágil
. Solo es un patrón pero me parece interesante.

miércoles, 12 de marzo de 2008

Symfony vs Zend Framework. 4- ¿Cuál nos quedamos?

Artículos de la serie:
  1. Definición del problema
  2. Comencemos con Symfony
  3. Turno de Zend Framework
  4. ¿Cuál nos quedamos?
Después de que en la primera parte definieramos los requisitos de una pequeña aplicación y las implementásemos en los dos siguientes capítulos con los correspondientes frameworks, llega el momento de sacar unas cuantas conclusiones. Recordemos que el punto de vista de esta comparación es el de alguien que sólo ha dedicado unas cuantas horas a cada uno de los dos, así que debemos ser conscientes de que solo hemos visto la punta del iceberg y que tal vez por ello las conclusiones no sean del todo justas.

Forma de trabajo

En primer lugar hay ciertas diferencias a la hora de trabajar con ellos. Symfony hace uso de la linea de comandos para facilitarnos muchas tareas monótonas mintras que ZF todavía no lo incorpora. Cuando este último posea esta carácterística habrá que analizar si realmente equivaldría al otro en cuanto a funcionalidades. Por otro lado en Symfony tendremos que crear y retocar archivos YAML para ciertas cosas como validar formularios y como configuración de diversos aspectos.

A parte de esto, la forma de trabajar será muy parecida debido a que ambos responden a un patrón MVC y tendremos que recurrir continuamente a modificar clases relativas a acciones, revisar archivos plantilla, etc.

Curva de aprendizaje

Aquí toma clara ventaja ZF porque símplemente hemos de documentarnos a través de la guía de referencia para conocer las clases existentes y sus funciones. En Symfony, además de lo anterior, tendremos que familiarizarnos con Yaml, averiguar que podemos hacer y que no con los comandos de CLI y manejarnos por diferentes archivos de configuración, lo que implica familiarizarse con la estructura de archivos del proyecto.

La guerra de los plugins

Es posible encontrar una gran cantidad de plugins no oficiales para Symfony los cuales se pueden instalar, como no, haciendo uso de la linea de comando. Por otro lado ZF no distingue como plugins una serie de clases que tendrían que ver con la utilización de APIs externos, ya que forman parte de la distribución, pero sí que los identifica como servicios (Zend_Service_Amazon, Zend_Service_Flickr, etc) Es posible que nuestra elección deba centrarse en este aspecto si queremos comenzar un proyecto de tipo mashup y aquí Symfony tiene ventaja por la gran cantidad de recursos que pone a nuestra disposición.

Comandos sí o no

ZF necesita incorporar los comandos de CLI para llegar a la altura de Symfony, deberían darle un empujón definitivo a ese aspecto. De todos modos hay partidarios de no utilizarlos así que este hecho puede ser determinante para la gente que se posicione al respecto.

Otros aspectos

Otros puntos a favor de Symfony, aunque no he llegado a probarlos, son el soporte que proporciona para tests unitarios y funcionales, la integración de subversion y la sincronización de código entre los entornos de desarrollo, pruebas y producción.

Conclusiones

Desde mi punto de vista Symfony goza de ventaja sobre ZF por poseer los comandos de CLI , la gran cantidad de plugins exsitentes, el entorno de desarrollo con el menú flotante de información de debug, soporte para tests, etc.

Además de todo esto puede incluir a ZF como una biblioteca de clases. De hecho puede hacer esto mismo con otros frameworks. Para incluir ZF haríamos esto:

Declarar en settings.yml
.settings:
zend_lib_dir: /usr/local/zend/library/
Después extenderíamos la rutina autoload
.settings:
autoloading_functions:
- [sfZendFrameworkBridge, autoload]

Además Symfony cuenta con una gran comunidad que a parte de los plugins puede ofrecer algún extra interesante como Symfoclipse que nos permite usar los comandos de este a través de Eclipse en un menú contextual.



Por contra ZF goza de la simplicidad de aprendizaje que hemos comentado anteriormente, la libertad a la hora de definir nuestras estructuras de archivos y la flexibilidad a la hora de instanciar clases que comentamos en el capítulo precedente.

Algo que podría hacer Zend Technologies para impulsar su framework sería integrarlo con el entorno PDT de Eclipse. Estaría muy bien encontrar en el menú de creación de proyectos algo así como "Nuevo proyecto Zend Framework" y que al elegirlo nos creara una estructura de archivos inicial para adelantarnos trabajo, además, es algo que ya incorpora Zend Studio. En segundo lugar, por supuesto, tiene que potenciar como sea a la comunidad de desarrolladores para que creen mas "clases servicio". Es cierto que están haciendo un gran esfuerzo y que ZF crece rápidamente, está ganando muchos adeptos y por tanto están surgiendo muchas webs que lo utilizan.


Estamos ante dos rivales destinados a luchar una larga batalla y aunque, para mí, uno tenga ventaja, estoy seguro de que el otro irá recortando la diferencia. Deberemos elegir uno u otro en función de las situación que nos encontremos: sí se desea simplicidad y no perder mucho tiempo en la fase de aprendizaje ZF será lo más apropiado. Por el contrario, Symfony es mucho más completo y dispone de muchos, muchos más plugins. Hoy por hoy si tuviera que escoger uno de ellos elegiría Symfony pero ya veremos dentro de unos meses.

domingo, 17 de febrero de 2008

Symfony vs Zend Framework. 2- Comencemos con Symfony

Artículos de la serie:
  1. Definición del problema
  2. Comencemos con Symfony
En el capitulo anterior planteamos una pequeña aplicación para comparar Symfony y Zend Framework. En este parte empezaremos con el primero de los citados no sin antes recordar que, aunque pueda parecerlo en ciertos momentos, esto no es un tutorial ya que no se citan todos y cada uno de los paso dados para llegar a la aplicación final.

Antes de nada... ¡a leer!

Partiendo de unos conocimientos nulos sobre Symfony, si rebuscamos un poco en su portal web, encontraremos una par de cosas interesantes para hacernos a la idea de cómo empezar a trabajar.

http://www.symfony-project.org/tutorial/1_0/my-first-project
http://www.symfony-project.org/book/1_0/

El primero de los enlaces es un tutorial rápido en el que curiosamente se desarrolla un ejemplo muy similar al nuestro. Es obvio que ha resultado bastante útil a la hora de hacer esta prueba. Las principales diferencias con nuestro caso son:
  • Nuestro requerimiento de utilizar una base de datos MySQL.
  • El diseño de nuestras tablas, que no aprovecha las ventajas de las nomenclaturas predefinidas para los ficheros YAML.
  • Nuestro diseño gráfico que aplicamos de una forma bastante realista (como si un equipo de diseño nos lo entregara maquetado)
El segundo enlace es un libro que podremos consultar en formato html, obtenerlo impreso o, incluso, en formato PDF traducido al español gracias a librosweb.es Si bien no es necesario leerlo por completo para realizar este ejemplo de aplicación, no vendrá mal darle un vistazo rápido y tenerlo a mano para consultar alguna duda.

Además de esto tendremos toda la documentación habitual sobre el API a la que podremos recurrir cuando lo necesitemos

Diseñando la BD

Recordamos el diseño comentado en el capítulo anterior según el cual un artículo podía tener muchos comentarios de lectores:



En Symfony tentemos que plasmar nuestros diseños en YAML, así que para el diagrama anterior el archivo schema.yml correspondiente sería:
propel:
blog_articulo:
_attributes: { phpName: Articulo }
idarticulo: { type: integer, required: true, primaryKey: true, autoIncrement: true }
titulo: varchar(255)
cuerpo: longvarchar
fecha_creacion: {timestamp}
blog_comentario:
_attributes: { phpName: Comentario }
idcomentario: { type: integer, required: true, primaryKey: true, autoIncrement: true }

idarticulo: { type: integer, foreignTable: blog_articulo, foreignReference: idarticulo, onDelete:cascade }
author: varchar(255)
email: varchar(255)
body: longvarchar
fecha_creacion: {timestamp}

Una vez más hay que recordar que había una forma más fácil de hacer esto y es realmente la recomendable, consiste en usar ciertos nombres de campos preestablecidos para claves primarias, claves externas y campos de fecha. La siguiente definición se correspondería con ello:

propel:
blog_articulo:
_attributes: { phpName: Articulo }
id:
titulo: varchar(255)
cuerpo: longvarchar
created_at:
blog_comentario:
_attributes: { phpName: Comentario }
id:
articulo_id:
author: varchar(255)
email: varchar(255)
body: longvarchar

created_at:

Después de ejecutar este paso es natural pensar que alguien que se adentre en este framework deberá familiarizarse con el lenguaje YAML y con Propel. Esto incrementa un poco la curva de aprendizaje. Como anécdota basta decir que el que escribe esto perdió bastante tiempo hasta conseguir hacer funcionar el fichero YAML mostrado anteriormente y todo por culpa de un salto de linea que pasaba inadvertido.

Cargando el resultado en mysql

Como ya tenemos nuestro fichero de descripción de la base de datos, continuaremos generando las clases de nuestro modelo, que quedará alojado en sf_sandbox/lib/model/ y nos permitirá actuar con la base de datos sin utilizar sentencias SQL.

php symfony propel-build-model

Si como es nuestro caso la aplicación parte desde cero y no tenemos la base de datos creada en nuestro servidor, nos vendrá bien utilizar el siguiente comando para generar el archivo de intrucciones SQL que podremos utilizar más tarde:

php symfony propel-build-sql

Gracias al archivo generado y disponible en la ruta data/sql/lib.model.schema.sql podremos importar el diseño de la base de datos a nuestro servidor MySQL. Para ello usaremos la linea de comandos, la opcion restaurar de MySQL Administrator, PHPMyAdmin, etc. Alternativamente podríamos utilizar la instruccion:

php symfony propel-insert-sql

Esta instrucción es útil si lo tenemos todo bien configurado con Symfony para que actúe sobre el serividor MySQL ya que por defecto generará una base de datos SQLite. De hecho en nuestro caso ha sido necesario modificar la configuración para poder trabajar con MySQL.

Un poco de magia

Los formularios de creación, modificación y eliminación de datos, suelen ser una tarea bastante tediosa y monótona. Por suerte Symfony nos puede librar casi por completo de ello, y decimos casí porque es cierto que siempre terminaremos retocando algo de los formularios. Esto lo conseguimos en nuestro caso haciendo lo siguiente:

php symfony propel-generate-crud frontend articulo Articulo
php symfony propel-generate-crud frontend comentario Comentario
php symfony clear-cache

Modulos y acciones

Llegados a este punto tenemos gran parte de la lógica interna de nuestra aplicación desarrollada. Gracias a los comandos que acabamos de ejecutar, dentro del directorio frontend/modules tendremos creados los módulos articulo y comentario. Cada uno de ellos contiene los directorios actions y templates. De momento nos ocuparemos del primero, donde encontraremos el fichero actions.class.php En este fichero se nos ha creado una clase que contiene todas las acciones del módulo y que por supuesto podremos modificar según nuestras necesidades.

Sin entrar mucho en detalle, en nuestro modulo articulos tendremos, en el fichero actions.class.php, la clase articuloActions que contendrá, entre otras, las siguientes funciones:
  • executeList: muestra el listado de artículos utilizando la plantilla listSuccess.php
  • executeShow: muestra un determinado artículo utilizando la plantilla showSuccess.php
  • etc.
Por poner un ejemplo nosotros hemos modificado executeList para que muestre los artículos por orden descendente de fecha:
public function executeList()
{

$this
->nombreModul=$this->getModuleNam();
$c=new Criteri();
$c->addDescendingOrderByColum(ArticuloPeer::FECHA_CREACION);
$thi->articulos = ArticuloPeer::doSelect($c
);
}

Adaptando nuestro diseño inicial

En la introducción a esta serie escogimos el diseño Pluralism. Es el momento de adaptarlo a nuestra aplicación, para ello tomaremos el archivo css (style.css) y lo copiaremos en la ruta /web/css. Para hacer que nuestra web lo lea añadiremos la siguiente linea al archivo layout.php que se encuentra en /apps/frontend/templates/

php echo stylesheet_tag('style') ;

Por supuesto insertaremos esta linea antes del fin de la etiqueta html head.

Después de esto remaquetamos nuestro layout.php copiando el código html proporiconado por Pluralism. Es decir que añadimos las capas wrapper y todo lo que necesitemos para obtener el resultado esperado. Mostraremos parte del código:
<body>
<div id="wrapper">
<div id="wrapper2">
<div id="header">
<div id="logo">
<h1&gt
<?php echo link_to('Janfri Bloggart', '@homepage')?></h1>
</div>
<div id="menu">
<ul>
<li&gt
<?php echo link_to('Crear entrada','articulo/create')?></li>
<li&gt
<?php echo link_to('Lists de articulos','articulo/list')?></li>
</ul>
</div>
</div>
<!-- end #header -->
<div id="page">
<div id="content">
<?php echo $sf_data->getRaw('sf_content')?>
</div>


Observese que introducimos un link a la home como título y que en la zona de menús dejamos dos links más.

Con la instrucción $sf_data->getRaw('sf_content') mostramos la información correspondiente a la acción invocada del módulo actual.

Para mostrar el listado de títulos de posts recientes nos hemos ayudado creando una plantilla auxiliar llamada _articulos_listado.php que hemos hubicado en modules/articulo/templates/ Este tipo de plantillas se incluyen mediante la instrucción inclde_partial:

include_partial('articulo/articulos_listado',array('articulos'=>$articulos
));

Por lo demás, el trabajo en la capa de presentación se basa en modificar las plantillas existentes, por ejemplo, a la hora de dar de alta un artículo hemos cambiado el "select" cargado con los artículos existentes por un input hidden con el valor del articulo a comentar. De otro modo: Simfony es listo pero no perfecto. Nos ha proporcionado un formulario de creación de comentarios en el que podríamos elegir el artículo a comentar mediante un "select" pero no era lo que queríamos. También hemos ampliado los textarea que nos ha creado para el cuerpo de los artículos y los comentarios, por citar otro ejemplo.











Conclusiones


Tras todo lo comentado anteriormente llegamos a la conclusión de que en eso más o menos consiste el trabajo básico. Debemos modificar las acciones y las plantillas hasta conseguir los resultados deseados. Todo ello después de haber hecho un buen diseño de tablas y haber ejecutado los comandos que nos preparan todos los archivos. Fácil y rapido una vez te acostumbras al árbol de archivos, configuraciones, etc. No se le puede pedir más.

Además es de agradecer que Symfony diferencia entre el entorno de desarrollo y el de producción, ofreciendo en el primero bastante información útil a través de un menú flotante en nuestra propia página web. Podermos inspeccionar el valor de variables, mensajes de log, consultas SQL realizadas (a través de Propel), etc.

El precio para disfrutar de todo esto es el aprendizaje, tal vez mayor que con otros competidores ya que además del API, tendremos que tener conocimientos sobre YAML y Propel.

En definitiva dan ganas de seguir poniendo a prueba a Symfony ya que es una forma diferente de trabajar con PHP pero es el momento de comenzar con Zend.

martes, 12 de febrero de 2008

Symfony vs Zend Framework. 1- Definición del problema

Desde hace un par de años están tomando mucho auge diversos frameworks en PHP: Prado, Tigermouse, Symfony, CodeIgniter... Realmente hay una gran variedad de ellos haciendo difícil la tarea de elegir uno. Por si éramos pocos, durante el año pasado surgió Zend Framework (ZF en adelante) con todo el apoyo de la compañía que lleva las riendas del desarrollo del intérprete PHP.
Parecía que ZF iba a desplazar a todos los demás, pero entonces llegó Yahoo y anunció la adopción de Symfony para desarrollar Del.icio.us. Podríamos decir, con permiso de los demás, que la partida huele a tablas entre ambos al menos mediáticamente.

Todo esto invita a hacer una comparativa y la haremos desde el punto de vista de alguien que nunca ha utilizado ninguno de ellos. Para ello haremos una aplicación bastante simple: un blog (puede que no sea muy original) y partiendo de un diseño común la escribiremos utilizando ambos frameworks.

En principio dedicaremos capítulos diferentes a cada uno de los frameworks y, aunque no hay intención de que tengan estructura de tutorial, detallaremos bastantes de los pasos seguidos para la implementación. En la última parte comentaremos las conclusiones a las que lleguemos.

La aplicación

Simplificaremos bastante la aplicación, contemplando las siguientes historias a desarrollar.

1- El blogger escribe, edita o borra artículos.
2- El lector lee artículos
3- El lector añade comentarios a un artículo.



No incluiremos procesos de autenticación de usuarios.

Por supuesto el diseño de la BD será el mismo para ambos casos y responderá a este esquema:


Aclararemos aquí que seremos estrictos con el nombre de los campos. Como se verá mas adelante nos resultaría más fácil llamar id a los campos clave de cada tabla, de lo contrario nos veremos obligados, por ejemplo en el caso de Symfony, a extender las definiciones de nuestros campos en los ficheros yaml. Lo mismo ocurriría si llamásemos created_at a los campos fecha_creacion.


En cuanto a la capa de presentación elegiremos un diseño de la web freecsstemplates Para ello buscaremos uno que se adecue a la siguiente disposición:



Hay bastantes donde elegir. Nosotros nos quedaremos con Pluralism ya que cumple con nuestras características deseadas.



Así pues, a partir de nuestros casos de uso y con el diseño elegido, tenemos las siguientes páginas a desarrollar:

  • Listado de posts. En él se podrán leer directamente el cuerpo de los posts recientes y aprovechando la maquetación de pluralism tendremos un listado de posts (de sus títulos) inmediatamente antes del pie. Ya que no hay validación de usuarios colocaremos cerca de este bloque el enlace que nos permitirá crear una entrada nueva.
  • Edición de posts. Aquí se crearán, modificarán y borrarán los artículos. Será un entorno muy básico sin edición WYSIWYG, etc.
  • Añadir comentarios. Al igual que antes será un entorno muy simple.


Otras consideraciones a tener en cuenta


Por lo general no abarcaremos detalles de carácter avanzado como la instalación o la posibilidad de utilizar plugins porque simplemente nos pondremos en el caso más práctico: hacer una aplicación que funcione.

Por supuesto se intentará que ambas versiones sean lo más similares posible en aspecto y funcionamiento.

Versiones utilizadas

Usaremos el recién horneado Zend Framework 1.5 (que sigue siendo una beta en el momento de escribir esto) y el paquete Sandbox de Symfony 1.0 que en teoría tiene todo lo necesario para comenzar una aplicación como esta.
Como base de datos haremos uso de MySQL en ambas aplicaciones.

Powered by ScribeFire.