• Parte I: Destripando: Instants Chile Get! – Planificación

Voy a ser honestos con ustedes, no tengo idea de qué cosa significa exactamente una «prueba de concepto». La utilizo según lo que me parece que quiere decir, “probar” si es posible dar con una pequeña prueba para luego generalizarla. Claramente el objetivo de mi aplicación, es bastante general (descargar todos los archivos y decodificarlos). Por lo que antes de comenzar a ver como descargar todos los archivos, sería más prudente descargar alguno y ver si efectivamente puedo transformarlo en un formato audible que no sea swf. ¿Imaginan que logro dar con una fórmula para descargar todo y finalmente resulta que no puedo hacer nada con los archivos?.

Esto por supuesto, puede tener muchos acercamientos (incluso ni siquiera utilizar un prototipo), personalmente me gusta lo que pregona la metodología ágil (algún día hablaré de ello); que consiste básicamente[2] en trabajar en base a iteraciones y pequeñas metas, de forma de que cada cierto intervalo corto de tiempo (cada día por ejemplo) se avance algo, aunque signifique modificar y reparar el código más de alguna vez. Esto permite tener una percepción de “ir avanzando” y no quedarse “pegado” en soluciones complejas, además darle muchísimo más dinamismo.

Por otra parte, me parece mucho más simple dar con una solución única y luego buscar la forma de generalizarla que desgastarse en problemas más difíciles de abordar, especialmente cuando recién nos sentamos y parece abismante la cantidad de trabajo que queremos realizar.

Manos a la obra

Descargando

Lo primero, entonces será encargarnos de descargar alguno de los archivos. No sé como hacerlo en otros navegadores que no sean Firefox, pero supongo que deben tener procedimientos similares. Nos vamos a la página del instant que queremos utilizar como prueba (sí, no podría dejar pasar a Carlitox) y luego:

• Nos vamos al menú Herramientas » Información de la página, o
• Apretamos el botón derecho y escogemos “Información de la página”, o
• (mi favorita) <Ctrl> + <i>

En los tres casos nos veremos con una pantalla más o menos así:

Nos vamos a la pestaña “Media” buscamos el archivo y pinchamos en “Guardar como”. Por si fuera poco (y sin quererlo) descubrimos el lugar donde está almacenado (http://www.axonema/instants/swf2/jojojo.swf), y con bastante lógica podríamos suponer que todos los instants están guardados en una carpeta llamada swf2. Nuestro objetivo pues en alguna iteración ulterior será la de descargar todos los archivos con extensión swf de dicha carpeta.

Decodificando

Perfecto, ya tenemos nuestro archivo, ahora faltaría comprobar si es posible decodificarlo, una rápida búsqueda en google nos llevará a que la herramienta que permite destripar este tipo de archivo: swftools, por lo que tendremos que encargarnos de instalarla.

Nos desplazamos a través de la terminal al directorio donde hayamos descargado el joJÓjo y probamos swfextract:

swfextract jojojo.swf
Objects in file jojojo.swf:
[-i] 7 Shapes: ID(s) 3-9
[-i] 1 MovieClip: ID(s) 1
[-s] 1 Sound: ID(s) 10
[-f] 1 Frame: ID(s) 0

Hm, tiene 1 Sound, que está como ID 10… extraigámoslo:

swfextract -s 10 jojojo.swf -o jojojo.mp3

(por supuesto que un swfextract --help ayuda bastante!)

¡Perfecto! Extrajimos el audio en mp3 y funcionó sin problemas. Podríamos aprovechar de probar si es posible decodificar el mp3 y pasarlo a wav. Para esta tarea, no se me ocurre nada mejor (ni más simple) que utilizar LAME, así que lo siguiente será instalarlo.

En el mismo directorio, ejecutamos:

lame --decode jojojo.mp3 jojojo.wav

Voilà!

[1] Quizá “prototipo” sea el término más adecuado…

[2] En realidad es una simplificación bastante burda, pero sirve de forma académica

Imagen:

• Robot por Julien Tromeur en Stock.xchng

Compartir

Al menos en mi percepción, lo más importante de la programación es saber abstraerse; si bien, todos los lenguajes tienen sintaxis, reglas y exigencias distintas a la hora de programar (que el “;” al final de cada línea, que la indentación, etc). Al final todos poseen ciertos denominadores comunes, como estructuras de control (if, else), bucles, iteraciones, etc. La idea de esta serie, si bien aprender algo de bash y scripting, es también aprender técnicas y/o sugerencias para ayudar a programar un poco mejor.

Luego de esta introducción, comenzamos la primera parte: la planificación.

La motivación de programar no es por generación espontánea, habitualmente responde a algún problema o necesidad que debe ser resuelto. En este caso no es distinto, tengo una página web, con cierto contenido que inicialmente sólo me permite escucharlo por internet. Más de alguna vez he echado de menos tener la posibilidad de contar con esos sonidos en momentos que lo ameritan, por lo que ya tengo el objetivo principal de la aplicación: descargar los instants de la página web.

Con esta información pues, tenemos que investigar algunas cosas; comenzando por si existe alguna aplicación similar. Esto puede parecer obvio, pero es increíble lo difícil que es ser original. Teniendo ya este punto, nos vamos a mirar la página web en cuestión, donde una rápida mirada (botón derecho en uno los botones) veremos que son sonidos flash.

Con este nuevo obstáculo, veremos que nuestro simple plan se complejiza un poco:

1. Descargar todos los sonidos
2. Transformarlos a mp3/wav

Aunque el trabajo que vayan a realizar, parezca simple (o que en definitiva lo sea) me ha dado mejor resultado planear lo que voy a hacer antes de tirarme de cabeza a escribir el código, a la larga, ahorra tiempo y es mucho menos frustrante que empezar y darse cuenta cada 10 minutos que lo que parecía sumamente sencillo no lo era tanto.

Afortunadamente, mi carrera (Medicina) me obliga a ser metódico, ¿imaginan que cada vez que examinara a un paciente lo hiciera en distinto orden?

Sería dramático (de hecho, es uno de los típicos errores de los estudiantes de medicina cuando recién ingresan a las labores clínicas), de esa forma es muy fácil omitir cosas importantes. En cambio si uno lleva el mismo orden —independiente de cuál sea— además de memorizarlo con mayor facilidad, simplifica enormemente la tarea de ir agregando o retirando “pasos” para hacer más eficiente/efectivo el sistema.

Por supuesto que la herramienta a escoger no es algo que se pueda afirmar con certeza absoluta, es a conveniencia de cada persona. Para alguien podría ser útil realizar un listado (receta de cocina) lo más detallado posible, realizar un diagrama de flujo, utilizar pseudocódigo, y/o muchas más.

Esta fase también nos puede permitir tomar una mejor decisión sobre qué lenguaje utilizar. En ese sentido, no es lo mismo diseñar una aplicación web (php), una aplicación de escritorio (python-gtk) o un script simple como el que motiva esta serie.

Si ya contásemos con más experiencia en algún lenguaje (o en programación en general), podríamos hilar incluso más fino. Por ejemplo, si quisiéramos desarrollar alguna aplicación basada en el API de delicious, sabríamos que debemos tratar con archivos XML. Con este antecedente, podríamos investigar qué lenguaje cuenta con mejores bibliotecas[1] o las que sean más fáciles de manipular para el objetivo particular que andamos buscando.

Por último, todo esto no es sólo válido para trabajos personales, también lo es para trabajo en equipo; invertir unas horas más fuera de los computadores para hacer un esquema de la aplicación y planificar los distintos aspectos, facilita en gran medida que cada miembro tenga claro el rol que cumplirá y no será necesario interrumpir el trabajo, sólo para descubrir que el proyecto era inviable o los estilos de los códigos causan estragos en la comprensión de las aplicaciones.

Lamento que esta parte haya sido tan “latera”, desde la próxima parte ya empezaremos a tipear código; diría “programar”, pero la verdad es que sería una redundancia pues ya lo empezamos a hacer ;)

