Mostrando las entradas con la etiqueta código. Mostrar todas las entradas
Mostrando las entradas con la etiqueta código. Mostrar todas las entradas

2010/06/11

Zen Coding para editar HTML+CSS

Zen Coding permite construir rápidamente bloques de código HTML y CSS a partir de secuencias mnemotecnicas.

Por ejemplo, html:4s puede expandirse para producir todo el esqueleto de una página HTM4 strict.

La siguiente secuencia:

div#page>div.logo+ul#navigation>li*5>a

Puede ser expandida para producir:

<div id="page">
<div class="logo"></div>
<ul id="navigation">
<li><a href=""></a></li>
<li><a href=""></a></li>
<li><a href=""></a></li>
<li><a href=""></a></li>
<li><a href=""></a></li>
</ul>
</div>

Zen Coding es un plugin disponible para Notepad++, Aptana y Dreamweaver, entre otros. Está disponible en Zen Coding.

Zen Coding con Notepad++

La versión para Notepad++ puede descargarse de http://code.google.com/p/zen-coding/downloads/list.

En mi caso, descargue Zen.Coding-Notepad++.v0.6.1.zip, cuyo contenido copié en el directorio plugins del árbol de Npp (C:\Program Files (x86)\Dev\Notepad++\plugins).
Zen Coding usa Npp Scripting, que permite extender Npp mediante javascript.
Luego de eso, la siguiente vez que se inicie Npp encontrará el menú Zen Coding.

El uso básico es sencillo. Puede escribir una secuencia y luego expandirla presionando CTRL+E.

2010/05/18

A través del código

Dicen que quien no conoce la historia está condenado a repetirla. Es importante registrar las cosas.
Sin embargo, tiene que haber una forma de visualizar fácilmente aquello que se ha registrado. Para comprenderla. Quizás se debería decir, en realidad, que quien no comprende la historia es quien está condenado a repetirla.

Por ejemplo, uno puede tener un log con el tráfico de un website, o los mensajes de depuración de un programa, pero si no logra visualizar fácilmente la información contenida en esos registros, no la comprenderá, y se perderá en el papeleo.

En general, no se trata sólo de la historia. Para comprender algo es importante visualizarlo fácilmente, de alguna manera. La evolución de los lenguajes de programación pueden ser una manifestación de la necesidad de los programadores de comprender más fácilmente un programa. Assembler en lugar de binario. Cobol en lugar de Assembler. O C, Pascal, Basic, Smalltalk, Java, Ruby. Y, dentro de cada uno, algún framework o manera de organizar el código. Diagramas de flujo. UML. Herramientas visuales. Generadores de código. Vamos buscando una manera simple de ver el programa.

Es tan facil introducir complejidades en la organización del código que los hackers acuñaron la frase KISS ('Keep It Simple, Stupid', 'Mantenlo simple, estúpido'), para recordárnoslo, en tono de broma, pero muy en serio.

Del mismo modo que es difícil hacer reparaciones en una casa donde las tuberías están ocultas, es difícil reparar código que no está organizado convenientemente.

Cuando un programa falla, no suele ser una tarea fácil encontrar la causa. Esta no es inmediatamente visible. Hay que bucear en el código. Por eso los buenos programadores tratan que esté limpio y claro. El código que se optimiza y compacta para que quepa en un hardware económico, es uno que ha sido muy probado, porque es demasiado costoso de depurar en esa forma. Es mejor que haya una versión más amplia y clara, donde ocurra el desarrollo, y se haga el empaque de versiones seguras sólamente.

Es la misma idea que con los programas compilados. Programamos en texto, pero se usa el compilado binario, para que quepa mejor en el hardware. Imagínese tener que depurar diréctamente en el compilado. Por eso la mayoría depura en el texto fuente.

