La manipulación de bits individuales para representar todo lo que hace un ordenador, aunque es teóricamente posible, es muy poco práctico. El lenguaje de los ordenadores es puramente matemático, respira ceros y unos.
Nosotros, los humanos, sin embargo, no somos tan numéricos como nuestras máquinas, y nosotros dependemos de sistemas más descriptivos, simbólicos para comunicarnos, como nuestras lenguas habladas y escritas naturales. Mientras que una computadora podría ser feliz con el código binario 0110011 para dar significado una operación como la suma de dos números, los seres humanos prefieren algo más en la línea de la palabra “sumar”. A pesar que una serie de ceros y unos es eficiente, es difícil para la mayoría de nosotros descifrar eficientemente patrones binarios y luego recordar lo que significa cada patrón único. Esta brecha entre cómo los ordenadores procesan la información en comparación con la forma en que comprendemos los humanos ha llevado al desarrollo de lenguajes de programación.
En un nivel fundamental del proceso de la información, nuestros cerebros funcionan de forma bastante similar a nuestras computadoras. En vez de un complejo conjunto de transistores, tenemos una red interconectada de neuronas. Las neuronas individuales pueden considerarse de forma análoga como transistores individuales. Aunque en lugar de puertas, las neuronas utilizan algo llamado un potencial de acción. El potencial de acción, como la puerta de un transistor, está controlado por un impulso eléctrico, es lo que determina cuando la neurona transmite información. La respuesta es un todo o nada, como una puerta abierta o cerrada. Procesar, ya sea la información en el cerebro o una computadora es muy distinta de la comprensión humana.
El ordenador es una especie de cerebro de silicio en una caja brillante. Como se mencionó anteriormente, trabaja con ceros y unos, o lo que más técnicamente se llama lenguaje de máquina. Cuando los ordenadores se desarrollaron, si realmente querías hacer algo con ellos, era necesario aprender a hablar el idioma nativo de la máquina. Este fue un proceso muy difícil, tedioso y lento.
Los informáticos rápidamente se dieron cuenta que necesitaban lenguajes para simplificar el proceso de programación y comenzaron a desarrollar lenguajes de alto nivel. Por nivel más alto, nos referimos a las lenguas que se acercan más a la forma que entendemos los humanos la información y se alejan del lenguaje de máquina. Uno de los primeros lenguajes desarrollados era el lenguaje Assembly (ensamblador).
El lenguaje Assembly para los estándares de hoy en día sigue siendo un lenguaje de muy bajo nivel, muy cerca de los unos y de los ceros, pero fue un gran paso adelante en la simplificación de la programación. El lenguaje Assembly convierte los comandos de lenguaje de máquina, números en estado puro a estados, incluyendo palabras conocidas como: conjunto, almacenar, cargar, y saltar. En el contexto de la lengua materna de la máquina, podemos hacer referencia a estos términos con un lenguaje más natural como mnemotécnicos, o dispositivos para ayudarnos a entender y recordar los comandos de máquina subyacentes.
Aunque Assembly fue un gran paso adelante en la simplificación de la programación, es todavía un enfoque denso y complejo, todavía necesita un montón de código para hacer cosas relativamente sencillas. Por ejemplo, el siguiente es el código de la Assembly da como salida la frase: “Feliz programación creativa”
; código basado en el ejemplo: http://michaux.ca/articles/assembly-hello-world-for-os-x
; A “Feliz programación creativa!” programa con NASM
sección .text
mundial c3Start
c3Start:
empujar msglen dword
empujar mymsg dword
empuje dword 1
mov eax, 0x4
sub esp, 4
int 0x80
añadir esp, 20
empuje dword 0
mov eax, 0x1
sub esp, 4
int 0x80
sección .data
mymsg db “Feliz programación creativa!”, 0xa
msglen equ $ -mymsg
En comparación, aquí está el código para hacer lo mismo en Java:
// A “Feliz programación creativa!” programa en Java
Y, por último, aquí está el mismo programa en Processing:
// A “Feliz programación creativa!” programa usando Processing
println (“Feliz programación creativa!”);
Si no era obvio, Java, y especialmente Processing, reduce en gran medida el número de líneas en el código. Además, si lees el código de ejemplo, sospecho que fuiste capaz de entender mucho más de el código Java y Processing que de Assembly.
Los primeros ensambladores de lenguajes, el software que convierte el código Assembly a lenguaje de máquina, surgieron en torno a 1950. Java fue lanzado a mediados de la década de 1990. En los cuarenta años entre Assembly y Java, se desarrollaron muchos otros lenguajes de programación. Uno de los lenguajes más importantes que surgieron, que influenció fuertemente a Java y en última instancia, a Processing, era el lenguaje de programación C. Para nuestra discusión, no es necesario decir mucho más acerca de C, aparte de eso, es un nivel considerablemente más alto que Assembly, y se adoptó muy ampliamente. En comparación con Assembly, C reduce en gran medida las líneas de código necesaria para programar un ordenador. La gramática del lenguaje de programación Java, más comúnmente conocida como la sintaxis del lenguaje, se basa en gran medida en C, pero como aprenderás, Java es un lenguaje con un enfoque, incluso de más alto nivel que C.
El desarrollo de Java era, por algunos estándares, un fracaso. Java fue desarrollado inicialmente para televisión interactiva y en última instancia para conectar dispositivos “inteligentes”, que en realidad no capturan hasta unos quince años después de la liberación de Java. Damos por sentado ahora que nuestros televisores de pantalla plana más nuevos y lisos se conectan a Internet, lo que nos permite navegar por la red mientras vemos series bajo demanda y revisamos nuestro correo electrónico. Ya en 1995, se trataba de una quimera en manos de unos pocos fanáticos tecnológicos.
Java fue diseñado como un lenguaje de programación con todas las funciones, como C, pero con una portabilidad diferencial universal muy grande. El lema original de Java era “escribe una vez, ejecuta en todas partes”. La idea era que un programador podría escribir un programa Java en cualquier máquina, y el programa se ejecute constantemente en cualquier otra máquina. Esto puede no parecer una gran cosa a primera vista, pero los ordenadores no son simplemente las palabras de moda a las que las que hemos reducido: Mac, Windows, Linux. Los ordenadores están compuestas por una gran cantidad de piezas complejas, tales como unidades centrales de Proceso (CPU), las unidades de procesamiento gráfico (GPU) y la memoria de acceso aleatorio (RAM), sólo para nombrar algunos.
Estas piezas, especialmente la CPU, el cerebro principal de la computadora, se basan en instrucciones específicas, el lenguaje de máquina, para hacer su magia. Por desgracia, estas instrucciones de la máquina varían mucho de no sólo las de informática, sino también componentes específicos de hardware como CPU.
Volviendo a nuestra conversación sobre el lenguaje de programación de la Assembly, te enteraste de que Assembly envuelve lenguaje de máquina con la mnemotecnia añadiendo más comandos de lo normal, haciendo sonar lingüísticas a las matemáticas binarias subyacentes. El lenguaje C lleva el proceso un paso más allá, en un sentido envolviendo el lenguaje ensamblador con una construcción de lenguaje de alto nivel, lo que simplifica enormemente la programación. Por ejemplo, una línea de código C podría reemplazar diez líneas de Assembly. El problema con la forma
en que este enfoque funciona es que el código (sin tener en cuenta si se trata de la Assembly o C) todo se sigue reduciendo a lenguaje de máquina, y como se mencionó anteriormente, el código de lenguaje de máquina es específico para el hardware de la máquina que está trabajando. Para ejecutar un programa en C, es necesario convertir explícitamente el código C a lenguaje de máquina para su CPU específica.
Nos referimos a este proceso como compilación. El compilador del lenguaje C es un software que convierte el código fuente en C en el idioma nativo de la máquina, el código binario (de 1 y 0).
Entonces, ¿cómo Java mejora esta situación? Java incorpora una capa adicional de software, llamado un intérprete de lenguaje, o para usar la jerga de Java, una Máquina Virtual Java (comúnmente abreviado como JVM). El código Java, como el código C, se compila. Sin embargo, el código de Java no se compila hasta el nivel de máquina nativo, que a su vez sería específica de hardware. Más bien, el código Java se compila a una forma universal superior, llamado código de bytes. El código de bytes de Java es universal, ya que debe ser capaz de funcionar en cualquier máquina, independientemente del hardware subyacente de la arquitectura, siempre que el producto incluya una máquina virtual Java.
Si vuelves de nuevo a nuestra discusión anterior, el lenguaje Java era un fracaso inicial salvado por la proliferación de Internet. Internet es una vasta red de computadoras, con una amplia variedad de configuraciones de hardware, ejecutando varios sistemas operativos. La declaración de Java, incluyendo su compilador (a byte code) y su intérprete (JVM), se convirtió en la solución perfecta para conectar todos estos dispositivos dispares. Además, algunos navegadores web incluyen su propia máquina virtual de Java, permitiendo que los programas Java (conocidos como applets en este contexto) funcionar también en la Web. Para saber más sobre la interesante historia interesante de Java, consulta:
Además de Internet, Java también está teniendo un impacto dramático en la informática móvil, y más en general, en todas partes, con máquinas virtuales Java ampliamente disponibles para la mayoría de nuestros dispositivos portátiles y de mano. Por ejemplo, el sistema operativo Android de Google está basado en Java. Así que al final, parece que Java, al igual que otras ideas revolucionarias, no era tanto un fracaso como adelantado a su tiempo.
Eso no quiere decir que Java está exento de críticas. Java sigue siendo un lenguaje complejo, difícil aprender y difícil de enseñar en el aula como introducción a la informática. Algunos críticos también culpan a Java por ser más lento que un lenguaje puramente compilado como C, que no necesita ser ejecutado a través de un intérprete del lenguaje. (Es un tema muy caliente en cuanto a cuánto más lento es Java en realidad comparado con un lenguaje puramente compilado como C) Desde la liberación de Java, muchas otras nuevas lenguas se han desarrollado y apuntan a reducir aún más la complejidad de la programación. Una de ellas es Processing, que no ha dejado de crecer en popularidad desde su lanzamiento en el año 2001. A pesar de que Processing es de hecho un entorno de programación independiente, con su propio lenguaje, aprenderás que también está indisolublemente ligado a Java.
Processing, el software libre y de código abierto desarrollado por Ben Fry y Casey Reas en el Laboratorio de Medios del MIT en 2001.
Las funciones de Processing nos proporcionan las herramientas para la elaboración de gráficos en pantalla que proveerá retroalimentación visual inmediata y pistas en cuanto a lo que el código está haciendo. Y como cualquier otro lenguaje de programación, Processing emplea los mismos principios, estructuras y conceptos de otros lenguajes de programación (específicamente Java), todo lo que aprendas con Processing es programación real. No es solo un lenguaje fácil para empezar a programar, Processing tiene todos los fundamentos y conceptos básicos que tienen todos los lenguajes.
Después de seguir este taller y aprender a programar, es posible seguir utilizando Processing en tu vida académica o profesional como una herramienta de creación de prototipos y para producir. También puedes tomar los conocimientos adquiridos aquí y aplicarlo a aprender otros lenguajes de programación y entornos de creación.
El aprendizaje de los conceptos básicos te ayudará a ser un ciudadano mejor informado en tecnología a medida que trabajes en proyectos de colaboración con otros diseñadores y programadores.
Puede parecer una exageración enfatizar el por qué con respecto al tratamiento. Después de todo, el enfoque de este taller es principalmente el aprendizaje de los fundamentos de la programación en un contexto gráfico. Sin embargo, es importante tomar algún tiempo para reflexionar sobre las razones detrás de la selección un lenguaje de programación para un taller de programación creativa, una clase, una tarea, una aplicación web, una suite de software, y así sucesivamente. Después de todo, ahora te vas a llamar a ti mismo programador en las fiestas de cumpleaños, esta pregunta te la van a plantear una y otra vez. Necesito la programación a fin de lograr el proyecto X, ¿qué lenguaje y que entorno debo utilizar?
Yo digo, sin ninguna duda, que para ti, el principiante, la respuesta es Processing. Su sencillez es ideal para alguien que desea iniciarse en la programación. Al final de este capítulo, estarás preparado para aprender los conceptos fundamentales de la programación. Pero la simplicidad no es donde Processing termina. Un viaje a través de la exposición en línea de Processing (http://processing.org/exhibition/) y descubrirás una gran variedad de proyectos bonitos e innovadores desarrollados íntegramente con Processing.
Al final de este taller, tendrás todas las herramientas y conocimientos necesarios para tomar tus ideas y convertirlas en proyectos de software del mundo real, como las que se encuentran en la exposición. Processing es genial tanto para el aprendizaje, como para la producción, hay muy pocos entornos y lenguajes de programación de los que se pueda decir lo mismo.
En su mayor parte, este blog supone que tienes un conocimiento básico de cómo operar con tu computadora personal. La buena noticia, por supuesto, es que Processing está disponible para su descarga gratuita.
Dirígete a http://www.processing.org/ y visita la página de descarga. Si eres un usuario de Windows, verás dos opciones: “Windows (estándar)” y “Windows (experto).” Puesto que estás leyendo este blog, es muy probable que seas un principiante, en cuyo caso obtendremos que la versión estándar. La versión de expertos es para aquellos que ya han instalado Java en sus equipos. Para Mac OS X, sólo hay una opción de descarga. También hay una versión para Linux disponible.
Los sistemas operativos y los programas cambian, por supuesto, por lo que si este párrafo está obsoleto, visita la página de descarga en el sitio para obtener información sobre lo que necesitas.
En estos momentos ya puedes descargarte la versión 3 de Processing.
El software de Processing llegará como un archivo comprimido. Elegir un buen directorio para almacenar la aplicación (por lo general “c: Archivos de programa ” en Windows y en “Aplicaciones” en Mac), extrae los archivos allí, busca el archivo ejecutable “Processing”, y ejecútalo.
El entorno de desarrollo de Processing es un entorno simplificado y minimalista para escribir código en tu equipo, y es casi tan fácil de usar, como cualquier software de edición de texto (como TextEdit o el Bloc de notas), y se combina con un reproductor de medios. Cada Sketch (los programas de Processing se denominan “Sketch”) tiene un nombre, un lugar donde se puede escribir código, y algunos botones para guardar, abrir y ejecutar bocetos. Ver Figura 2.1.
Figura 2.3
Para asegurarse de que todo está funcionando, es una buena idea para tratar de ejecutar uno de los ejemplos de Processing. Vaya a ARCHIVO > EJEMPLOS y elige uno de los Sketch que Processing tiene como ejemplo.
Una vez que hayas abierto el ejemplo, haz clic en el botón “PLAY”. Si una nueva ventana se abre al ejecutar el ejemplo, significa que está todo listo! Si esto no ocurre, visita el FAQ en línea “Processing no arranca!!” Para posibles soluciones. La página se puede encontrar en este enlace directo:
Los programas de Processing también se pueden ver en pantalla completa (conocido como “modo de presentación” en Processing). Este está disponible a través de la opción de menú: Sketch→ Presentar (o shift-click en el botón de ejecución). Presentación no cambia el tamaño de la resolución de su pantalla. Si desea que el boceto para cubrir toda la pantalla, debe utilizar sus dimensiones de la pantalla de size().
________________________________________________________________________ NOTA: Processing 3 se han incorporado un par de nuevas funciones que nos permite modificar el tamaño de nuestro skecth. surface.setResizable(true); y surface.setSize(w, h); sobre las cuales hablaremos más adelante.
________________________________________________________________________
Si quieres saber las mejoras y cambios que ha sufrido Processing 3 con respecto a su versión anterior puedes leer la siguiente entrada del blog Novedades en Processing 3.
Los programas de Processing se denominan de manera informal como Sketch (bocetos en inglés), guardando cierto espíritu con el prototipado rápido de gráficos, y vamos a emplear este término a lo largo de este blog. La carpeta donde se almacenan los Sketches se llama “book of sketches.”
Técnicamente hablando, cuando se ejecuta un sketch en Processing se ejecuta como una aplicación local en el equipo. Como veremos, Processing también te permite exportar sus bocetos como applets web (mini-programas que operan integradas en un navegador) o como aplicaciones independientes específicas de la plataforma (que podría, por ejemplo, poner a disposición para su descarga).
Ve al menú Archivo y selecciona “Nuevo” y generará un nuevo boceto en blanco denominado por fecha. Es buena idea ir al menú Archivo y “Guardar como” y crear tu propio nombre de sketch.
(Nota: Processing no permite espacios ni guiones, y su nombre de sketch no puede comenzar con un número.)
La primera vez que ejecutaste Processing, un directorio por defecto “Processing” se creó para almacenar todos los bocetos de la carpeta “Mis documentos” en Windows y en “Documentos” en iOS X. Aunque puedes seleccionar cualquier directorio en tu disco duro, esta carpeta es el valor de manera predeterminada. Es una buena carpeta para usar, pero se puedes cambiarla mediante la apertura de las preferencias de Processing (que están disponibles en el menú Archivo).
Es hora de empezar a escribir algo de código, vamos a repasar algunas reglas sintácticas básicas.
Hay tres tipos de declaraciones podemos escribir:
• Las funciones
• Las operaciones de asignación
• Estructuras de control
Por ahora, cada línea de código será una llamada a una función. Vamos a explorar las otras dos categorías en los próximos capítulos.
Las funciones, normalmente, tienen un nombre, seguido de un conjunto de argumentos entre paréntesis.
Una función muy importante es size( ).
//Tamaño de la ventana de reproducción de 250px por 250px.size(250, 250);
size( ) especifica las dimensiones de la ventana que desea crear y toma dos argumentos, anchura y altura. La función size( ) siempre debe ser el primer argumento.
size(width, height);
Hay algunos artículos adicionales a tener en cuenta.
• El editor de texto Processing aporta color a palabras conocidas (a veces conocidas como las palabras “reservadas” o “palabras clave”). Estas palabras, por ejemplo, son las funciones de dibujo disponibles en la biblioteca de Processing, tipos de variables y constantes, así como ciertas palabras que hereda de Java.
• A veces, es útil para mostrar información de texto en la ventana de mensajes de Processing (que se encuentra en la parte inferior). Esto se logra usando la función println( ).
println( ) toma un argumento, una cadena de caracteres entre comillas. Y lo muestra en la ventana de mensajes. Es muy útil para saber el valor de una variable durante la ejecución de un programa.
• El número en la esquina inferior izquierda indica el número de línea que tienes seleccionada en tu editor.
• Puedes escribir “comentarios” en su código. Los comentarios son líneas de texto que ignora Processing cuando el programa se está ejecutando. Los comentarios en programación, normalmente se utilizan como recordatorios para saber qué esta haciendo cada parte del código.
Comentarios en una sola línea se crean con dos barras inclinadas, //. Comentarios sobre múltiples líneas están marcadas por /* seguido de los comentarios y terminando con */.
// Esto es un comentario de una sola línea/* Esto es un comentario multilíneay puedes escribir tanto como quieras.Processing ignorará el texto que se encuentra aquí dentro */
Intenta adquirir el hábito de escribir comentarios en tu código. Usa comentarios para todo. El código es muy difícil de leer y entender sin comentarios. No necesitas tener un comentario en cada línea de código, pero cuanto más se incluyen, más fácil será de revisar y reutilizar el código más tarde.
Los comentarios también te obligan a entender cómo funciona el código que se está programando. Si no sabes lo que el código está haciendo, ¿cómo se puede escribir un comentario sobre él?
Los ejemplos anteriores sólo funcionan porque no cometimos ningún error o errores tipográficos. Los errores tipográficos son muy comunes en programación. Si cometemos un error de sintaxis nuestro programa no va a funcionar. Si hay un error no se abrirá la ventana de dibujo, y mostrará en su lugar el mensaje de error.
Processing es case sensitive!
Processing distingue entre mayúsculas y minúsculas, si en lugar de size(200, 200); escribes Size(200, 200); Processing te informará de un fallo.
Si se producen varios errores, simplemente te alertará del primero que encuentre (y, normalmente, una vez que se corrige ese error, se mostrará el siguiente error en tiempo de ejecución). Esto es algo así como una limitación desafortunada, ya que a menudo es útil tener acceso a una lista completa de errores al escribir un programa. Esto es simplemente una de las ventajas y desventajas que recibimos en un entorno simplificado como Processing.
Las funciones que hemos utilizado son parte de la biblioteca de Processing. ¿Cómo sabemos que “elipse” no se escribe “elipse”, o que rect() toma cuatro argumentos (x, y, width, height)?
Una gran cantidad de estos detalles son intuitivos, y esto habla de la fortaleza de Processing como lenguaje de programación para principiantes. Sin embargo, la única manera de saber con seguridad es mediante la lectura de la referencia en línea. Si bien vamos a cubrir muchos de los elementos de la referencia a lo largo de este blog, de ninguna manera es un sustituto de la referencia y ambos serán necesarios para que puedas aprender Processing.
En la web oficial (http://www.processing.org) bajo el enlace “reference”. Puedes navegar por todas las funciones disponibles por categoría o por orden alfabético.
Si vemos la página para rect(), ofrece documentación completa para la función rect(), incluyendo:
• Name: el nombre de la función.
• Examples: Ejemplo (y resultado visual, en su caso).
• Description: Una descripción amable de lo que hace la función.
• Syntax: sintaxis exacta de cómo escribir la función.
• Parameters: Estos son los elementos que van dentro de los paréntesis. Te dice qué tipo de datos acepta (un número, carácter, etc.) y lo que ese elemento representa. Éstos también se refieren a veces como “argumentos”.
• Returns: A veces una función envía datos de un “tipo” concreto en lugar de dibujar una forma. Este apartado te informa del “tipo” de dato que devuelve.
• Usage: Algunas funciones están disponibles para mostrar Processing la web y otras funciones solo se representarán como aplicaciones de escritorio. Usage te informa sobre esto.
• Related Methods: funciones relacionadas con la función que estamos viendo, algunas funciones trabajan en equipo, Processing te ofrece un listado aquí.
Processing también tiene una opción muy útil “find reference”. Haga doble clic en cualquier palabra clave para seleccionarla y accede al menú HELP /→FIND IN REFERENCE (o seleccione la palabra clave y SHIFT + CNTRL + F).
Una de las buenas cualidades de Processing es que todo lo que uno tiene que hacer para ejecutar un programa es presionar el botón “PLAY”. Es una bonita metáfora y la hipótesis es que estamos cómodos con la idea de jugar con animaciones, películas, música y otros medios de comunicación. Los programas de Processing tienen como salida de medio gráficos en tiempo real, así que ¿por qué no jugar con ellos?
Sin embargo, es importante tomar un momento y considerar el hecho de que lo que estamos haciendo aquí no es lo mismo que lo que sucede en un iPod. Los programas de Processing comienzan como texto, que se traducen en código máquina, y luego son ejecutados para funcionar. Todos estos pasos suceden en secuencia al pulsar el botón de reproducción. Vamos a examinar estos pasos uno por uno.
Paso 1. Traducir a Java. Processing es realmente Java. Para que el código se ejecute, primero debe ser traducido a código Java.
Paso 2. Compilar a código Java en bytes. El código Java creado en el paso 1 es sólo otro archivo de texto (con la extensión .java en lugar de .pde). Para que el equipo la comprenda, debe traducirse en lenguaje de máquina. Este proceso de traducción se conoce como compilación. En el caso de Java, el código se compila en un lenguaje de máquina especial conocido como código de bytes de Java. Puede funcionar en diferentes plataformas (Mac, Windows, teléfonos celulares, PDAs, etc.), siempre y cuando la máquina está en marcha un “servidor virtual de Java.”
Aunque esta capa extra a veces puede hacer que los programas se ejecuten un poco más lentos de lo que podrían de otro modo, siendo multi-plataforma es una gran característica del Java. Si desea obtener más información sobre cómo funciona esto, visita http://java.sun.com.
Paso 3. Ejecución. El programa compilado termina en un archivo JAR. Un JAR es un archivo histórico de Java que contiene los programas compilados de Java (“clases”), imágenes, fuentes y otros archivos de datos. El archivo JAR es ejecutado por la máquina virtual de Java y es lo que hace que la ventana de la pantalla que aparezca.
