Ahora es ‘Vendimia Framework’

Hace unos días, antes de dormir, googleé ‘M3 framework‘. Y resulta que ese nombre lo usa un plan de modernización del gobierno de USA, un software de topografía, un protocolo de IoT, una librería para web adaptable, y una plétora de otras cosas más.

Así que decidí renombrar el proyecto. Seguiré la sugerencia de mi gran amigo Ricky Muñoz, y ahora se llama ‘Vendimia Framework‘ 👏👏

GitHub: https://github.com/vendimia/vendimia

(futuro) Sitio web: http://vendimia.in

M3 Framework

Actualización: El framework ahora se llama “Vendimia

TL;DR: Para ir al cau cau de este post, haz clic aquí.

Un poco de historia.

Todo empezó con el servidor web Xitami a finales del milenio pasado, por allá en el lejano 2000. Jaime y yo la pasábamos de lo lindo haciendo programas en Pascal para usarlo de filtro HTML en el Xitami, y colocar un contador de visitas en la web, y otras monadas. Oh, las gratas memorias…

Por esas épocas, Jaime (como siempre ha sucedido) me presentó la nueva tecnología de moda: PHP. Y empezó un romance con el desarrollo web que aún no acaba.

Con el tiempo, empezamos a desarrollar librerías para manejar cosas comunes, como acceso a la base de datos o validación de formularios. Yo hice una clase para un motor de plantillas llamado ‘keadoo’, entre otros juguetes más. Con el tiempo, tenia varias librerías que me ayudaban con el desarrollo web, y les puse de nombre ‘Matrix’.

Pero pronto PHP empezó a quedar obsoleto. Su falta de especificación formal (y por lo tanto, de orden), numerosos problemas de inconsistencia en sus nombre de funciones, y sus clases/objetos que dejaban que desear, alentaban indirectamente a malas prácticas de programación.

Nuevos y novedosos lenguajes empezaron a emerger, y con ellos nuevas formas de hacer aplicaciones Web. Recuerdo el Dynamic Programming Day del 2008: Un evento sobre lenguajes de programación dinámicos. Nunca nadie mencionó a PHP. Me sentí un tanto excluido, y quizás algo avergonzado.

Pasaron los años, y decidí dejar PHP. Revisé Django y Rails, ámbos con dos filosofías de programación muy diferenciadas, y muy buenas ideas. Pero ámbos tuvieron ciertos detalles que no me permitieron ser felices con ellos.

Por una ironía del destino, cerca a esa época fui invitado a enseñar PHP en un instituto local 🙂 Al prepararme para el curso, y releer toda su documentación, me di cuenta que PHP estaba menos feo 😀 así que decidí darle una nueva oportunidad.

Actualicé todas las librerías, la mayoría las convertí en objetos, y empecé a unir todo como una gran sola unidad. Implementé un ActiveRecord y un preprocesador de CSS. Eliminé el ‘keadoo’, para usar PHP simple en las vistas (ya que regresaron el tag corto <?= ) Esta nueva versión se llamó ‘Matrix 2’, obviamente.

Y hace unos dos años atrás (por el 2014), viendo la proliferación de nuevos frameworks de desarrollo web, decidí también preparar el mío para publicarlo como OpenSource. Le construí los scripts de administración, y tapé varios huecos que quedaban en la implementación. Se supone que debió haberse llamado ‘Matrix 3’, pero ‘matrix’ ya es un nombre con otros significados (y reusarlo sería muy huachafo), así que renombré todo el proyecto a ‘M3’. Versión 0.0.0.1 😀

El año pasado, por motivos laborales, Jaime (Jaime, Jaime… siempre Jaime. Gracias, Jaimito 😀 ) también regresó al PHP. Y en su re-preparación, aprendió mucho más de programación, conocimientos que me los ha estado pasando de a pocos, desde entonces. Y a raíz de ello, le dí el último gran overhauling a todo el M3, y buscando los ánimos para publicarlo, ya que pasará buen tiempo antes que llegue a la primera versión estable. Incluso a la primera beta.

Y el momento llegó.

