Aunque os la contamos en detalle en el anterior enlace, la resumimos brevemente:

• Damos acceso a los 2 primeros módulos del curso. Solo hay que darse de alta en nuestra plataforma online (si no tenéis ya usuario) y auto-matricularse en el curso de “Diseño 3D con Blender (Módulos 1 y 2)” en la sección “Acceso Libre“.
• Si se realizan las 2 actividades propuestas en esos módulos antes del 31 de Marzo entráis en un sorteo de una matrícula gratuita para el curso completo, compuesto por 7 módulos.
• En cualquier caso, por haber realizado los 2 ejercicios, tenéis derecho a un descuento especial para el curso completo.

El autor y tutor del curso es Joaquín Herrera, Formador Oficial de la Fundación Blender, toda una garantía para que contar con la mejor ayuda y divertirse mientras aprendéis las nociones fundamentales del diseño 3D utilizando Blender.

Como veis, hemos tratado de hacerlo fácil, sin que suponga ningún compromiso y sobre todo, para sacarle partido desde el inicio. Podréis acceder a todos los contenidos en formato web y pdf descargable, ficheros .blend o videotutoriales de esos 2 primeros módulos, que ya de por sí, sirven como guía de iniciación a este software.

Esperamos que os guste la idea y os animéis a aprender Blender con nosotros.

Happy blending!

 credits: imagen © Can Stock Photo Inc. / iqoncept

Algunos recordaráis que ya hicimos una edición similar a final del año pasado, con una acogida extraordinaria (tuvimos que limitar los participantes a los 100 primeros inscritos). En esta ocasión, hemos decidido con Joaquín Herrera (Joaclint), el autor y tutor del curso, que la edición esté siempre abierta, por lo que la inscripción podrá realizarse en cualquier momento.
Creemos que es una fórmula mejor para los alumnos, ya que pueden elegir la fecha para iniciar esta formación y se podrán escalonar las inscripciones dando cabida a todos los interesados.

Con esta introducción guiada, pensamos en dos objetivos principales:

• Contribuir a la difusión de Blender y ampliar la comunidad de personas que conocen y utilizan esta extraordinaria aplicación. En estos dos módulos, dispondréis de contenidos teóricos en formato web y pdf descargable, videotutoriales, actividades propuestas, ficheros .blend y ejercicios. En los foros, podréis intercambiar experiencias y ayuda con otros participantes. Además, Joaclint revisará los ejericicios que se le envíen a través de la plataforma  y hará un seguimiento a los foros, interviniendo siempre que le sea posible.
• Facilitar a los alumnos la evaluación, sin compromiso, de esta formación. Si les gusta, esperamos que deseen seguir aprendiendo con nosotros matriculándose en la edición completa de 7 módulos del curso Diseño 3D con Blender.

Si te interesa darte de alta en estos 2 primeros módulos libres, consulta esta página con las indicaciones de cómo hacerlo.

Nota (^): Blender es un software de código abierto con (open source) con licencia GPL:  puedes utilizarlo, copiar, editar o distribuir de forma gratuita

Joaclint nos propuso compartir esta buena noticia con los alumnos y seguidores de una manera que nos entusiasmó enseguida: ofrecer una formación gratuita de introducción a Blender a partir de su guía de iniciación a este software.
Decidió por tanto reelaborarla y convertirla en 2 módulos que incluiríamos en el curso de Diseño 3D con Blender, dando acceso a esta parte sin coste para el alumno.

Os contamos, para los que conozcan la guía, en que han consistido esos cambios:

• La ha revisado completamente, reescribiendo y adaptando a las nueva serie de versiones 2.6x de Blender.
• Ha ampliado bastantes apartados y añadido algunos nuevos.
• Ha transformando su presentación, tanto en organización de recursos como visualmente
• …y lo más importante: ha incorporado actividades prácticas, esenciales para el aprendizaje del alumno.

El resultado como hemos dicho, es la creación de dos módulos, que el alumno puede seguir online en formato web en nuestra plataforma Moodle  (los contenidos teóricos también pueden descargarse en pdf) e incluyen:

• Tres prácticas guiadas de diseño 3D  explicadas paso a paso con texto e ilustraciones y los ficheros .blend para que pueda revisarlos el alumno
• También ha grabado tres vídeos (screencasts) donde explica directamente estos pasos mientras muestra como se realiza en la pantalla del ordenador
• Propuesta de actividades
• Un foro donde los alumnos pueden intercambiar comentarios y colaborar entre ellos
• Un ejercicio evaluable en cada módulo, que pueden enviar a través de la plataforma para que Joaclint les realice una valoración del trabajo.

Creemos que es una fórmula atractiva para los que desean conocer Blender e iniciarse en el diseño 3D.  Pueden evaluar esta herramienta profesional como alternativa abierta y gratuita al software privativo o si tienen poca experiencia en diseño, comprobar que pueden asimilar sin dificultad estos nuevos conceptos.

Esperamos que os guste este formato de aprendizaje y los contenidos y ejercicios que os ofrecemos. Y por supuesto, si Blender y el diseño 3D os engancha, que os animéis a continuar con el curso completo!