[1] Por supuesto que esto es una simplificación casi absurda, dudo que exista algún lenguaje que tenga un mal soporte para parsear archivos XML.

Foto:

• Php Code por Kakao Por en Stock.xchng

Compartir

Si eres alguno de los últimos (nunca faltan), paso a dar una pequeña descripción: los instants son esos pequeños momentos que por alguna razón pasaron a la historia, tenemos el clásico joJÓjo de Carlitox, el archi-conocido (al menos en Chile)  “¡Aer quien e’ el dostor!”, el semipterno Rick Roll o el clásico “EA Sports It’s in the game”, todo ello al alcance de un botón rojo.

¿Cuántas veces han querido tener ese sonido en su computador o en el celular para complementar ese momento que también lo ameritaba? Todo ello y más luego del salto…

La buena noticia es que acabo de desarrollar un pequeño script de Bash que obtiene todos, ¡sí! ¡todos! los sonidos desde instants.cl. Esto no habría sido posible sin los trabajos previos de Gon y Felipe Astroza.

Respecto a sus versiones anteriores, este script:

• Descarga los sonidos sólo una vez (el de Gon lo hacía dos veces)
• El código ha sido “simplificado”
• Utilicé Arrays (sí, de BASH) para establecer las “dependencias”
• Mejoré un poco la interfaz y las salidas son más explicativas

Si miran se podrán dar cuenta que aún hay algunas cosas que mejorar y que faltan:

• Utilizar un directorio temporal (en /tmp), en vez de crear una carpeta “on-the-fly” y luego eliminarla
• Preguntar al usuario dónde descargar los sonidos
• Dejar opcional la posibilidad de utilizar curl o wget
• Preguntar a qué formato el usuario quiere transformar los archivos (actualmente lo hace a mp3 y wav)

El script está disponible aquí, en un gist de Github, o a continuación. Me gustaría detenerme en lo de “un gist” (un especie de lugar para almacenar snippets) , esto significa que está funcionando como repositorio (de git por supuesto), pueden descargarlo, hacer un fork, clonarlo y ver los logs del desarrollo y lo más interesante, pueden hacer mejoras para luego yo incluirlas en la versión definitiva.

Si quiere algo más simple, también lo incluyo acá (click para desplegar):

#!/usr/bin/env bash
#
###############################################################################
#                                                                             #
#   (c) 2010, Pablo Olmos de Aguilera <pablo[at}glatelier.org>;               #
#   Based on work from Gonzalo Diaz <me{at)gon.cl>;                           #
#   http://gon.pastebin.com/zanh8uAq                                          #
#                                                                             #
#   Based on InstantsFunGet from Felipe Astroza <felipe(at]astroza.cl>        #
#   http://felipe.astroza.cl/news/2010/05/08/audios-de-instantsfun-es-en-mp3/ #
#                                                                             #
#   This program is free software: you can redistribute it and/or modify      #
#   it under the terms of the GNU General Public License as published by      #
#   the Free Software Foundation, either version 3 of the License, or         #
#   (at your option) any later version.                                       #
#                                                                             #
#   This program is distributed in the hope that it will be useful,           #
#   but WITHOUT ANY WARRANTY; without even the implied warranty of            #
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             #
#   GNU General Public License for more details.                              #
#                                                                             #
#   You should have received a copy of the GNU General Public License         #
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.     #
#                                                                             #
###############################################################################