Hoy fue el Software Freedom Day, celebrado también en Ica por los chicos de Icanux. Y como ya había estado mostrando el M3 a varios amigos, me pidieron que lo exponga en una charla.

Así que sin más preámbulo, les presento la version 0.0.1 del Framework de desarrollo en PHP M3:

https://github.com/M3framework/m3

Super alfa. Lejos aún para ser considerado óptimo para producción. Pero si no estás avergonzado de tu primera versión de tu producto… Aunque, la verdad, esta versión está bonita 🙂 Me gusta cómo está quedado, pero el camino a recorrer es largo aún.

Aun no hay documentación 😛 Estoy en proceso de creación. Pero por hoy, es suficiente. Hace 2 días que no duermo bien por la gripe, después escribiré, para empezar, un tutorial sobre cómo crear un proyecto en M3.

tmux-git 0.4

Este es un pequeño update al tmux-git:

  • La configuración ahora está guardada en un fichero separado ~/.tmux-git.conf, creado automágicamente en la primera ejecución
  • Soporte inicial para Mac con homebrew.
  • He removido la verificación de ejecución dentro de tmux de la función principal. Ahora se realiza en el .bashrc, por lo que si usas una versión anterior a la 0.3, debes de editarlo y colocar la línea de instalación como está en el README.md

https://github.com/drmad/tmux-git/releases/tag/v0.4

PHP7: Sintaxis uniforme de variables

PHP 7 ya casi está aquí. Su principal cambio, es que debe funcionar, en promedio, el doble de rápido que PHP 5.x sin necesidad de modificar los programas ya hechos. Rasmus mostró unos slides en PHP Australia con unos benchmarks (con flecha derecha avanza los slides) sobre algunas aplicaciones populares, y su diferencia de velocidad. Y wao…

Esta nueva versión tiene un gran cambio que traerá problemas con el código en PHP ya existente, ahora usa una nueva sintaxis de variables que afecta cómo se evalúan las variables variables desreferenciadas.

Las variables variables son una de esas travesuras mágicas de PHP que algunos lo toman como mala práctica de programación,  aunque te ayuda bastante si los usas con cautela: Una variable variable es una forma de acceder a una variable, propiedad, función, o método, usando el valor de otra variable.

$nombre = 'oliver';
$campo = 'nombre';
echo $$campo;

El código de arriba mostrará oliver. Con el tiempo, la sintaxis de PHP se volvió más compleja, y la forma de evaluar variables variables cuando se desreferencia un array comenzó a ser inconsistente. PHP normalmente analiza las expresiones de izquierda a derecha. En el código:

$arr['el'] -> prop;

PHP primero buscar la variable array $arr, luego busca su elemento 'el', y del objeto resultante accede a su propiedad prop.

PERO en algunas expresiones más complejas como:

$$arr['el'] -> prop

PHP 5.x primero obtendrá el valor de $arr, ubicará su elemento ‘el’, y luego buscará una variable con nombre igual a dicho resultado, y de ahí accederá a su propiedad prop. Empieza a analizar por la mitad, regresa a la izquierda, y luego se va a la derecha. Y hay muchos más casos de inconsistencias de este tipo, incluso con expresiones idénticas en contextos distintos.

Adiós al desorden

En PHP7 el análisis de las variables será de izquierda a derecha, sin excepciones. Ya me topé con un problema de estos: Este línea de código empezó a generar la noticia ‘Array to string conversion‘:

$res[] = $record -> $params[0];

Quizás haya tenido un poco de sentido común esta forma de analizar variables: obtienes la propiedad cuyo nombre se guarda en el índice 0 del array $params, del objeto $record. Pero nuevamente es inconsistente con el análisis izquierda-derecha. PHP7 ahora lo analiza así: Obtiene la propiedad guardado en la variable $params del objeto $record, y de él obtiene el elemento 0. Como $params es un array, y las variables variables tienen que ser strings, produce la noticia que mencioné arriba.

Para lograr el comportamiento que quiero en PHP7, es necesario darle un hint al analizador usando llaves, para agrupar los elementos que deben ser analizados juntos:

$res[] = $record -> {$params[0]};

