Prueba de screencasts con Jing generando .swf

Bueno, recibí por fin un nuevo auricular con micrófono (no es nada del otro mundo, pero hasta que consiga otro de mejor calidad, salimos del paso) y estoy probando distintos programas "legales" (me resisto a usar software a través de "cracks").

Para mi primer screencasts estaba usando uno gratuito de Microsoft (Windows Media Encoder) pero no encuentro la versión vieja que usaba y la nueva consume demasiados recursos para mi gusto. Y por el momento estoy usando Windows XP para unos proyectos, así que más adelante volveré a GNU/Linux.







Buscando me encontré el proyecto Jing, así que lo estoy probando. Genera directamente archivos en formato flash (.swf) e inocentemente pensé que podía subirlo a Youtube directamente, algo que no es cierto ya que debo antes convertirlo a ".flv".

Por el momento subí el archivo .swf a mi servidor y lo incrusté en Blogger. Aparentemente funciona bien, pero me gustaría simplificar la operación y seguir subiendo los futuros screencasts a Youtube para que estén a disposición de todos.

¿Sugerencias? ¿Software para hacer screencasts que recomienden?

Soluciono estos detalles y esta semana empiezan a salir los screencasts como "por un tubo" ;-)

PD: También muchos usuarios me han sugerido en su momento la opción para bajarlos, pero creo que a través de youtube se puede llegar a más gente usando una infraestructura existente. Sé que el tamaño es reducido (tengo que jugar dentro de los 425x355 de Youtube para no distorsionar la imagen), tal vez se podría hacer otros de mayor tamaño, pero tendría que ver el ancho de banda y cómo quedaría posteriormente.

Screencasts sobre Zend Framework


Como muchos sabrán a través de este blog, hace un tiempo que estoy dedicándome a estudiar el Zend Framework (producto desarrollado por "la empresa de PHP"). La idea fundamental, motivado por grandes modas como Ruby On Rails, es generar un marco de trabajo de más alto nivel, así evitar la habitual programación artesanal de "una sola capa" (php con html embebido y programando sin uso de objetos).

Lo vivo en carne propia, no es sencillo aprenderlo ya que hay que entender antes muchos conceptos para luego lentamente ir comprendiendo el marco de trabajo para empezar a sacarle el provecho justo.

Actualmente me estoy apoyando en varios screencasts, que aunque están en inglés, son muy entendibles y te muestran paso a paso cómo empezar a construir la estructura de tu proyecto para poder usar el framework y aplicar el patrón MVC.

El primero es de Mitchell Hashimoto y la sección se llama Zend Framework Tutoriales donde este estudiante nos cuenta paso a paso y a través de código cómo instalar Zend partiendo de una estructura en cero (el nos invita luego a hacerle una donación a través de Paypal para apoyar sus estudios). El otro tutorial es sobre Zend_Registry, que nos permite entender cómo funciona la registración de variables para luego poder ser utilizada en distintas partes de nuestro sistema (funcionalidad similar a contar con variables globales pero sin los perjuicios de estas).

Los otros screencasts que estoy viendo, directamente como si estuviera en un curso ;-), son de la misma empresa Zend y están en la sección Webinar, y también tienen uno que inicia de cero, pero primero por los conceptos, explicando la estructura del framework (hay que registrarse primero en el sitio para poder verlo).

Próximamente voy a compartirles dos ayudas más:
  1. A pesar que existe el proyecto abierto surforce-cms que puede servir a cualquier desarrollador para empezar a conocer cómo funciona Zend Framework, voy a armar otro proyecto con el nombre "surforce-base" que contará con lo mínimo indispensable para empezar un proyecto de cero: Zend instalado, configuración básica, un ejemplo con conexión a la base de datos y comentados todos los pasos. Tengo pensado agregarle un detalle interesante: dejar configurado por defecto Smarty para poder aprovecharlo en esta estructura (ya que conozco muchas empresas que sus diseñadores usan templates para luego fácilmente pasarles el trabajo a los desarrolladores).
  2. Armar un screencasts basado en los anteriores que están en inglés, pero en nuestro idioma y profundizando un poco más los conceptos básicos de cómo trabajar con Zend, la parte de persistencia y usando Eclipse para la demostración.
Bueno, espero que les sea de utilidad y si tienen alguna sugerencia más que pueda aportarles y reducirles el nivel de dificultad para aprender a desarrollar con este framework, bienvenidos los comentarios en este post.

Dentro de poco novedades ;-)

Crear templates para consultas SQL

Los "templates" o "plantillas" nos sirven para disponer de una estructura base y agregarle solo la información que cambia o varía, evitando tener que volver a copiar código una y otra vez.

En el caso de HTML podríamos usar Smarty, lo que nos permite contar con archivos de extensión .tpl y separar el código de presentación del código que se encargaría de armar o recibir información de la lógica de nuestro sistema.

Me ha sucedido que en muchos proyectos relacionados con web y con PHP se tienen que trabajar intensamente con consultas sql, más allá del tema de usar o no una capa de abstracción para conectarse a la base de datos. En estas situaciones existe mucho trabajo del lado del rol de DBA para incorporar mucha lógica en el motor de base de datos, como ser restricciones de integridad, disparadores, vistas, etc. De la misma forma, muchas reglas del negocio se resuelven a través de complejas consultas SQL que escapan del entendimiento de muchos de los programadores tradicionales (cabe aclarar que un programador nace con un cerebro distinto al de un DBA; muchas veces odiamos a las bases de datos y todo lo relacionado con la teoría de conjuntos ;-)).