Se han reorganizando los temas, mejorando algunos aspectos de presentación y contenido, con inclusión de más ejemplos y la realización de un Proyecto final, y sobre todo, hemos añadido un tema completo dedicado a la libreria jQuery, un auténtico entorno de trabajo (framework) basado en Javascript que ha revolucionado la manera de programar en este lenguaje,

jQuery, es software libre de código abierto, y líder indiscutible en utlización dentro de todas las librerias que han surgido en los últimos años, como Dojo, MooTools o ExtJS, por citar algunas.

Este tipo de librerias,nos ofrecen dos ventajas muy importantes:

• nos permite despreocuparnos de incompatibilidades entre navegadores y sus distimta versiones. jQuery se encarga por nosotros de que el código se ejecute sin problemas independientemente del navegador que visualice nuestra página.
• nos permite desarrollar funcionalidades avanzadas y efectos espectaculares con mucha menos dificultad y esfuerzo. El lema de jQuery “haz más con menos” es una auténtica realidad para el programador, que puede desarrollar aplicaciones web con interfaces y una experiencia para el usuario similares a las  tradicionales aplicaciones de escritorio.

Por supuesto, creemos  que para sacar el máximo partido del potencial que ofrece jQuery (o cualquiera de estas librerías) es imprescindible una adecuada base de conocimientos y experiencia en la programación con Javascript. El alumno, al completar este curso, va a adquirir sin duda esos fundamentos para poder seguir  formándose y afrontar proyectos y desarrollos de mayor complejidad.

Para ello, con el proyecto abierto, nos situamos en la clase wombat en el diagrama de la derecha. Hacemos que aparezca el menú contextual (botón derecho del ratón) y elegimos ‘Abrir el editor‘. Lo que vemos es el código escrito en lenguaje Java que define esta clase.

Si tienes muy poca experiencia en programación quizás te resulte casi incomprensible, pero analizando por partes verás que no es tan difícil de entender.

En una primera revisión, como podemos ver en la imagen de abajo, se distinguen varias secciones enmarcadas con recuadros de distintos colores que explicaremos a continuación:

* Importación de clases: es la sección inicial, en fondo blanco. Mediante la cláusula ‘import‘, podemos incluir las clases que necesitemos en nuestro programa  para que todo funcione correctamente. Las clases suelen encontrarse agrupadas de forma lógica en librerías o packages(paquetes). Un paquete es por tanto un conjunto de clases ya construidas que podemos utilizar en nuestra aplicación, lo que nos ahorra programar todas las funcionalidades desde cero:

import greenfoot.*;  // (World, Actor, GreenfootImage, and Greenfoot)
import java.util.List;
import java.util.ArrayList;

En el apartado ‘la API de Java’, en este mismo artículo, te explicamos más en detalle estos conceptos.

* Declaración de la clase: es el bloque donde definimos la clase Wombat en sí y que está delimitada visualmente por un cuadro verde. Comienza con unos comentarios (qué hace la clase, su autor, versión…), cuyo inicio y final se marcan con los caracteres ‘/* ‘ y ‘*/’ (es muy recomendable incluir comentarios a lo largo del programa para hacer más entendible nuestro código) y continúa con:

public class Wombat extends Actor
{ ...............
...............

la expresión public class Wombat extends Actor’ la podríamos traducir literalmente por ‘la clase Wombat extiende la clase Actor , y encierra uno de los elementos fundamentales de la POO, la herencia. Explicaremos más detenidamente el concepto de herencia en un siguiente apartado en este artículo, pero básicamente estamos diciendo que creamos la clase Wombat (más específica) a partir de la clase Actor (más genérica) ‘heredando’ o teniendo disponibles sus atributos y métodos.

El término  public es un modificador de acceso y define a esta clase como pública, siendo accesible por tanto por cualquier otra clase. Por defecto, si no incluímos ningún modificador (default), solo sería accesible por clases que están incluídas en su paquete.
Hay otros dos modificadores de acceso, que al igual que los anteriores, también son aplicables a los métodos y a los atributos: protected (similar a default aunque permite heredar a una subclase que no está en el paquete ) y private (si queremos que los  métodos o atributos sean solo accesibles dentro de la clase). Si quieres saber más, puedes consultar este artículo sobre modificadores Java.

El código que define la clase se encierra entre llaves  ‘{‘ y ‘}’ ‘. Vemos que a su vez tiene bloques diferenciados, Vamos a analizarlos:

* Declaración de atributos: es el recuadro inicial en fondo blanco:

private static final int EAST = 0;
private static final int WEST = 1;
private static final int NORTH = 2;
private static final int SOUTH = 3;

private int direction;
private int leavesEaten;

El grupo de los cuatro primeros: EAST, WEST, NORTH y SOUTH, son las direcciones a las que puede orientarse el Wombat. Son de tipo entero (int) y se han definido de forma que actúan como constantes para cualquier objeto Wombat al tener los modificadores final y static. El primero no permite que se modifiquen sus valores (0,1,2 y 3),y el segundo las define como variables de clase, es decir, no es necesario crear un objeto para utilizarlas. Recordemos en el anterior post el efecto que producía pasar uno de estos números como parámetro al método setDirection(int direction). ¡Hacían que el Wombat se girará a derecha, izquierda, arriba o abajo !. El otro modificador (private) indica que solo son accesibles dentro de la clase.

El grupo de los dos siguientes atributos, direction y leavesEaten, son variables de instancia y almacenarán la información en formato entero (int) de la dirección y las hojas que han comido cada uno de los objetos Wombat que creemos (instanciemos) a partir de esta clase. Se les denomina también campos y toman valores particulares a nivel de objetos.

* Constructor: es el proceso que crea un objeto a partir de una clase y que se ejecuta automáticamente cada vez que instanciamos un objeto (al seleccionar new WombatWordl, new Wombat() ó new Leaf()).
Su código aparece en el recuadro amarillo justo debajo de la definición de atributos:

<strong>public Wombat()</strong>
{
setDirection(EAST);
leavesEaten = 0;
}

Tiene la misma estructura que un método aunque con algunas particularidades: debe tener siempre el mismo nombre que la clase y no tener ningún return type.

No es necesario declarar siempre un constructor, ya que toda clase tiene uno que inicializa los campos del objeto con valores por defecto. Si queremos personalizar ese proceso de creación, entonces podemos escribir uno o varios constructores, a los que a su vez podemos pasar o no parámetros. Por ejemplo, en este caso, el constructor inicializa los campos direction con el valor ‘EAST’ y leavesEaten con el valor ‘0’.

* Métodos: todo el código restante de esta clase, son las definiciones de sus métodos. Cada uno aparece en un recuadro amarillo, con una estructura muy parecida:

• Comentario indicando que realiza ese método
• Declaración del método: ‘public void act()‘, ‘public boolean foundLeaf()‘, ‘public void eatLeaf()‘,…
• encerrados entre llaves {}, las instrucciones que han de ejecutarse

Aunque no podemos entrar en detalle de todo el código, vamos a revisar por ejemplo el primer método que aparece: act()

<strong>public void act()</strong>
{
if(foundLeaf()) {
eatLeaf();
}
else if(canMove()) {
move();
}
else {
turnLeft();
}
}

Sabemos por un post anterior, que la palabra reservada void nos indica que el método no devolverá ningún valor. Interpretando o traducciendo del inglés el código encerrado entre las llaves, vemos que hay una estructura condicional:

if(condición 1) {
instruccion 1…..
}
else if (condición 2) {
instrucción 2
}
else {
instrucción 3
}

If, es el ‘si’ condicional en inglés y el ‘else’ nos permite evaluar una alternativa.  Podríamos leer todo este código literalmente como:
“si se cumple la condición 1, ejecuta  la instrucción 1, si en cambio se cumple la condición 2, ejecuta la instrucción 2 y en cualquier otro caso (no se cumple ninguna de las dos anteriores), ejecuta la instrucción 3″

¿Qué condiciones e instrucciones hay? Pues vemos que son precisamente llamadas a otros métodos de este mismo objeto. Si seguimos traduciendo literalmente sería algo así como:

“si se cumple la condición ‘he encontrado una hoja’, ejecuta ‘comer hoja’, si en cambio se cumple la condición ‘puedo moverme’, ejecuta la instrucción ‘mover’ y en cualquier otro caso, ejecuta la instrucción ‘gira a la izquierda’ ”

Si queremos cambiar el comportamiento de los Wombat que creemos, solo tenemos que modificar los métodos adecuados. Lo iremos viendo en próximos posts, pero puedes practicar un poco con cambios sencillos. Por ejemplo, si modificas este método act() en su primer condicional de forma que añadas llamadas a los otros dos métodos de la forma:

if(foundLeaf()) {
eatLeaf();
turnLeft;
move(3);
}

¿qué ocurrirá cuando el Wombat encuentre una hoja? Es fácil de adivinar ¿verdad?. Prueba las variantes que quieras y no olvides compilar siempre después de realizar los cambios. Puede ser buena idea que al hacer el primer cambio guardes el proyecto con otro nombre (save as…) y continuar ya con éste, de forma que mantegas el proyecto y código original de referencia.

En primer lugar vemos que al abrir un escenario, por ejemplo el ‘Wombat’, y tras dar al botón de compilar en la parte inferior derecha no aparecen la siguiente pantalla, que será nuestra interfaz visual donde editaremos y ejecutaremos nuestros programas:

Se divide en tres partes principales:

• El Mundo, que es el cuadrado con retícula de color arena que nos aparece en la izquierda. Es donde pondremos los objetos y donde se desarrollará el juego o simulación que programemos. Variará su apariencia en función del escenario que carguemos, ya que cada uno tiene un Mundo por defecto (en este caso es ‘WombatWorld“) y éste a su vez tiene una imagen de fondo que podemos cambiar fácilmente como veremos más adelante.
• El Diagrama de Clases, en la parte derecha. Ahí nos aparecen tanto las clases de Mundo que tenemos disponibles y las clases de Actores (‘Wombat‘ y ‘Leaf’) a partir de las cuales crearemos los objetos que incluiremos en el mundo elegido.
• Los botones que aparecen en la parte inferior y que nos permiten ejecutar una serie de acciones que veremos a continuación.

Si posicionamos el puntero del ratón en la clase Wombat y pulsamos el botón derecho para que apareca el menú contextual, obtendremos lo que aparece en la imagen de la derecha.

Si elegimos la opición ‘new Wombat()‘ estaremos creando un objeto a partir de esa clase, apareciéndonos una imagen de este animal que podremos arrastrar y posicionar en el mundo que tenemos a la izquierda (imagen de abajo).

Podemos crear tantos objetos como queramos a partir de la clase Wombat, y podemos hacer lo mismo con la clase Leaf (hoja), posicionando todos esos objetos en el cuadrado de la izquierda.

A la acción de crear objetos se le denomina instanciar (un objeto es una instancia de una clase). A partir de ahí, ya podemos interactuar con ellos.

Pasamos a la acción

Si pulsamos el botón accionar, veremos que el (o los) wombat que hayamos creado se moverán una celda hacia la derecha mientras que las hojas permanecen quietas. Si pulsamos el botón ejecutar (run si lo tienes en versión inglesa), los wombats seguirán moviéndose celda a celda hacia la derecha con dos particularidades: si encuentran una hoja, ésta desaparece (se la come!) y si llegan a los límites del mundo (los lados del cuadrado), girán 90 grados y continuan en esa nueva dirección.

¿Por qué hacen cosas los wombats y no las hojas (leaf)? Lógicamente porque está así programado. Si nos posicionamos en un wombat situado en la cuadrícula  y accedemos al menú contextual (botón derecho ratón) nos aparecerá una lista de métodos, tal como vemos en la imagen de la derecha. Descubriremos más adelante, cuando inspeccionemos el código Java, que los métodos son un conjunto de instrucciones que hacen una determinada tarea, al estilo de las funciones que utilizamos en la programación estructurada.
Podemos adivinar más o menos de que se trata por sus nombres en ingles: act (actuar), eatLeaf (comer hoja), … Si pulsamos en cualquiera de ellos, ese objeto wombat  ejecutará la operación correspondiente. Por ejemplo, con move(), se moverá un cuadro a la derecha, con turnLeft(), se girará a la izquierda.

La palabra que aparece delante del nombre de los métodos (void, boolean, int) indica el tipo que tienen los valores que retornan al ejecutarlos (return type). Prueba a pulsar todos los métodos de la lista. ¿Qué observas?  Verás que hay dos tipos de métodos:

• los que tienen un return type ‘void’ (‘vacio’ en inglés) ejecutan una acción y no devuelven ningún resultado
• los que contestan con algún tipo de información. Con estos, estamos haciendo una pregunta al objeto:
  • canMove(): ¿puedes moverte?
  • foundLeave(): ¿has encontrado una hoja?
  • getLeavesEaten(): ¿cuántas hojas has comido?