Este código también es válido en PHP5. Este cambio trae orden al caos, a costas de romper compatibilidad con código anterior. Pero además, este cambio prepara al analizador de PHP para poder evaluar expresiones más complejas. Ahora queda a esperar al lanzamiento final, en Octubre 🙂

Jugando con el framebuffer de Linux en Raspberry PI

Hace una semana llegó (después de 4 meses), la pantalla 7″ touch que pedí al Papa Noel chino 🙂

IMG-20150817-WA0009

Docenas de ideas se me ocurrieron para usar esta pantalla con el Rasperry Pi del la visita anterior de Papa Noel: Desde un on-board display para el carro, hasta un reloj mono para mi alcoba. Pero cualquier cosa que haga tiene un pequeño reto: El hardware es bastante limitado: 700 MHz de velocidad de procesador, 512MB de RAM, entre otras cosas. Pero eso es excelente: con pocos recursos, necesitas ser creativo 🙂

El primer problema es cómo dibujar una interfase gráfica para lo que vaya a hacer. Lo más sencillo hubiera sido quizás usar Gambas, pero el overhead sería demasiado. Así que comencé a bajar de nivel, pensando en Python + OpenGL, C++ + OpenGL, pero todo me pareció muy complicado y/o con demasiado overhead. Al final, después de indagar un poco, llegué a viejo Framebuffer de Linux. Y es perfecto: No requiere ninguna dependencia (ya viene todo en Linux), funciona en cualquier Linux, y es bastante sencillo de usar: Como en los viejos tiempos, accedes a la memoria de vídeo directo para dibujar los pixeles. Mi lado oldschool demoscener se emocionó B-)

Y qué mejor forma de probarlo, que implementar un viejo efecto de fuego 😀

Este código está hecho en C, y tuvo varias iteraciones. Primero lo empecé probando en Dorothy, que su framebuffer sólo trabaja a 1024×768 y 32bpp. Pero era demasiado lento en el RPI. Al final quedó trabajando a 8 bpp (como en la VGA de antaño, so retro!!1ONE 😀 ), usando lookup tables para evitar ejecutar rand() en el bucle principal (lento), y convirtiendo las funciones para leer y escribir pixeles en macros.

El código fuente está en github.

Mi c-foo está muy oxidado… aun hay espacio para optimar más ese código. Aún así, fue una semana excelente, acabando con un perfecto #viernesretro 😀

El Cañón de los Perdidos

Todo el departamento de Ica ha estado en algún momento de la vida de la tierra sumergido bajo el mar. Esto le da a su tierra sus excelentes propiedades para la agroindustria.

Pero el distrito de Santiago y el distrito de Ocucaje son particularmente interesantes, ya que su historia geológica es tangible. En su desierto se pueden encontrar no sólo fósiles de ballenas o tiburones, sino toda las épocas de su existencia guardadas en los estratos de las rocas.

estratos2

estratos

Por dichos distritos pasa y desemboca el Rio Ica, el cual ha cavado por el paso de los eones bellos paisajes, que aun en temporada seca mantiene su vegetación y encanto.

rio_ica

En el 2009 se hizo público un nuevo atractivo de esta zona por un reportaje de un canal local: una vertiente del río Ica, que ahora está seco, cavó en la tierra un pequeño cañón.

El 10 de julio del 2011, un grupo de personas de la Asociación de Promoción Turística y Cultural de Ocucaje, al intentar llegar al cañón, se perdieron por varias horas, y de ahí lo bautizaron como El Cañón de los Perdidos.

Hace unas semanas, mi amigo Bryam y yo nos propusimos perdernos hasta encontrarlo 😀 . Con Google Maps en la mano, y después de 6 horas de divagar por los desiertos de Ocucaje y Santiago (y tomar docenas de fotos a cada piedra o ave que encontramos), llegamos a esta pequeña maravilla natural.cañon-1

Está a aproximadamente 82km de camino desde el centro de Ica. La mayor parte es trocha, pero transitable. Bryam ha hecho un mapa del camino en su página de Destinos Ica. El cañón debe tener unos 2km de largo, y unos 100 metros de profundidad en su inicio. Al final de él, la pendiente es menos pronunciada, y se puede bajar.