Quizás lo ideal sería que un programa pudiera ser visualizado como una caja transparente, con el flujo ocurriendo de manera obvia, de modo que fuera fácil encontrar la causa de cierto comportamiento. Quizás lo más importante sería que, al ver con más claridad lo que hay, imaginaríamos con más facilidad lo que podría haber.

2009/08/19

Construyendo código

Al desarrollar una aplicación web me voy dando cuenta que el proceso es similar a cuando se dibuja, o se pinta algo. Pero también es útil pensar que es similar a cuando se construye algo.

De mismo modo que se ponen cimientos y una estructura base, uso un framework.

Uno podría hacer un framework aceptable. Afortunadamente hay frameworks estandar que puedo reutilizar y me ahorran mucho trabajo.

Pero quienes han hecho alguna vez un framework (quizás como yo, sin saber que así se llamaba), saben que es simplemente una forma de organización que va surgiendo conforme resuelves el problema. Es como un patrón de lugares comunes que van apareciendo en tu modo de resolver las cosas. Incluso aunque no hagas nada a propósito, el sólo hecho de intentar resolver el problema produce un framework.

Pienso que los framework estandar surgieron del mismo modo, pero por alguna razón (su simplicidad, elegancia, robustez, lo que sea), les pareció tan bueno a otros desarrolladores como para dedicarse a la tarea de mantenerlo y mejorarlo como un proyecto en común, un estandar.

Aún usando un framework estandar, para hacer algo nuevo se sigue la secuencia del bosquejo, funcionamiento, optimización. Es similar a levantar estructuras auxiliares, luego la estructura en sí, y después ir puliendo el trabajo.

Esa secuencia es como algo natural. Es demasiado complicado y propenso a errores tratar de desarrollar directamente 'en limpio'. Es como tratar de construir sin andamios, ni estructuras auxiliares, ni bosquejos, ni líneas guía.

El código va creciendo, simplificándose, creciendo, simplificándose. Pero entonces uno nota un problema. Si ya se tiene código funcional optimizado, las mejoras que se le puede hacer son relativamente pequeñas, del mismo modo que las correcciones que se pueden hacer sobre un edificio habitado, o sobre un dibujo ya terminado.

Sería interesante que se pudiera trabajar sobre el código original, con sus estructuras auxiliares y código aún sin optimizar, donde el espíritu de la solución es más palpable, y luego, de algún modo, iniciar un proceso de optimización estándar, una especie de compilación, que produzca el código optimizado para producción.

2009/08/18

Pintando código

Actualmente desarrollo una aplicación web que es un tablero de anuncios de trabajo. El lenguaje de programación es PHP. El framework, CodeIgniter.

He realizado todos los aspectos del desarrollo. Organicé los requerimientos, modelé las tablas, implementé los modelos, los controladores, y las vistas.
Trato de seguir el principio KISS, de mantener las cosas tan simples como sean posibles, pero no suele ser algo fácil.

Muchas veces he tenido la tentación de hacer algo que quede bien, para el futuro, o para cierto público exigente que me imagino debo complacer. Paso algo de tiempo divagando, pero eventualmente (afortunadamente) retomo la forma KISS.

Me parece que cuando uno ve código profesional, y está comenzando, puede tener la falsa impresión de que ese código se produce directamente tal cual lo vemos. Cuando vamos ganando experiencia es que notamos que es necesario pasar por soluciones intermedias para llegar a la solución final.

Pensándolo bien, así ocurre en otros tipos de desarrollo. Y puede que sea la forma natural de hacerlo.

Por ejemplo, una pintura que vemos colgada sobre una pared no es realizada directamente en limpio. Antes hubo un bosquejo, posiblemente sucio y horrible de ver, pero necesario para que llegara a existir. Un bosquejo que fue cambiado y corregido muchas veces antes de dar la primera pincelada. Luego, los colores se fueron aplicando por capas y zonas, de acuerdo a ciertos principios y técnicas, y también sufriendo cambios y correcciones mientras la imagen se aproximaba al ideal imaginado.