  y devuelven distintos tipos de respuesta en un cuadro de diálogo:

  • boolean: valor ‘true/false‘ (es decir, ‘verdadero/falso’)
  • int: (número entero)

En la imagen de abajo vemos el ejemplo del resultado del método canMove(). Nos contesta ‘true‘, es decir, es verdad que el wombat puede seguir moviéndose porque no ha llegado a uno de los lados del cuadrado. Si movemos el objeto hasta el final e invocamos otra vez el método, veremos que nos contestará con un ‘false‘. Ese resultado lo puede utilizar el programa para decidir que el objeto gire y cambie de dirección su trayectoria. Lo veremos cuando analicemos el código Java.

También habrás observado que uno de los métodos, setDirection (que podemos traducir por ‘establecer dirección’), contiene una expresión entre los paréntesis. Nos indica que para ejecutarlo el método está esperando que le pasemos un parámetro, en este caso ‘direction‘ que debe ser de tipo ‘int’. Prueba con los valores 0,1,2 y 3 y verás como el wombat cambia su orientación. Estamos modificando el valor de un atributo o propiedad de este objeto (lo explicamos en el cuadro de abajo). Si introduces otro tipo de valor que no sea un nº entero (por ejemplo un nº decimal como 2,3 o una letra) te devolverá un mensaje de error.

Otra detalle que habrás visto en la lista de métodos, es la primera entrada  ‘heredado de Actor‘. Si pulsas ahí, verás una lista adicional de métodos que están definidos en la clase Actor y que automáticamente también tiene la clase Wombat como puedes comprobar  ejecutándolos. Tiene que ver con el mecanismo de la herencia (una clase más genérica es `padre’ de una más específica, la ‘hija’ y ésta recibe sus características), fundamental en la POO y que explicaremos más adelante.

En próximos posts, accederemos al código Java de este programa para comprender  mejor como se implementan los conceptos que estamos presentando y generaremos un juego con objetos y reglas nuevas a partir de uno ya desarrollado. Mientras, si tienes curiosidad, abre el menú contextual de la clase Wombat y elige la opción ‘Abrir el editor‘. ¿Puedes entender cómo está construida y localizar los métodos de los que hemos hablado? Inténtalo, es un buen ejercicio…

A la vez que mostramos este entorno, iremos ampliando información sobre algunos aspectos de  Java y la POO. Podemos manejar esta herramienta sin necesidad de leer esta información, pero será útil para los que quieran aprender más sobre programación. Esta información adicional la incluiremos en recuadros, diferenciándolos de la documentación básica.

Greenfoot es un proyecto de software libre y gratuito,  desarrollado en la Universidad de Kent (UK),  enfocado en principio a jóvenes estudiantes que quieren inicarse en el mundo de la programación. Existen otras herramientas con objetivos similares, como Scratch o Alice, pero Greenfoot tiene características más avanzadas, como la edición de código fuente en Java, lo que lo hace más potente e incluso interesante para personas que tienen ya conocimientos en programación. Greenfoot se distribuye gratuitamente con licencia GNU GPL y está disponible para Windows, Mac OS X y Linux.

Instalación del programa Greenfoot

Descarga e instalación del JDK

Para ejecutar Greenfoot es necesario tener instalado previamente el entorno de desarrollo Java (JDK),  que provee las herramientas para programar y ejecutar aplicaciones en este lenguaje. Podemos descargarlo de forma gratuita desde esta página:

http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u3-download-1501626.html

eligiendo la versión acorde a nuestro sistema operativo e instalándola según el proceso habitual de nuestro sistema.

Nosotros vamos a descargar el JDK (Java Development Kit ) denominado SE (Stándar Edition) versión 7 (es la última, aunque también valdría la versión 6) que incluye a su vez el JRE (Java Runtime Enviroment – Entorno de Ejecución de Java). El JRE puede descargarse e instalarse de forma autónoma, lo que nos permitiría ejecutar aplicaciones Java en nuestro equipo, pero no crear y compilar programas en este lenguaje. Además de la SE, utilizada usualmente para aplicaciones en entornos desktop-PC, hay otros kit de desarrollo: como ME, EE, FX,… que están orientados a otros tipo de entornos (móviles, aplicaciones corporativas, interfaz webs…)

Descarga e instalación de Greenfoot

Una vez instalado JDK, pasamos a la instalación del programa. Para ello nos dirigimos a la página http://www.greenfoot.org/download

Una vez alli, se nos presentan distintas versiones dependiendo del sistema operativo que usemos, e incluso podemos descargar una versión Java para cualquier SO o una que corra desde una memoria USB.

¡Ojo!, en el caso de que nos hubiésemos saltado el anterior paso, se hubiera instalado incorrectamente el JDK o en un directorio que el instalador de Greenfoot no encuentra nos  aparecería un mensaje de error: “No (suitable) Java SDK s were found…“. Debemos comprobarlo o proporcionarle el directorio donde lo tenemos ubicado en nuestro equipo.

Durante la instalación se eligirán diversas opciones respecto al programa, tales como su ubicación y si se desea crear accesos directos al escritorio.

Si queremos cambiar la interfaz del programa a español, deberemos modificar el fichero “greenfoot.defs” que se encuentra en la carpeta “lib” ubicada en el directorio donde hallamos instalado el programa (p.ej., por defecto en Windows:  “archivo de programas/greenfoot/lib/greenfoot.defs“).

Para ello lo editamos con un editor de texto como el Bloc de Notas ó Notepad++ y quitaremos el carácter comentario “#” del idioma español y se lo pondremos delante del idioma inglés (ver imagen a la izquierda). Si tienes dudas, consulta la página de traducciones en su sitio web.

Inicio de Greenfoot

Una vez instalado, iniciamos Greenfoot. Sus aplicaciones se basan en Escenarios, que contienen todos los elementos necesarios para que dichos programas se visualicen y funcionen. Los escenarios incluyen un fondo gráfico, denominados Mundos (Worlds), y Actores (Actors ) que colocaremos en dichos mundos y que realizan acciones (ya lo veremos más adelante).
Hay muchos escenarios disponibles. El programa viene con algunos instalados pero también podemos acceder a escenarios creados por otros usuarios que los comparten libremente en la web de Greenfoot.

La primera vez que accedemos al programa nos saldrá un cuadro con opciones para empezar con un escenario ejemplo, elegir algún otro, crear uno nuevo o continuar sin cargar nada. Si elegimos un escenario, nos aparecerá otro mensaje indicándonos que debemos guardarlo en otra carpeta si queremos modificarlo:

Si escogemos el escenario ‘Wombat’ y lo guardamos en una carpeta (p.ej: ‘proyectos_greenfoot‘ en un directorio personal), nos lo abrirá pero sin ningún fondo gráfico. Si pulsamos el botón ‘Compilar todo’ en la parte inferior derecha, nos debe aparecer ya el mundo cargado. Nosotros vamos a crear un Wombat (un marsupial de Australia) y tres hojas:

¿Te animas a jugar ya con este escenario?. Una pista: selecciona la casilla Wombat con el ratón y pincha el botón derecho para que te aparezca el menú contextual. Si no sabes como seguir, en los siguientes posts te iremos contando como hemos creado los ‘actores’, cómo se juega y cómo podemos ir adaptado éste o cualquier otro escenario mediante programación Java de forma muy sencilla.

En nuestro recién lanzado Curso de Desarrollo de Aplicaciones para Android explicamos estos primeros pasos de forma sencilla, de manera que nuestros alumnos pueden instalarse sin problemas y en pocos minutos el entorno de desarrollo y el SDK de Android, elementos imprescindibles para comenzar su trabajo. En este post vamos a explicar cómo realizar esta instalación fácilmente. Si tenéis algún problema, por favor usad los comentarios y os echaremos una mano. Igualmente, si algo falla, por favor comunicádnoslo:

Descarga e instalación de Eclipse

Para empezar a desarrollar con el SDK de Android, es necesario descargar un entorno de desarrollo. Se pueden usar varios, como puede ser Netbeans, Java-Eclipse SDK (en adelante Eclipse ), IntelliJ IDEA, etc… En este curso aprenderemos a configurar Eclipse, ya que es el más utilizado para desarrollar en Android.

Deberemos dirigirnos a http://www.eclipse.org/downloads/ y descargar una versión de Eclipse. Aconsejamos la versión Eclipse Classic, aunque la RCP o la Java también pueden servir.

Página principal de descargas de Eclipse, desde aquí podemos descargar Eclipse Classic en su versión 3.7.1 o posterior para Windows, Mac o Linux.

Será necesario descargarnos previamente el JDK (http://java.sun.com/javase/downloads/index.jsp) si no lo tuviéramos ya instalado.

Una vez descargado e instalado el Eclipse, lo ejecutamos y mostrará una ventana parecida a la siguiente:

Ventana principal de Eclipse

Instalación de las ADT y del SDK

En versiones anteriores, era necesario descargarnos antes el SDK e instalarlo por nuestra cuenta y luego configurar el ADT para que apunte al lugar donde lo habíamos instalado. Ahora este proceso es mucho más sencillo con las últimas actualizaciones de las ADT. Veamos cómo se hace ahora:

• Con el Eclipse abierto, nos vamos al menú Help → Install New Software…

Instalación de ADT (I)

• Pulsamos Add… y agregamos las fuentes de Android: en Name lo que queramos (Android, por ejemplo) y en Location ponemos https://dl-ssl.google.com/android/eclipse/ y pulsamos OK.

Instalación ADT (II)

Si tienes problemas para obtener el plugin, prueba usando http en lugar de https.

• En el diálogo de Available Software, marcamos la casilla al lado de Developer Tools y pulsamos Next.

Instalación ADT (III)

• Pulsamos de nuevo Next para aceptar las herramientas que se van a instalar y por último Finish para aceptar los acuerdos de licencia.
• Una vez instalado todo, reiniciaremos Eclipse.

Al abrir Eclipse de nuevo después de haber instalado las herramientas de desarrollo, nos aparecerá una ventana como la siguiente:
lustración 6: “]

Instalación SDK (I)

En ella podemos marcar dos opciones,

1. Instalar la última versión del SDK de Android,
2. Instalar la versión 2.1, la cual es soportada por el 97% de los terminales Android a fecha de noviembre de 2011.

Instalación SDK (II)

1. Es indiferente la opción que marquemos ya que luego podremos instalar más versiones. En este caso se ha optado por marcar la opción de instalar la última versión del SDK. En este momento se empezará a descargar e instalar el último SDK de Android. Una vez haya terminado el proceso, pasamos a configurarlo.

Configuración del SDK

Una vez realizado el proceso descrito en el apartado anterior, Eclipse permite acceder a Android SDK Manager ( entorno de instalación y descarga de paquetes (Packages) de herramientas, APIs, fuentes, ejemplos, etc.. ) mediante este entorno podremos configurar el SDK. El acceso a este interface se realiza pulsando en el siguiente icono de la siguiente Ilustración situado en la barra superior de herramientas de Eclipse:

Botón de configuración del SDK

Configuración del SDK

En esta ventana seleccionamos aquellos componentes que queramos instalar. Recomendamos instalar al menos las APIs 8 y 10, ya que son las que mayor número de usuarios poseen, tal y como vimos en el gráfico de la primera unidad.

La API 8 será la que utilizaremos a lo largo de este curso, por lo que como mínimo habrá que instalar ésta.

Actualización del SDK y las Android Development Tools (ADT)

Para actualizar el SDK lo haremos desde la misma ventana que la captura del apartado anterior. En ella aparecerán si tenemos componentes para actualizar o no.

Para actualizar las ADT:

1. Nos dirigiremos a Help → Check for Updates. Si no hay actualizaciones, mostrará un mensaje diciéndolo y entonces habremos acabado.
2. Si hay, se mostrará una ventana en la que deberemos marcar las casillas que aparecen y pulsar Next.
3. En los detalles de la actualización pulsamos Next.
4. A continuación deberemos aceptar los acuerdos de licencia y pulsar Finish.
5. Finalmente reiniciaremos Eclipse.

Acerca de la autora: Bloguera con experiencia y experta en temas de comunicación, programación y tecnología móvil, A.Lara trabaja para twago, la plataforma líder en el mercado alemán entre profesionales freelance y empresas que requieren servicios TIC (programación, diseño web, traducción, redacción y otros servicios empresariales).

La situación del software libre

Todos aquellos metidos en el sector, estamos viendo como el software libre se va incorporando a la realidad de las empresas a un ritmo cada vez más rápido. No es de extrañar si tenemos en cuenta sus innumerables ventajas, pues su uso ofrece libertad, flexibilidad, adaptabilidad a nuestras necesidades, seguridad, privacidad y un precio ajustado a su valor. Sin duda un “bueno bonito y barato” en toda regla.

Ante todas estas ventajas, no es de extrañar entonces que el crecimiento de este tipo de tecnología sea tan grande. Según los datos publicados por el INE el 75% de las Pymes o grandes empresas y el 51% de las microempresas de nuestro país ya están utilizando algún tipo software libre. En un reciente estudio de CENATIC ya sólo en el sector IT un 39% de las empresas no sólo conocen las soluciones libres, sino que las han incorporado como parte fundamental de su oferta comercial.

Claramente el software libre ya no es sólo cosa de “raritos” o “frikis”. Muchas aplicaciones basadas en este entorno están ganando popularidad. Software libre ya no es sólo sinónimo de Linux sino que ha madurado a otro nivel y se ha traspasado a muchas otras aplicaciones. A los desarrolladores que contribuyen con este tipo de software, ahora también hay que sumarle la participación de grandes empresas, incubadoras de proyectos o fundaciones como Google, SourceForge, Apache o Mozilla  que disponen de proyectos Open Source que ellos mismos patrocinan o dan soporte.

¿Existen posibilidades laborales?

Hablar de las posibilidades laborales con esta tecnología ha dejado de ser algo utópico. Con la actual coyuntura económica, las empresas se han visto obligadas a optimizar sus presupuestos para cada departamento y el de TI no iba a ser menos. Aquí es donde entran en juego las soluciones Open Source ya que permiten un ahorro de costes considerables en conceptos como el pago de licencias.

Ante esta creciente popularidad, es perfectamente normal que la gente empiece a preguntarse cómo hacer carrera en este terreno. Son muchos los programadores que sienten verdadera pasión por el software libre y el código abierto y como es natural buscan ir por esa vía, pues ¿qué mejor que convertir tu hobby en tu carrera profesional?. No obstante, ¿existe la posibilidad de que nos paguen por hacer aquello que de verdad nos gusta?

Es de lógica, si las empresas siguen adoptando soluciones Open Source, van a buscar empleados que estén familiarizados con este tipo de tecnología y esto significa un incremento considerable en las oportunidades laborales basadas en estos sistemas.

¿Qué pasos seguir para labrarse una profesión con Software libre?

Llegar a dominar este tipo de tecnología y por tanto poder optar a oportunidades laborales puede conseguirse, igual que en el resto de profesiones, combinando estudios o conocimientos teóricos con práctica. A nivel estudios es sencillo, tan sólo tenemos que escoger bien el curso (on-line, presencial, en la universidad, en una escuela privada,…) y la tecnología en la que queramos especializarnos.

A nivel experiencia la cosa se complica. Seguro que todos nos hemos preguntado en algún momento de nuestra carrera como conseguir experiencia laboral si no nos contratan en ningún sitio por falta de experiencia (y más en una materia tan práctica como la informática). Por fortuna, este problema desaparece con el software libre, pues el sistema se basa en la colaboración pública con la comunidad y todo el mundo es libre de participar.

Como desarrollador puedes aprender rápidamente diferentes metodologías de código, que de otra manera hubieras aprendido en estadios más avanzados de tu carrera en una empresa. Existe también la opción de ser un colaborador. Puedes apuntarte a proyectos en múltiples forjas (plataformas de desarrollo colaborativo) como SourceForge, IrisLibre, GitHub, LaunchPad o Google Code o incluso empezar tu propio proyecto. Una vez te unas a alguno de los proyectos ya puedes empezar a ponerlos a prueba e ir ganando más conocimiento sobre la tecnología que hay detrás. Esto te permitirá empezar a rellenar informes de reportes de fallos (bugs-reports) y a aportar soluciones. También puedes contribuir en los proyectos elaborando su documentación. Además si eres novato, siempre va a haber alguien dispuesto a ayudarte y darte consejos y ¿qué mejor manera de ganar experiencia que esta?

Y no sólo experiencia, es también reconocimiento. ¿Cómo? Sencillamente colaborando en los miles de proyectos que necesitan tu ayuda. Involúcrate en la comunidad, ayuda y conforme ganes experiencia desarrolla nuevas características y no dudes en comentarlo luego en tu CV. Incluso puedes obtener una compensación económica por donaciones de usuarios (y a veces venta) de extensiones que amplíen las funcionalidades de soluciones abiertas muy populares como Firefox, WordPress, Joomla, Moodle o Prestashop, por poner unos ejemplos. Estas contribuciones van a ser tu portfolio a la hora de buscar trabajo, y recuerda que son proyectos públicos y tienen mucha visibilidad, por tanto aumenta las posibilidades de que una empresa vea tu trabajo y te ofrezca una posición, al fin y al cabo tienen una prueba irrefutable de tus cualidades como programador.

Desarrollo laboral y perspectivas de futuro

El camino laboral en este sector empezará normalmente por programar o desarrollar. A partir de aquí y con la experiencia, el nivel subirá a la distribución, implementación y puesta en marcha de sistemas completos en empresas. Con experiencia adquirida, el profesional puede aventurarse en el mundo de la consultoría y la estrategia evaluando por ejemplo los productos que mejor se adaptan a las necesidades de la empresa.

De todas maneras, sea cual sea la progresión individual de cada uno lo que sí que está claro es que el software libre continuará creciendo en nuestro país. Según el estudio realizado por CENATIC una de cada cinco empresas que actualmente no trabajan con programas de código abierto lo hará antes de cinco años. ¿Podéis empezar a imaginar la envergadura del mercado y las oportunidades laborales que esto representa?

(Fuente datos: www.cenatic.es y www.ine.es)

Credits: foto programador (www.flickr.com/photos/ebarrera/)

Ahora bien,se puede estar preguntando alguien, ¿qué es un Servidor Web y qué hace exactamente?

Bueno, lo primero que debemos aclarar es que estamos hablando de software, aunque el equipo donde se ejecuta recibe la misma denominación. Su misión es crítica, ya que es el encargado de aceptar las peticiones de páginas (o recursos en general) que provienen de los visitantes que acceden a nuestro sitio web y gestionar su entrega o denegación, de acuerdo a las políticas de seguridad establecidas. Esto, que puede parecer simple, implica muchas facetas y funcionalidades que debe cubrir, como pueden ser:

• Atender de manera eficiente, ya que puede recibir un gran número de peticiones HTTP, incluyendo una ejecución multitarea ya que pueden darse peticiones simultáneas. Cualquier petición compleja (por ejemplo con acceso a base de datos) dejaría colapsado el servicio.
• Restricciones de acceso a los ficheros que no se quieran ‘exponer’, gestión de autentificaciones de usuarios o filtrado de peticiones según el origen de éstas.
• Manejar los errores por páginas no encontradas, informando al visitante y/o redirigiendo a páginas predeterminadas.
• Gestión de la información a transmitir en función de su formato e informar adecuadamente al navegador que está solicitando dicho recurso.
• Gestión de logs, es decir almacenar las peticiones recibidas, errores que se han producido y en general toda aquella información que puede ser registrada y analizada posteriormente para obtener las estadísticas de acceso al sitio web.

Además, Apache nos permite configurar un Hosting Virtual basado en IPs o en nombres, es decir, tener varios sitios web en un mismo equipo (por ejemplo: nombreweb1.com, nombreweb2.com,….) o como indicábamos, establecer distintos niveles de control de acceso a la información incluyendo el soporte a cifrado SSL utilizando protocolo seguro HTTPS.

A continuación, para los que quieran tener una visión más en detalle de cómo se trabaja con Apache, reproducimos la explicación del fichero de configuración de Apache 2 de nuestro curso Servidor Web Apache, elaborado por Franciso Illeras. Este apartado, junto a otros dos, los podéis  descargar en el extracto del curso que hemos publicado en nuestra sección de Tutoriales, para que podáis tener una mejor idea del mismo.

Archivo “apache2.conf”

(apartado del Tema “Configuración y ajuste del servidor Apache”)

Sin lugar a dudas, “apache2.conf” es el fichero más importante de Apache, puesto que en él se definirá el comportamiento general del servidor de páginas web y además, es el encargado de acceder a los distintos módulos que amplían la funcionalidad del servidor.

Como ya hemos comentado, el archivo “apache2.conf” se encuentra en el directorio “/etc/apache2”, y al tratarse de un fichero de texto podrá editarlo fácilmente (por ejemplo, con nuestro editor preferido “joe”).

Dentro del archivo de configuración encontraremos dos partes bien diferenciadas:

1) Variables globales del servidor: variables que definen el funcionamiento general del servidor. Las más importantes son (siempre podrá completar la información que le suministro con la que posee en la propia web de Apache, el lugar donde encontrará la documentación es “http://httpd.apache.org/docs/2.0/es/”):

En este momento solo tiene que preocuparte que el nombre de nuestro servidor esté bien indicado mediante la variable “ServerName” para que cualquier redirección o referencia existente en nuestros documentos HTML funcionen bien. Y el resto de las variables no tendrán que tocarse puesto que por defecto vienen con los valores adecuados, salvo la parte correspondiente a “AccessFileName”. Lo explicaremos de una manera más detallada.A la vista de la tabla anterior parecería que Apache es un servidor que no es muy complejo de configurar, porque no posee muchas opciones. Es cierto en parte, aunque éstas son solo una pequeña parte de las opciones que posee Apache, ya que mayoría de las variables de configuración se encuentra repartida entre otros pequeños ficheros de configuración (módulos) guardados en “mods-available” (pero esto lo veremos más adelante).

.htaccess es un archivo de texto oculto (por esa razón comienza por “.”) que permite personalizar el funcionamiento del servidor Apache un directorio concreto sin necesidad de modificar el fichero de configuración principal “apache2.conf”.

Cuando un cliente web solicita un archivo al servidor, este busca desde el directorio raíz hasta el subdirectorio que contiene el archivo solicitado el archivo .htaccess y tiene en cuenta las directivas contenidas en el mismo antes de proceder con la petición.

Los usos principales del .htaccess son:

• Impedir el listado de los archivos de un directorio.
• Redireccionar el tráfico Web.
• Personalizar las páginas de error.
• Restringir el acceso a determinados archivos.
• Impedir el acceso a determinadas IPs o rangos de IP.

En el apartado de comunicaciones seguras de este mismo tema lo veremos con más detenimiento.

2) Ampliación de funcionalidades: relacionado con las llamadas a otros módulos y archivos de configuración. Todas las directivas relacionadas con este punto vendrán precedidas por la palabra “Include”.

Si aún no te has hecho una idea mental de cómo esta conformado el servidor Apache, la siguiente imagen te ayudará.

Ilustración 1: Estructura del servidor Apache2.

Hasta ahora has aprendido que el archivo de configuración principal de Apache 2 se llama “apache2.conf” y se encuentra en el directorio “/etc/apache2”. Ya sabes como indicar el nombre del servidor, que el usuario y grupo con el que se ejecuta el servidor Apache se llama www-data, y que se cargarán todos los módulos que se encuentren almacenados en los directorios de configuración “mods-enabled” y “sites-enabled”.