cañon-2 cañon-3cañon-4El final del cañón tiene una mini-cascada seca, que le llaman La Cara del Puma, y debajo hay un pequeño pozo de agua estancada.

cañon-5

El lugar tiene su encanto, aunque más me gustó las 6 horas perdidas en el desierto 🙂

Branch de Git en Tmux

Para desempolvar este blog, le he instalado el nuevo tema 2014 que está bien paja. Después le cambiaré la imagen de la portada. Pero por ahora, quiero comentarles sobre un pequeño script que he creado para jugar mejor con Git:

https://github.com/drmad/tmux-git

Este script muestra la rama (‘branch‘) activa del repositorio Git que está en el directorio activo en la barra de estado de Tmux, un “multiplexador” de terminales cliente-servidor muy paja, que además proporciona esa barra de estado.

¿Por qué Tmux? Hay varias soluciones para mostrar el branch activo en el prompt  del terminal de Linux, como esta (lo cual es muy útil, para no estar repitiendo git status constantemente), pero la verdad es que me gusta tener el prompt sencillo, sin tantos bombos ni platillos. Entonces, ¿dónde muestro esa información?

Ahi entra a tallar Tmux.

 

Instalación

Primero necesitas, obviamente, tener instalado tmux y git… Si unas una distro derivada de Debian (como Ubuntu, Mint, ElementaryOS, SteamOS, etc.), basta ejecutar:

sudo apt-get install tmux git

Una vez instalado todo, clonas el proyecto a una carpeta escondida en tu home:

git clone git://github.com/drmad/tmux-git.git ~/.tmux-git

Luego, agregas el script en el fichero de incialización de Bash ejecutando esta línea:

 

echo "if [[ \$TMUX ]]; then source ~/.tmux-git/tmux-git.sh; fi" >> ~/.bashrc

 

 

10 cosas que probablemente no sabías de PHP

Hace un año empecé a buscar alternativas para desarrollar web, ya que el PHP que habia estado usando por años se quedó atorado en el pasado… estuve revisando bastante Django y Rails, que son excelentes frameworks, en modernos lenguajes.

Entonces fui invitado a enseñar PHP en un instituto local, lo que me obligó a releer su documentación (te das cuenta lo poco que sabes de algo, cuando lo enseñas…). Y me di con la sorpresa que desde la versión 5.4, PHP está menos feo 🙂 Y desde entonces han estado añadiendo características interesantes, aunque no lo ponen a la par con los otros lenguajes, al menos ahora no está tan atrasado como en versiones pasadas.

Pero veo que muchos no se han percatado de algunos cambios. Así aquí presento mi top-ten de las cosas de PHP que probablemente no sabías que existían:

El tag de cerrar el código PHP es innecesario

Si tu fichero .php tiene puro código PHP, es mejor no colocar el tag ?> al final. Esto evita que se introduzcan líneas en blanco en el HTML, que lo personal me ha dado varios dolores de cabeza cuando uso la función header(), por ejemplo.

Variables y funciones en castellano

PHP soporta los caracteres ASCII extendidos para los nombres de variables y funciones. Esto es medio limitante para otros idiomas, pero para el español es suficiente, ya que incluye todas las vocales acentuadas, la eñe, y la cedilla, en mayúsculas y minúsculas.

<?php
function añadir_acción($acción) {
    return "Acción $acción añadida";
}

$AÑO = 1991;
echo "Año $AÑO: " . añadir_acción('correr') . PHP_EOL;

Tag corto para plantillas ( >= 5.4 )

Para imprimir una variable dentro de un HTML, puedes usar el tag <?=... como reemplazo al <?php echo ..., que hace tu HTML un poco más limpio, y ya no requerirás usar algún motor de plantillas.

<h1>Información de usuario <?=$usuario?></h1>
<p>Nombre completo: <?=$nombre_completo?></p>

Antes de la versión 5.4, esta versión del tag estaba unido al “tag corto” que cayó en desuso, por lo que por defecto estaba desactivada.

include() y require() pueden devolver un valor