No tengo mucha técnica dibujando y mucho menos pintando, sin embargo, recuerdo algunas experiencias.

Recuerdo que, al comienzo, sin mucha guía, hubo veces que intentaba obtener directamente la versión final de una obra. Me concentraba en un área pequeña hasta completarla y luego avanzaba a un área siguiente.
No pasaba mucho tiempo hasta que notaba que algo andaba mal con el rostro que intentaba reproducir. Quizás cada parte por separado estuviera bien, pero el conjunto estaba, como se dice, descuadrado. Descubrí que me iba mejor si trazaba antes algunas líneas guía, que me ayudaran a recordar el tamaño, la posición y la forma aproximada de los ojos, la nariz, las orejas, y los labios, y luego recién desarrollar cada una de esas partes; es decir, bosquejar primero y desarrollar después.
Si se trataba de una imagen de cuerpo entero o donde aparecieran varios personajes, el bosquejo era mucho mejor opción que intentar lograr la composición directamente.

Puede ser que la costumbre de copiar dibujos es la que nos habituó a pensar que hacer una imagen por áreas, secuencialmente, era la única forma.
Pero es cuando uno trata de hacer una composición propia que descubre que es mejor trabajar por capas, iteradamente, mejorando cada vez la capa anterior.

Bailar es parecido. Al menos para mí. Aunque hay personas que insisten en tener memorizados pasos perfectos antes de comenzar a ensamblarlos, yo creo que es mucho mejor tener primero la secuencia, es decir el bosquejo de todo el baile y sus movimientos generales.
De ese modo puedo aproximarme con mas facilidad y menos frustraciones a la idea, y sentir cierta armonía que guía y ayuda a ir puliendo los pasos.

Planear la ruta de un largo viaje también es parecido. Es agotador, y hasta iluso, tener de antemano el detalle de cada tramo de la ruta, porque la práctica está llena de imprevistos. Es mejor hacer un bosquejo general, indicar los hitos principales, e ir desarrollando los tramos a medida que vamos avanzando.

Y para programar, he descubierto que también es similar.
No es malo hacer código repetitivo, usar muchas variables, ni otras cosas que muchos temen como si fueran pecados capitales.
No es malo, del mismo modo que no es malo garabatear una hoja cuando se está bosquejando.
Algunas veces para llegar a cierta posición, incluso puede ser necesario crear material auxiliar que luego se desecha.
Al inicio, lo principal no es la perfección ni la optimización, sino que simplemente funcione. Primero que funcione, luego se optimiza, me parece que dice un dicho de los hacker.

Claro que presentar código repetitivo, con demasiadas variables, o no optimizado, como versión final de un producto es como presentar un bosquejo en lugar del cuadro terminado. No te tomarán en serio, a menos que seas Leonardo.

Además, para desarrollar algo, es importante comenzar. No quedarse atorado en la trampa del perfeccionismo, ni esperar que todas las estrellas estén alineadas para dar el primer paso. Simplemente comenzar; dar el primer trivial paso; escribir código sucio quizá, pero que funcione. Luego se podrá factorizar, reorganizar, simplificar.

Factorizar es extraer el factor común de una expresión, de modo que se forma una expresión más simple o menos repetitiva. Es lo que se hace en álgebra.
Si alguien lo recuerda, no es conveniente factorizar una expresión cada vez que se le agrega algo; suele ser mejor esperar hasta que todos los términos estén presentes, para ver mejor el patrón. Si uno hace una factorización prematura, suele requerir un esfuerzo adicional desatar lo ya atado para ingresar el cambio y luego volverlo a atar.

De modo similar en programación. Es mejor no optimizar prematuramente el código, sino esperar hasta que esté completo para ver mejor el patrón, y luego factorizar. La optimización prematura puede fácilmente complicar el desarrollo. El código optimizado es mucho más difícil de depurar. Se debe optimizar, pero a su tiempo.