#==============================================================================
#
#          FILE:  instants_cl_mp3_downloader.sh
#
#   DESCRIPTION:  Download every 'instant' from instants.cl to a folder.
#
#      REVISION:  0.9
#==============================================================================

#
# Constants
#

SOURCE_HOST=http://www.instants.cl/search?max-results=1000

# TODO: Use mktemp
TEMP_DIR=tmp

# TODO: Ask user
COLLECTION_DIR=collection

# TODO: make optional wget or curl
# TODO: ask if the user wants to convert to wav
REQUIREMENTS=( lame wget swfextract )

function prepare() {
    for app in ${REQUIREMENTS[@]}; do
        if ! type -P ${app} &>/dev/null; then
            # TODO: Find a way to make bash find that swfextract is part from swftools
            [[ $app = "swfextract" ]] && app="swftools"
            not_installed=("${not_installed[@]}" "$app")
        fi
    done

    if [ ${#not_installed[@]} != 0 ]; then
        echo "Sorry, the following apps have to be installed to run this script:" >&2
        for required_app in ${not_installed[@]}; do
            printf "   %s\n" $required_app
        done
        exit 1
    fi

    mkdir -p $TEMP_DIR $COLLECTION_DIR
}

function cleanup() { rm -fr $TEMP_DIR; }
function get_swf_list() {
    echo $(cat $1 | grep swf | awk 'BEGIN {FS="\""}; {print $12}');
}

function get_index() {
    wget -q $1 -O $TEMP_DIR/index
    echo "$TEMP_DIR/index"
}

#
# Starting Application
#

prepare

echo "InstantsChileGet-Improved - (C) 2010 Pablo Olmos de Aguilera"
echo "Based on: InstantsChileGet - (C) 2010 Gonzalo Diaz"
echo "based on: InstantsFunGet - (C) 2010 Felipe Astroza"
echo -n -e "Reading index\r"
swf_list=$(get_swf_list $(get_index $SOURCE_HOST))

# Deleting $TEMP_DIR/to_download if exists
[[ -e $TEMP_DIR/to_download ]] && rm $TEMP_DIR/to_download

for swf in $swf_list; do
    echo $swf >> $TEMP_DIR/to_download
done

# Remove duplicated entries
swf_list=$(cat $TEMP_DIR/to_download | uniq )

TOTAL=$(echo $swf_list | wc -w)
current=1

for swf in $swf_list; do
        name=$(echo $swf | awk 'BEGIN {FS="/"}; {print $6}')
        echo -e -n "\r[$current of $TOTAL]\e[0K $swf => $TEMP_DIR/$name\n"
        wget -q -nc $swf -P $TEMP_DIR/
        let "current++"
done

echo "Now we are going to extract the sound..."
sleep 5

current=1

for swf in $TEMP_DIR/*.swf; do
        filename=$(basename $swf)
        name=${filename%.*}
        echo -e -n "\r[$current of $TOTAL]\e[0K Extracting sound from: \
        $swf => $COLLECTION_DIR/$name.mp3\n"
        sound_id=$(swfextract $swf | grep Sound: | awk '{print $5}')
        swfextract -s $sound_id $swf -o $COLLECTION_DIR/$name.mp3
        lame --decode $COLLECTION_DIR/$name.mp3 $COLLECTION_DIR/$name.wav
        let "current++"
done

cleanup

Para los que les interese un poco más aprender algo de scripting, les cuento que este script contiene varias a respuestas a problemas típicos (extraer campos de una dirección, obtener el nombre sin extensión, entre otros), por lo que revisar el código les puede ser bien útil.

De hecho, comenzaré una serie de artículos donde iremos paso a paso desarrollando este script, desde la ideación, prueba de concepto, pseudocódigo y finalmente el código propiamente tal. Todo esto, para que podamos ir aprendido “abstracciones” y responder al cómo programar, más que a “aprender Bash”.

PS.- Este artículo va con trackbacks para ambos Felipe y Gon, espero que funcionen.

Compartir

Este artículo fue escrito por Julian Eduardo Onoa Aguirre, bloguero del sitio Somewhere back in Linux…. Agradecemos también su diposición a celebrar con nosotros nuestro primer millón

Saludos!

Por estos días uno de los mejores blogs que sigo desde hace mas o menos un año llega al millón de visitas. Como blogger puedo decir que llegar a este nivel no es nada sencillo, se requiere muchísimo trabajo y dedicación. Por eso para mí es un gran honor (y un placer!) poder ser partícipe de esta gran fiesta y poder contribuir con un mini-tutorial para celebrar este gran logro que Geeks & Linux Atelier festeja por lo alto. Aprovecho la oportunidad que me han dado de escribir en su sitio y les traigo un sencillo tutorial de instalacion de joomla! en Ubuntu (de hecho sirve para cualquier distribución Linux) y que espero que sea de utilidad y sobre todo que esté a la altura de los buenos tips que día a día Geeks & Linux Atelier comparte con todos nosotros. Bueno, manos a la obra….

Para los que no saben en qué consiste Joomla!, y sin ir más allá, les dejo la descripción de Wikipedia: “Joomla! es un sistema de gestión de contenidos, y entre sus principales virtudes está la de permitir editar el contenido de un sitio web de manera sencilla. Es una aplicación de código abierto programada mayoritariamente en PHP bajo una licencia GPL. Este administrador de contenidos puede trabajar en Internet o intranets y requiere de una base de datos MySQL, así como, preferiblemente, de un servidor HTTP Apache.

Sin más preámbulo les voy a indicar como instalé correctamente Joomla! en mi Ubuntu Lucid.

Primero que todo debes entender que Joomla! funciona sobre entornos web, y si quieres usarlo en tu equipo debes tener instalado un ambiente web. para esto primero deberás instalar LAMP en ubuntu. Una vez lo tengas listo, abre una consola y escribe lo siguiente (en este orden):

mkdir joomla
cd joomla
wget http://joomlacode.org/gf/download/frsrelease/12649/53618/Joomla_1.5.20-Spanish-pack_completo.tar.gz

Con este comando descargarás joomla!. Una vez termine la descarga debes extraer los archivos

tar xvjf Joomla_1.5.20-Spanish-pack_completo.tar.gz

En este momento ya puedes borrar el paquete que descargaste (ojo! No el contenido que acabas de extraer!)

rm -f Joomla_1.5.20-Spanish-pack_completo.tar.gz

Ahora mueve el contenido de joomla a tu carpeta www

cd ..
sudo mv joomla /var/www/

Para que todo funcione correctamente debemos dar permisos de escritura a la carpeta donde instalaremos joomla!, el método más sencillo es

sudo chown -R www-data:www-data /var/www/joomla

Existen otros métodos pero la verdad este me pareció mucho más sencillo :).  Ahora si empecemos a instalar joomla, para esto debes ingresar a esta dirección en tu navegador web favorito

http://localhost/joomla

Si todo está bien, deberás ver una ventana como esta, donde se te pide seleccionar el idioma de instalación:

Luego hará la comprobación de tu sistema verificando que tienes todo configurado para poder trabajar con joomla! sin problemas (si en este paso tienes dudas deja un comentario!):

Aceptas la licencia GNU/GPL de Joomla!

Ahora crearemos la base de datos necesaria para almacenar la información de nuestro sitio, recuerda que debes ingresar los valores que asignaste cuando instalaste MySQL

A continuación te solicitará la configuración FTP. En este caso no haremos nada ya que estamos usando nuestro propio equipo, no hay necesidad de esto.  Finalmente te pedirá que pongas los datos básicos del sitio que vamos a crear:

Bueno, y eso es todo! Luego te pedirá borrar la carpeta de instalación de instalación, lo puedes hacer con un

sudo rm -r /var/www/joomla/installation

Ahora refresca la pagina y listo!

Adicional quiero compartir con ustedes unos excelentes recursos si eres principiante como yo:

Video tutoriales de joomla! que realizó strOngbacker en su canal de youtube y que son bastante buenos para empezar

Este manual de usuario creado por reparaciondepc.cl

Bueno, creo que eso es todo. Y de nuevo felicitaciones a Geeks and Linux Atelier por su excelente trabajo. Espero que los 2 millones sean pronto!

Up the Irons! And the Geeks!

Compartir

Entre los servicios soportados encontramos Gmail, GoogleReader, Twittter, Identi.ca y cualquier correo IMAP o POP3.

Para instalarlo en Ubuntu debemos agregar el PPA del proyecto:
sudo add-apt-repository ppa:chuchiperriman/cloudsn

Y para instalarlo:
sudo apt-get update && sudo apt-get install cloudsn

En Arch se encuentra disponible en AUR:
yaourt -S cloudsn

Una vez instalado lo podrás encontrar en las aplicaciones de Internet, al seleccionarlo aparecerá un nuevo icono en nuestra bandeja del sistema.

Seleccionamos nuestro nuevo icono y podremos agregar nuestras redes favoritas.

Una vez configuradas nuestras cuentas, el programa utilizará nuestro gestor de notificaciones para avisarnos de las actualizaciones de las redes configuradas.

Si lo preferimos podemos cambiar algunas preferencias del programa, que aunque pocas son las mínimas necesarias para su correcto funcionamiento.

Ya con tu programa funcionando correctamente podrás revisar tus redes y sus actualizaciones cuando quieras solo haciendo click en el icono de CloudSN.

No soy un activo usuario de las redes sociales, pero debo decir que este programa me gustó mucho por su sencillez y porque cumple satisfactoriamente con sus funciones. Se esperan nuevas actualizaciones donde vendría el soporte de nuevas redes entre ellas Facebook.

Hasta la proxima.

Compartir

Acá desarrollaremos el manejo más básico de vectores y arrays (también conocidos como arreglos en español) en el lenguaje Fortran.

A muchos les puede sonar conocida la palabra vector, para algunos, es un organismo que transmite enfermedades, para otros (los más matemáticos) es una cantidad dirigida, o un elemento de una estructura algebraica conocida como espacio vectorial, por lo tanto partimos definiendo ¿qué es un vector o un array en Fortran?.

Básicamente un vector (o array también) es una manera de manejar una gran cantidad de datos de manera más cómoda, ¿a qué nos referimos con esto? se preguntarán algunos, bueno, más especificamente un vector es un tipo de variable, que dentro de si contiene distintos valores.

Por ejemplo, en matemáticas, podemos definir el vector A=(x,y,z) en el espacio de 3 dimensiones, en Fortran es muy similar (recordemos que el objetivo del lenguaje es ayudar en tareas de matemáticas, ciencia e ingeniería), podemos definir vectores con cuantas componentes queramos. Los arrays son un poco distintos, estos trabajan (por dar un par de ejemplos) en distintas dimensiones, con esto me refiero a filas, columnas, etc, estas imágenes son más explicativas:

Ejemplo de un array en 2D

En cada celda del recuadro cabe un valor distinto (aunque no necesariamente) y al estar en un  array se tratan como uno solo, osea, se hacen las mismas operaciones sobre todos los elementos.

Un array 3D sería:

Ejemplo de un Array 3D

Acá cada cubo representaría un valor dentro del array. no puedo poner imágenes en 4D ya que es como imposible salirse del espacio normal xD; pero ya entendieron la idea.

Tenemos que introducir una cierta terminología para que estar seguros de que entendernos lo mismo:

• Rango: número de dimensiones (1D, 2D, 3D,…)
• Extensión: número de elementos de una dimensión.
• Forma: vector de rango 1 que contiene en sus entradas la extensioń de cada dimensión.
• Tamaño: número de elementos.

Hemos de saber que tenemos, nuevamente, dos tipos de arrays, estáticos y dinamicos.

Ahora que sabemos lo básico, veamos como trabajar con ellos:

Arrays Estáticos

Reciben el nombre estático ya que SE DEBE declarar con anterioridad sus dimensiones y su extensión, siendo estas inalterables.

Al ser declarados como variables, su sintaxis es un poco distinta, respondiendo a su distinta naturaleza, digamos que queremos trabajar con vectores y arrays con entradas del tipo real, la declaración sería:

program muestra_array1
real,dimension(5)::a
real,dimension(7,8)::r,s
real,dimension(6,9)::t
real::b(7)
...
end program

Acá se tiene que a es un vector con 5 entradas, b es también un vector, pero de 7 entradas. r y s son arrays de 7×8 y t es un array de 6×9, r,s,t son de dos dimensiones.

Arrays Dinámicos

A diferencia de los estáticos, la extensión de los arrays dinámicos podemos establecerla sobre la marcha, ya sea con una variable, o un valor arbitrario, para ello hacemos uso de la sentencia ALLOCATE, al declararlo sería:

program muestra_array2
integer::n
real,dimension(:)::a
...
ALLOCATE(a(n))
...
end program

En este caso particular, a es un vector con n entradas, la sintaxis para declarar arrays es la misma.

Ahora pasaremos a la manera de como trabajar, propiamente tal, con los arrays, hay una sola regla de oro: dos arrays o vectores se pueden operar, si y solo si, ambos tienen las mismas dimensiones y extensiones. Casi todo intento de operación que no cumpla esto, no es aceptable para el programa, la excepción es la multiplicación por un escalar, un escalar es una variable normal, estas al multiplicar, se “expanden” afectando a todos las entradas del array.

La suma, resta multiplicación y división se realizan elemento a elemento, ejemplo:

Ejemplo de multiplicación de arrays

Podemos llamar a un cierto elemento de un array indicando su posición, por ejemplo, si decimos que a es el primer array mostrado en la imagen anterior print*,a(1,2) nos muestra el valor 4. En dos dimensiones siempre se convoca array(fila,columna).

Las sentencias maxval y minval buscan el valor máximo y el valor mínimo dentro del array. Ej: b=maxval(a) !a b se le asigna el máximo valor dentro de a.

Finalmente, sum nos da la suma de todos los valores dentro de un array. Ejemplo b=sum(a) !b es la suma de todos las entradas de a.

Bueno, estos son los aspectos más básicos del manejo de arrays en Fortran, con este post, llegamos al fin de la serie de Programación para Newbies: Fortran. Espero lo hayan disfrutado, como yo lo hice :D

Hasta el momento, hemos aprendido a trabajar con las distintas variables, y a usar estructuras para modificar el curso que toman nuestros programas, pero cuando nos enfrentamos a programas más extensos, que algunas veces necesitan ejecutar un mismo bucle para procesar ciertos datos, pero las variables no son las mismas, no es lo más cómodo copiar y pegar las mismas instrucciones varias veces, más todavía si tenemos que estar cambiando las variables cada vez que usemos el mismo algoritmo, para esto existen los subprogramas.

Un subprograma es una estructura que se agrega al final del programa y se puede invocar en cualquier parte del programa principal (perdonen que sea reiterativo con la palabra programa) indicando que variables participan dentro del subprograma, que cambios se les hacen, etc. Tenemos de dos tipos: functions y subroutines, sus diferencias son sutiles.

Una function (o función en castellano), son subprogramas que tienen 0 o más argumentos (variables) y que retornan un valor en el nombre, esto significa, por lo pronto, que su invocación debe estar al lado derecho de una asignación de valor a una variable y no puede formar una sentencia aislada dentro del programa. Ejemplificando:

variable=funcion(argumentos)

siempre va a la derecha la invocación de la función. La sintaxis para crear nuestras propias funciones en Fortran es la siguiente:

program programa_muestra
... sentencias e invocaciones de la función
end program

function nombre_funcion(argumentos)
declaración del tipo de argumentos
sentencias de la función
end function

¿Por qué meto una declaración del tipo de argumento en subprograma?, como una simple precaución, es importante que los tipos coincidan, por lo que si nos equivocamos al declarar una variable en el programa y compilamos, puede generar un error de ejecución desastroso que arruine todos nuestros datos, entonces si incluimos la declaración en el subprograma y nos equivocamos, lo más probable es que el compilador se queje y nos advierta de ello. Vamos a dar un ejemplo de una función de dos variables:

function mayor(aL,bL)
integer::aL,bL
if (aL .ge. bL) then
mayor=aL
else
mayor=bL
end if
end function

lo que hace esta función es analizar los dos valores enteros que entraron (aL y bL) y devuelve en el nombre el mayor valor entre ellos (por eso la función se llama mayor). Noten que les agregué una L a las variables, esto es una forma elegante de evitar un efecto similar a la contaminación cruzada en la cocina, conocido como efecto lateral (si se usan los mismos nombres que en el programa, una memoria en mal estado podría asignar nuevas direcciones a la variable original). La forma de invocarla sería:

variable=mayor(x,y)

donde x e y son valores enteros.

Como dije antes, las subroutines (subrutinas en castellano) son solo un poco distintas, en el sentido de que NO devuelven un valor en el nombre, sino que su invocación se hace por medio de la sentencia call. La forma en que trabajan las subrutinas nos permite modificar los valores que entraron como argumentos, siendo esta su característica más importante. Esta es la estructura:

program programa_muestra
... sentencias e invocaciones de la surutina
end program

subroutine nombre_subrutina(argumentos)
declaración de tipo de los argumentos
sentencias sobre los argumentos
end subroutine

nuevamente declaramos los tipos en el subprograma, con mayor razón por que esta vez trabajamos sobre ellos, un ejemplo similar al anterior es:

subroutine mayor(aL,bL)
integer::aL,bL
if (aL .ge. bL) then
bL=aL
else
aL=bL
end if
end subroutine

esta vez, dejamos ambos valores iguales, pero solo tomamos el mayor. La invocamos con:

call mayor(x,y)

donde nuevamente x e y son nuestras variables enteras.

Una pequeña observación con respecto a las subrutinas y funciones, es que los argumentos que toman los subprogramas con los que se declaran dentro del propio subprograma son relaciones uno a uno (inyectivas como decimos en matemáticas), que las variables deben conservar el orden deseado y del mismo tipo que se declararon, ya que si no se producen errores. Un ejemplo “gráfico” es:

donde la segunda llamada a la subrutina obviamente generará error. Amigos, este es el penúltimo post relacionado con Fortran, el próximo es sobre arrays y después de eso dejaría de ser programación para newbies porque ya deberían estar bien introducidos dentro del lenguaje xD

Compartir

Ustedes pudieron apreciar que yo uso lenguajes como PHP, Python y Ruby. Éstos tienen características especiales, por lo que se les llama “lenguajes dinámicos”. Pero, ¿cuál es la diferencia con un lenguaje estático?, más bien, ¿qué es lo que hace a estos lenguajes dinámicos?

Cada lenguaje de programación tiene sus propias “terminologías”. Vale decir, dependiendo de la manera en que cada lenguaje aborde un problema, crea un idioma para que los desarrolladores se comuniquen. Hay muchos ejemplos, pero no quiero confundirles, así es que les daré sólo uno: los lenguajes interpretados no tienen “tiempo de compilación”, porque el lenguaje no se compila. La idea es que un lenguaje de programación dinámico agregue todas estas características en tiempo de “ejecución”, no en tiempo de “compilación” o de “carga”.

La definición de un lenguaje dinámico es: todo aquel lenguaje que posea características que permitan alterar el curso del lenguaje de manera legítima, a través de la inyección de código o de la ejecución de funcionalidades especiales. Describiré, pues, algunas de las maneras de agregar dinamismo a un lenguaje de programación e intentaré explicarlas con pseudocódigo.

1.- Evaluación de código

Un lenguaje puede tener un mecanismo (una función eval() o una clase del tipo función) que permite “evaluar” (leer, corregir e implementar) código en el lenguaje que escribimos. Esto nos da mucha flexibilidad pero también conlleva a riesgos de seguridad, permitiendo a gente con malas intenciones escribir código que no queremos que se ejecute. Una utilidad de esto es aplicar un filtro a una función:

function recordsetfilter(Recordset $rs, $filter)
{
$newrs = new Recordset();
foreach($rs as $record)
{
$rec = new Record();
$rec = $record;
$rec->setNombre(
eval($filter)
);
$newrs->add($record)
}
return $newsrs;
}
// ... código que nos genera un Recordset

$rs = recordsetfilter($rs, 'strtoupper($this->getNombre())');

Las funciones de rango mayor son funciones que toman una o más funciones como una entrada y/o entregan una función como una salida. La misma función descrita arriba es una implementación pobre de la función map(), que toma una función y una lista o arreglo de elementos, y que retorna como resultado una lista con la función aplicada a cada elemento de la lista de entrada. PHP tiene una función llamada usort() que permite tomar una función de comparación y dependiendo de lo que esta función entregue, el algoritmo hace un ordenamiento.

2.- Alteración del objeto en tiempo de ejecución

Esto es un poco complejo, pero se refiere al cambio de la herencia del objeto.

Por ejemplo, tengo una clase automóvil que extiende a la clase vehículos y también a la clase bienes. El resultado de esta operación es que un automóvil puede ser acelerado, frenado, con el motor encendido, con el motor apagado; y además puede ser comprado, vendido, traspasado o efectuarse una tasación sobre éste.

3.- Programación Funcional

Me gustaría escribir un artículo completo relacionado con programación funcional. Es un tópico totalmente entretenido, aunque es difícil de comprender a la primera. La idea de la programación funcional es definir funciones matemáticas que luego se aplican sin importar su estado. Algo como esto en PHP.

<php

$a = array(1, 2, 3, 4);
$i = 0;

foreach($a as $e)
{
$a[$i] = funcion1(funcion2($e));
$i++;
}

foreach($a as $e)
{
echo $e.' ';
}

?>

…puede ser escrito como esto:

funcion = lambda(funcion1, funcion2) { funcion1 ( funcion2 (x) ) }
destino = map(funcion(funcion1, funcion2), a)

La idea es decir que funcion() toma como parámetros las funciones funcion1() y funcion2(), y definir que a un elemento x dado se le aplicará primero funcion2() y al resultado se le aplicará funcion1(), luego se puede mapear el arreglo a para aplicarle nuestra nueva función a cada uno de los elementos. Elementos propios de la programación funcional son los closures, las continuaciones y la reflexión de datos.

4.- Macros

Las macros permiten hacer introspección dentro del código y evaluación del mismo. Ruby provee la mayor parte de la funcionalidad de las macros a través de su sistema de orientación a objetos.

Recuerdo que decidí volver a utilizar Ruby cuando leí un artículo que trataba precisamente de la diferencia entre las macros de LISP y la sintáxis natural de Ruby. (en inglés, pero fácil de leer).

Espero que esta densa explicación sea de utilidad para ustedes. Que les vaya bien y hasta otra entrega.

Ya saben, el castellano no es mi idioma nativo, así es que si tienen dudas o preguntas sobre algún párrafo, ¡háganmelas saber!

Auf Wiederlesen!

Compartir

Nuestros programas ya deben hacer tareas básicas como sumar, restar, multiplicar, mostrar textos, todo de manera secuencial, un claro ejemplo de esto es el ya conocido ¡Hola Mundo!, que ya explicamos, por si olvidaron como se hacía, aquí está el código fuente:

program hola
print*,'¡Hola Mundo!'
end program hola

o también nos pueden saludar:

program saludo
character*10::nombre
print*,'Ingrese por teclado su nombre:'
read*,nombre
print*,'Hola ',nombre
end program

¿notaron que después del tipo de la variable nombre va un * seguido del número 10? eso es para denotar que las variables del tipo character declaradas en esta línea tienen un largo de 10 caracteres, si este indicador se omite se considera que la cadena de texto es de largo 1. Y así combinando las distintas sentencias y variables, podemos crear programas sencillos con distintas finalidades, ¿pero que pasa si queremos que el programa ejecute distintas opciones dependiendo de lo que pase con las variables?

Para eso existen las estructuras de control condicionales, el if y el case, muy distintas entre si. El nombre estructuras de control designa a distintos bucles en la programación que permiten modificar como se ejecuta el programa, dependiendo de las condiciones u orden de repetición que se le indique al programa.

Estas funcionan de la siguiente manera, se activan cuando la condición que se les impone resulta ser verdadera, en caso contrario, se ejecuta una alternativa o se sigue adelante con el resto del programa.

Empecemos por la principal y más simple, el if:

if significa “si es que”, por lo tanto es bien intuitivo su uso; analiza una expresión, si resulta ser verdadera, entonces ejecuta este curso de acciones, en caso contrario, este otro curso. La sintaxis más básica para esta estructura es la siguiente:

if (condición) then
lo que queremos que ocurra
end if

Donde dice condición, va una sentencia lógica, esta debe ir siempre entre paréntesis. La forma más simple de mostrar esto es con un ejemplo e ir explicándolo:

program ejemplo_if
integer::seleccion
character*10::nombre
print*,'¿es tu nombre Pablo?  [1=si, 2=no]'
read*,seleccion
if (seleccion==1) then
print*,'¡Hola Pablo!'
end if
if (seleccion==2) then
print*,'bah, ¿Cuál es tu nombre?'
read*,nombre
print*,'¡Hola ',nombre,'!'
end if
end program

Este simple programa nos pregunta si nuestro nombre es Pablo, si le respondemos que no, entonces nos pregunta cual es nuestro nombre y después nos saluda.El == es el operador logico de equivalencia, aquí quiere decir si seleccion es igual a 1 o a 2 se ejecuten las distintas secuencias. También existe una opción para los entornos if, el else, este ejecuta una serie de acciones que nosotros determinamos si es que la condición original es falsa. Este va así:

if (condición) then
lo que queremos que ocurra si la condición es verdadera
else
lo que queremos que ocurra en caso contrario
end if

usando el mismo ejemplo anterior:

program ejemplo_if
integer::seleccion
character*10::nombre
print*,'¿es tu nombre Pablo?  [1=si, cualquier otro valor entero=no]'
read*,seleccion
if (seleccion==1) then
print*,'¡Hola Pablo!'
else
print*,'bah, ¿Cuál es tu nombre?'
read*,nombre
print*,'¡Hola ',nombre,'!'
end if
end program

reduce mucho el código.

Si queremos realizar distintas acciones dependiendo de lo que se de en el programa, podemos anidar varios if’s dentro de otros, o también podemos usar la estructura case, la sintaxis de esta es un poco distinta pero igual es simple:

select case (variable a analizar)
case (valor1)
acciones a ejecutarse si la variable toma el valor1
case (valor2)
acciones a ejecutarse si la variable toma el valor2
... así cuantas acciones queramos
case default
acciones que se ejecutan en caso de que la variable no haya tomado ninguno de los valores antes especificados
end select

Tiene una trampa eso si, no se pueden usar variables del tipo real o complex para analizar con un case, deben ser o integer, o logical o character. Aquí tienen un ejemplo:

PRINT*,'¿Desea seguir analizando el polinomio dado? [1=Si, 2=No].'
READ*,n
SELECT CASE (n)
CASE (1)
PRINT*,'OK, sigo trabajando.'
flag3=.FALSE.
CASE (2)
PRINT*,'OK, nos vemos :D'
flag4=.FALSE.
flag3=.FALSE.
CASE default
PRINT*,'¡ERROR!, ha ingresado un valor no válido.'
flag3=.TRUE.
END SELECT

Aquí n es una variable entera. No les puedo dejar el programa completo ya que es muy extenso (créanme, muy extenso) y usa muchas cosas que todavía no les muestro.

Para la próxima vez veremos otras estructuras, las repetitivas.

Tweet

Compartir

Continuamos con Fortran. Vamos a introducirnos en los aspectos más básicos de la programación en este lenguaje.

Tipos de Variables:

Las variables son los ingredientes con los que trabajamos al programar, en Fortran existen 5 tipos de variables distintos:

1. integer: integer es “entero” en inglés, por lo tanto las variables declaradas de este tipo son considerados números enteros, como el -1,01,2,3… o sea, sin cifras decimales. Es importante recalcar que las operaciones que se hagan entre números enteros, incluida la división, darán números enteros, por ejemplo 3+5=8, pero 3/5=0, o sea, solo conserva la parte entera del número resultante.
2. real: Los números “reales”, no son precisamente Reales, ya que IR es continuo y algunos tienen infinitos decimales, etc, etc, por lo que son meras representaciones de estos, no fieles al extremo, sino lo suficientemente para trabajar con ellos. Existe también los reales de doble precisión
3. complex: números complejos, se tratan como pares ordenados del tipo (a,b)=a+ib donde i es solución del polinomio x²+1=0 (raíz cuadrada de -1).
4. logical: son variables binarias, o sea, solo toman dos valores posibles: verdadero (.true.) o falso (.false.)
5. character: son variables que contienen caracteres, o sea, letras, también conocidas como cadenas de texto.

Para usar una variable, no es necesario declararla al principio del programa, pero el compilador decide el tipo de variable basado en la letra inicial del nombre que se le de, para evitar esto, lo mejor es declarar al principio del programa el tipo de variable, esto se hace de la siguiente manera:

integer::k,i,j,entero,lola
real::empiezo,pi
pi=3.14159
k=8
empiezo=5.

como ven, la sintaxis para declarar variables es: tipo::variable1,variable2.... A los distintos tipos de variables es posible añadirles opciones, las iremos revisando en cuanto sea pertinente.

Los nombres de variable pueden tener una extensión máxima de 32 caracteres, pueden contener únicamente letras y números, empezando por una letra, no se distinguen entre mayúsculas y minúsculas.

Estructura de un programa en Fortran:

Dentro de la programación en Fortran lo más primero que debemos tener en cuenta es la estructura básica del programa en si, esta va de la siguiente manera:

program nombredelprograma
declaración de variables
sentencias, el programa en si
end program
subprogramas

Otra cosa que debemos considerar es que el computador es “tonto”, en el sentido que uno debe especificarle exactamente lo que se quiere hacer, este es un punto muy importante para tener en cuenta al empezar a programar. En Fortran, la programación es secuencial, con lo que quiero decir que el orden de los factores altera el producto, por ejemplo si escribimos:

k=2
k=k+1
print*,k

es muy distinto de poner:

k=k+1
print*,k
k=2

por lo tanto debemos organizar bien las acciones que queremos ejecutar.

Sentencias fundamentales

Básicamente tenemos que aprender a decirle al computador que es lo que queremos que haga, y la manera que queremos que lo haga, para esto son necesarias distintas ordenes intrínsecas al lenguaje, las palabras y caracteres reservados, osea, palabras que ejecutan una acción en especial.
Las más básicas son:

program: es la sentencia inicial; se usa para nombrar el programa, por ejemplo: program nombre_programa.

end program: se coloca al final, indica el fin del programa.

print: esta sentencia nos muestra lo que viene a continuación de la coma, por ejemplo: print*,k nos mostrará el valor de la variable k, o print*,'cadena de texto' nos mostrará en pantalla “cadena de texto”.

read: permite la entrada por teclado de una o múltiples variables, la sintaxis es: read*,variable1,variable2,...

implicit none: va al principio de la declaración de variables, obliga al compilador a errojar un mensaje de error y a abortar la compilación si detecta el uso de una variable que no ha sido declarada (muy útil, la uso siempre).

!: hace que el resto de la línea sea considerada comentario, así el compilador la omite.

;: el ; (punto coma) se usa para terminar la línea, por ejemplo: k=2 ; k=k+1 ! a la variable se le da el valor 2 y después se le suma 1.

+,-,*,/,**: suma, resta, multiplicación, división y exponenciación respectivamente.

=: declara una variable.

.true. , .false.: valores de verdadero o falso (sólo variables lógicas).

El resto de sentencias importantes las iré explicando en cuanto las usemos.

Les dejaré un pequeño programa para que vallan viendo cómo va la cosa:

Este pequeño programa nos da el perímetro y el área que cubre una circunferencia pidiéndonos el radio.

Si prefieren aquí también les dejo el clásico “Hola Mundo!”:

program holamundo
print*,'¡Hola Mundo!'
end program

lo únco que deben hacer para ver su ¡hola mundo! es guardarlo en un archivo con extensión .f95 y compilarlo… OH WAIT!, todavía no les digo cómo compilar xD

Compilando un Programa

Como supongo que ya instalaron el compilador de Fortran de GNU (gfortran), voy a dar las instrucciones para compilar su código, desde ahora nos meteremos en una terminal y lo primero será navegar hasta la localización del archivo fuente;

La manera más natural de compilar es usando únicamente el comando gfortran seguido del nombre del archivo, así: $ gfortran nombrearchivo.f95 esto nos produce un ejecutable de nombre a.out, pero… ¿y si queremos que salga con otro nombre?, bueno simplemente con la opción -o se logra esto, entonces la sintaxis sería: $ gfortran nombrearchivo.f95 -o nombreejecutable. Y por último si solamente queremos verificar que no existan errores de sintaxis podemos usar la opción -fsyntax-only, en el  teminal escribimos: $ gfortran -fsyntax-only archivofuente.f95.

Eso es todo por esta semana, ¿bien extenso el post ah?.

Compartir