En estos casos conviene que las consultas vengan preparadas por el DBA y que el desarrollador solo tenga que ejecutarlas, en otros, directamente trabajar con vistas que nos oculten toda la complejidad del diseño de la estructura de datos. También se pueden aprovechar "procedimientos almacenados" para ejecutar consultas con solo entregar algunos parámetros.

Me ha sucedido en situaciones intermedias y menos complejas que me es útil manejar el concepto de templates pero aplicados a consultas SQL donde simplemente tengo almacenadas las consultas y les paso los parámetros que requieren para ejecutarse.

Un ejemplo sencillo sería:

SELECT * FROM usuarios WHERE id = 1

Donde si tuviera un código PHP tendría que hacer cosas como:

1  
<?php
2    
3  
function traerUsuario$id ){
4     
$sql "SELECT * FROM usuarios WHERE id = $id";
5  
6     
// ejecutar_sql( $sql );
7     // etc.
8    
9  
}
10    
11  
?> 



O alguna versión más POO como:

1  
<?php 
2  
3  
class Usuario{
4     function 
getId$id ){
5        
$sql "SELECT * FROM usuarios WHERE id = $id";
6        
// procesar consulta
7     
}
8  }
9  
10  
?> 



Ahora bien, ¿qué pasa si para todas mis tablas uso constantemente esta misma lógica, donde solo necesito cambiar el nombre de la tabla y mantengo siempre un campo id, y luego solo le paso distintos valores por parámetro?

Yo puedo procesar esta consulta como un template, armando el marco para la sentencia y luego sustituyendo las "marcas" por valores, simplemente así:

1  
<?php 
2  
3  $sql_one 
"SELECT * FROM %s WHERE id = %s ";
4  
$sql sprintf$sql_one"usuarios");
5  
6  
?>



Lo que sucede es que ahora tomará la sentencia sql y en cada %s ("s" por "String") sustituirá en orden por los valores que agregue a continuación, causando el resultado esperado:

$sql = "SELECT * FROM usuarios WHERE id = 1";

Y ahí podemos aumentar enormemente la complejidad de las consultas y podremos reutilizarlas todas las veces que queramos, más, si las tenemos almacenadas en un archivo aparte y que todo nuestro sistema las use. Llegado el caso, si hubiera que optimizarlas habría que modificar un solo archivo.

Otra cosa que se me ocurre es algo más parecido al patrón de diseño ActiveRecord, que nos solucionaría un poco la vida con la operación de nuestras clases de persistencia de objetos.

Por ejemplo, podría crearme una clase Persistente que fuera así (usaré PHP4 para demostrar que no hace falta gran uso del lenguaje para implementar la idea):

1  
<?php 
2  
3  
require_once( 'BaseDeDatos.class.php' )
4  
5  class 
Persistente {
6     var 
$id;
7     var 
$tabla;
8     var 
$orden;
9  
10     var 
$sql_one "SELECT * FROM %s WHERE id = %s ";
11     var 
$sql_all "SELECT * FROM %s ORDER BY %s ASC";
12  
13     function 
getId$id ){
14        
$sql sprintf$this->sql_one$this->tabla$id );
15  
16        
$bd = new BaseDeDatos();
17        
$datos $bd->traerTodo$sql );
18        
$this->cargarDatos$datos );
19     }
20     function 
cargarDatos$datos ){
21        foreach( 
$datos as $key => $it ){
22           
$this->$key $it;
23        }
24     }
25     function 
getAll(){
26        
$sql sprintf$this->sql_all$this->tabla$this->orden );
27  
28        
$bd = new BaseDeDatos();
29        
$datos $bd->traerTodo$sql );
30        return 
$datos
31     
}
32  } 
33  
34  
?>



¿Bien, y cómo se usaría? Me creo mi clase concreta de persistencia de objetos, por ejemplo Usuario, y simplemente defino la información particular de la misma:

1  
<?php 
2  
3  
require_once( 'Persistente.class.php' );
4  
5  class 
Usuario extends Persistente {
6  
7     function 
Usuario() {
8        
$this->tabla "usuarios";
9        
$this->orden "id";
10     }
11  } 
12  
13  
?>



Y listo, no debo decirle nada más. Ahora solo me basta usarla de esta forma:

Si quiero traerme a todos los usuarios

$usuario = new Usuario();
$datos = $usuario->getAll();


Y si quiero traerme solo a un usuario particular, basta con que la base de datos del usuario tenga los campos id, nombre y apellido para hacer dinámicamente lo siguiente:

$usuario = new Usuario();
$usuario->getId(1);

echo
"Mi nombre es {$usuario->nombre} y mi apellido
es {$usuario->apellido}"
;


Y lo más interesante es que en situaciones donde lo genérico puede quitarnos libertad de acción, simplemente con sobreescribir los valores de los atributos definidos en la clase Persistente pero del lado de la clase Usuario resolvemos algunas limitaciones:

1  
<?php 
2  
3  
require_once( 'Persistente.class.php' );
4  
5  class 
Usuario extends Persistente {
6  
7     function 
Usuario() {
8        
$this->tabla "usuarios";
9        
$this->orden "id";
10  
11        
// Agregamos un JOINs con otra tabla
12        
$this->sql_all "SELECT * FROM %s as u, 
telefonos as t WHERE u.id = t.idUsuario ORDER BY u.%s, t.id ASC"
;
13     }
14  }
15  
16  
?> 



Mmm... creo que hoy me fui muy lejos divagando... más adelante les comparto un ejemplo completo que incluye persistencia en todos sus casos (update, delete, etc).

Más información

- Manual oficial, comando sprintf

Entradas populares