Esto también aplica para include_once() y require_once(). El código incluido puede retornar un valor (o finalizar anticipadamente su ejecución) usando la sentencia return. Me parece útil para ficheros de configuración. E.g. este fichero llamado configuracion.php

<?php return [
    'base_datos' => [
        'tipo' => 'mysql',
        'usuario' => 'root',
        'contraseña' => 'pikachu123',
        'basedatos' => 'historias',
    ],
];

Y luego, en otro fichero:

<?php
    $configuración = include 'configuracion.php';

Forma alterna de estructuras de control para plantillas

Las estructuras de control if, while, for, foreach, y switch tienen una sintaxis alternativa, que puede ser útil al momento de hacer plantillas HTML: El bloque se inicia con un “:”, y se acaba con endif, endwhile, endfor, endforeach, y endswitch, respectivamente. Confunde menos que las llaves cuando se mezcla con HTML.

</pre>
<table>
<?php foreach ($datos as $d): ?>
<tr>
<td><?=$d['nombres']?></td>
<td><?=$d['apellidos']?></td>
</tr>
<?php endforeach ?>
</table>

 Arrays con corchetes ( >= 5.4 )

Esto fue lo primero que me llamó la atención. Adiós a la horrible función array() para crearlos, que se ve horrible al crear arrays anidados. Ahora los arrays se ven elegantes, como en otros lenguajes:

$a = [1, 2, 3];

Cabe acotar que puedes acceder los elementos de array usando corchetes, y también usando llaves. Asi que para imprimir el 2do elemento, puedes hacer un echo $a{1}; , y es válido.

Desreferenciación de arrays y strings retornados desde funciones ( >= 5.4 )

Bonita palabra, “desreferenciación” 😛 Ahora puedes acceder directo a los elementos de un array (o a los caracteres de un string) directo desde la llamada de la función. E.g.:

<?php

function retorna_array () {
    return ['pera', 'manzana', 'plátano'];
}

function retorna_string () {
    return 'parangaricutirimicuaro';
}

echo retorna_array()[2] . PHP_EOL; // Imprime 'platano'
echo retorna_string()[10] . PHP_EOL; // Imprime 'u'

Antes de esto, tenías que guardar en una variable el resultado de la función, para acceder a sus elementos.

Como bonus, a partir de la versión 5.5, puedes también desreferenciar arrays y strings literales, aunque aun no le encuentro una utilidad. E.g.

<?php
// Imprime 'llorones'
echo ['papanatas', 'llorones', 'baratijas', 'pellizco'][1];

Encadenamiento de métodos ( >= 5.0 )

Esto también era uno de los atrasos de PHP, los objetos eran devuelto como valor, y no como referencia. Ahora si son referencias, por lo que puedes retornar el mismo objeto desde un método, y hacer cosas guapas como:

$usuarios = users::find()
   -> where(['admin' => True])
   -> order('name')
   -> limit(10)
   -> getarray('login', 'name');

Es una sola instrucción, dividida en varias líneas por legibilidad. Cada método no estático (excepto el último) tiene un return $this; al final. Este snippet de código es parte de mi framework M3, que ya lo estaré comentando después 😉

Namespaces ( >= 5.3)

Los namespaces son una forma de agrupar constantes, funciones y clases bajo un nombre. Es una forma medio elegante de crear una librerías: En vez de tener una función como mensajes_error(), puedes tener en un fichero, digamos, mensajes.php:

<?php

namespace mensajes;

function error( $msg ) {
    echo "ERROR: $msg" . PHP_EOL;
}

Y luego, en otro fichero, incluyes la librería:

<?php

require 'mensajes.php';

mensajes\error ( 'Todo ha fallado!' );

 

Iteración de resultado de una consulta en MySQLi ( >= 5.4 )

En vez de hace un while ($data = $result -> fetch_assoc()), puedes iterar el resultado con un foreach, como si se tratara de un array. Se ve un poco más elegante:

<?php

$db = new MySQLi('localhost', 'root', '', 'mibasededatos');

$result = $db -> query ( 'SELECT * FROM clientes' );

foreach ( $result as $r ) {
    echo $r['nombres'] . PHP_EOL;
}

¿Faltó algo nuevo de PHP? ¡Házmelo saber en los comentarios!

Aclaración: ODIO JAVA (y un poco de switch/case)

Java es un lenguaje arcaico, increíblemente lento, y redundante. Si lo enseñé alguna vez, fue porque:

  1. El director del Instituto que me lo pidió inicialmente, se confundió… pensó haber leído en mi currículo que yo había sido docente en la UNICA (ahí dice claramente que fui Tech Support. Fue un momento bastante jocoso, la verdad),
  2. Parece que no existia nadie más en Ica que enseñara eso, y
  3. Me pareció paja la idea de ser profe 🙂

Es un error que no volveré a repetir. Quiero enseñar/exponer sobre Linux, Gambas, Blender, Python, y cualquier otro software libre que sea emocionante 🙂

¿Por qué digo que Java es arcaico y redundante? Porque su sintaxis es una copia de C. Y la sintaxis de C sólo tiene razón de ser en C, ya que el compilador de éste optima el código para convertirlo en lenguaje máquina, y ganar velocidad. Los lenguajes de programación de más alto nivel ya no compilan a lenguaje máquina directamente, usualmente lo hacen hacia un bytecode, y las optimizaciones de velocidad precisas de C pierden sentido. Para muestra, un botón: La sentencia switch, de C.

Si te has preguntado por qué tienes que escribir un break después de cada segmento case en una sentencia switch en Java,  es por que tu inconsciente también sabe que Java es feo 😀 Básicamente, un switch es un montón de ifs anidados, y es lo mismo usar uno u otro (python, por ejemplo, no tiene una instruccion switch, y te recomienda usar simplemente ifs), no hay beneficio de velocidad.

Excepto en C. La sentencia switch en C crea una tabla de saltos, donde el puntero de ejecución es empujado cierta cantidad de instrucciones según el valor numérico que se le pasa a la sentencia switch. Al no haber comparaciones (esto es, ifs), es mucho más rápido. Entonces cada keyword case marca un punto donde debe de saltar el puntero de ejecución. Aquí viene lo interesante: case no es una sentencia, no produce código máquina, solo lo usa el compilador para armar la tabla de saltos. Cuando se ejecuta el programa, no hay forma de saber dónde acaba las sentencias que le corresponde a cada case, por lo que uno manualmente tiene que marcar el fin, indicando que salga del bloque switch usando la sentencia break.

Esta forma de trabajar de switch permite hacer optimizaciones bastante locas (como el dispositivo de Duff). Otra cosa a notar aquí, es que el valor que se le proporciona a switch debe ser únicamente numérico (o pueda ser casteado a numérico), ya que este valor será sumado al valor del puntero de ejecución.

Es poco probable que ese tipo de sentencia switch se use en estos tiempos, incluso lenguajes feos como Visual Basic tienen un switch mucho más moderno (su SELECT CASE, que permite hacer comparaciones de mayor, menor, y de cadenas, obviamente es internamente IFs anidados)

¿Aún sigues pensando que Java es moderno? Allá en 1995, adoptaron la sintaxis de C para hacerlo familiar con los programadores, y modificaron cosas que trae problemas en C (como punteros, recolectores de basura, etc.) Cumplió su objetivo, y se volvió muy popular. Y el mismo bodoque siguen usando hasta ahora, por mucha presión de grandes billeteras. Suena un poco a la historia de Windows 🙂 Ahora hay muchos lenguajes de programación, como Python, o Ruby, que son infinitamente mejores, modernos, y se enfocan en la velocidad de desarrollo, que es lo que realmente importa en estos tiempos.

Si, es cierto: PHP tiene también la sintaxis de C. Por eso estoy en el proceso de dejarlo 🙂

Update 18 marzo, 2016: No, no lo dejé. Después de un par de años de estar enseñándolo, me di cuenta que se ha vuelto menos feo, así que le he dado una nueva oportunidad (obviando usar estas cosas obsoletas, como switchs y fors). Incluso he hecho un framework para PHP. Más noticias pronto 😉