Muy rápido, muy fácil, reproductor de audio con Python

En la entrada anterior pudimos ver cómo con muy poco código fue posible obtener un simple pero poderoso navegador web con el lenguaje de programación Python, PySide (Los bindings de Qt, uno de los  frameworks gráficos del lenguaje C++) y poco más de 70 líneas de código. En esta entrega veremos cómo usando el diseñador de interfaces y algo de código podemos hacer un muy simple reproductor de audio, el cual será extendido en próximas entregas.

Primero que todo es necesario decir que Qt ofrece una herramienta para diseñar interfaces de usuario. Esta se llama QtDesigner y viene incluida en el instalador de la libreria PySide de windows (para los entornos linux hay que instalarlo a mano). Esta herramienta es muy útil, puesto que con ella podemos hacer la interfaz y luego exportarla al lenguaje que vayamos a usar para realizar la aplicación (en la actualidad Qt tiene bindings para varios lenguajes, entre ellos Java, Ruby, Python y Php, entre otros), además de proveer un sistema de enlace entre objetos y métodos mediante eventos (en Qt se habla de slots y signals), lo cual facilita en cierta manera la tarea del programador. Esta herramienta es una herramienta WYSIWYG, la cual nos permite arrastrar, soltar y acomodar hasta obtener la interfaz como se desea. A continuación la imagen de la interfaz gráfica del reproductor:

La interfaz gráfica contiene unos cuantos QLabel para mostrar información, un QLCDNumber para mostrar cuánto tiempo ha transcurrido, un par de botones y unos espaciadores para conservar las proporciones al cambiar el tamaño de la ventana. A pesar de que sería posible "compilar" la interfaz a el lenguaje nativo con herramientas como el pyside-uic no lo vamos a hacer.

Ahora vamos a ver el código Python:

#!/usr/bin/env python

from PySide import QtCore, QtGui, phonon, QtUiTools
from PySide.phonon import Phonon

class Reproductor(QtGui.QWidget):

    def __init__(self):
        super(Reproductor, self).__init__(parent=None)
        self.setWindowTitle("Python Simple Player")
        self.gridLayout = QtGui.QGridLayout(self)
        loader = QtUiTools.QUiLoader()
        file = QtCore.QFile("repro.ui")
        file.open(QtCore.QFile.ReadOnly)
        self.ui = loader.load(file, self)
        file.close()
        self.gridLayout.addWidget(self.ui, 0, 0, 1, 1)
        # seccion multimedia
        self.audioOutput = Phonon.AudioOutput(Phonon.MusicCategory, self)
        self.mediaObject = Phonon.MediaObject(self)
        Phonon.createPath(self.mediaObject, self.audioOutput)
        self.mediaObject.setTickInterval(1000)
        #
        self.ui.lcdAvance.display("00:00")
        QtCore.QObject.connect(
            self.ui.btnArchivo,
            QtCore.SIGNAL("clicked()"),
            self.openFile)
        QtCore.QObject.connect(
            self.ui.btnPlay,
            QtCore.SIGNAL("clicked()"),
            self.play)
        self.mediaObject.tick.connect(self.alAvanzar)
        self.mediaObject.stateChanged.connect(self.alCambiarEstado)

    def alAvanzar(self, tiempo):
        displayTime = QtCore.QTime(
            0, (tiempo / 60000) %
            60, (tiempo / 1000) %
            60)
        self.ui.lcdAvance.display(displayTime.toString('mm:ss'))

    def alCambiarEstado(self, new, old):
        if self.mediaObject.state() == Phonon.State.StoppedState:
            self.ui.btnPlay.setEnabled(True)
        elif self.mediaObject.state() == Phonon.State.PlayingState:
            self.ui.btnPlay.setText("||")  # .setEnabled(False)

    def play(self):
        if self.mediaObject.state() == Phonon.State.PlayingState:
            self.mediaObject.pause()
            self.ui.btnPlay.setText(">")
        else:
            self.mediaObject.play()
            #///////////////////////////////////
            meta = self.mediaObject.metaData()
            meta["TITLE"] = meta["TITLE"] if "TITLE" in meta else "Indefinido"
            meta["ARTIST"] = meta[
                "ARTIST"] if "ARTIST" in meta else "SinNombre"
            label = "{TITLE} by {ARTIST}".format(**meta)
            self.ui.lblNombre.setText(label)
            #///////////////////////////////////
            self.ui.btnPlay.setText("||")

    def openFile(self):
        fileName = QtGui.QFileDialog.getOpenFileName(
            self,
            u"Abrir Archivo",
            u"/",
            u"Archivos de Audio (*.mp3 *.wav *.ogg)")
        if fileName[1]:
            self.path = fileName[0]
            self.mediaObject.setCurrentSource(
                Phonon.MediaSource(self.path))
            self.ui.btnPlay.setText(">")
            self.ui.lblNombre.setText("...")
            self.ui.lcdAvance.display("00:00")

if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    rep = Reproductor()
    rep.show()
    sys.exit(app.exec_())

En el código anterior podemos ver cómo mediante el uso del modulo QtUiTools es posible usar la clase QUiLoader para cargar en tiempo de ejecución el archivo de interfaz gráfica (repro.ui), y obtenemos un objeto QWidget, el cual contiene toda la jerarquía de objetos que habíamos hecho en el diseñador de interfaces, los cuales quedan listos para ser usados a gusto. Después de esto acoplamos el QWidget obtenido mediante un gridLayout. Seguidamente creamos las instancias de la salida de audio (audioOutput) y del reproductor (mediaObject), los cuales son enlazados mediante la instrucción:

Phonon.createPath(self.mediaObject, self.audioOutput)

Esta instrucción enlaza el reproductor con la salida de audio. Después de esto se establece cada cuánto se va a lanzar una señal de actualización (es para que pueda medirse el tiempo transcurrido y hacer cosas de acuerdo a este) mediante el tickInterval, el cual se establece cada 1000 milisegundos (un segundo) y se conectan objetos como botones a los eventos correspondientes para que antes de finalizar el constructor se enlacen las señales del reproductor a los métodos encargados de modificar el avance y cambiar la etiqueta del botón de reproducción.
Los métodos siguientes se encargan de cambiar el valor de las etiquetas, de iniciar o detener la reproducción o cambiar el título de la pista.

 El código correspondiente esta en GitHub para quienes estén interesados.

Entendiendo Javascript (V)

En el post anterior se intentó dar un vistazo general a el entorno de trabajo en JavaScript dentro de un navegador, mostrando cuáles eran sus propiedades principales, teniendo en cuenta que al iniciar la aplicación el entorno de trabajo está compuesto por todo lo que compone un objeto window, pero no sabemos mucho acerca de qué métodos o funciones podemos usar. A continuación veremos un poco de esto.

Recordemos, los procedimientos mostrados a continuación son métodos del objeto ventana y pueden ser invocados de manera directa puesto que el contexto de inicio de los scripts que se ejecutan en el navegador es la ventana misma.

• alert(mensaje): Es uno de los procedimientos más usados, éste despliega un diálogo con un mensaje específico
• close(): Cierra la ventana
• confirm(mensaje): Lanza un diálogo de confirmación y dependiendo de la respuesta retorna true o false
• open(url, nombre, parámetros, reemplazar):  Crea una nueva ventana en la cual carga la url, con el nombre y los parámetros especificados, y dependiendo del último valor la url especificada reemplazará la url de la ventana actual.
• print(): Imprime el contenido de la página actual.
• prompt(mensaje, valor): Crea un diálogo con una caja de texto, el diálogo tiene un mensaje especificado en el primer parámetro y como valor inicial el valor (valga la redundancia) especificado en el segundo parámetro.
• setInterval(funcion_o_expr, milisecs): Llama a una función o evalúa una expresión cada cierto intervalo de milisegundos. se detiene cuando la función clearInterval(id) es llamada. Ésta retorna un identificador.
• clearInterval(id): Detiene la ejecución periódica de la acción creada con setInterval a la que está asociada el id entregado.
• setTimeout(): Llama a una función o evalúa una expresión después de un intervalo de tiempo especificado en milisegundos. Ésta retorna un identificador y es detenida por la función clearTimeout(id).
• clearTimeout(id): Detiene la ejecución de la acción lanzada por setTimeout asociada al id entregado.

Muy bien, todo esto es muy bonito, pero, ¿Para qué podría usar todo esto?. A continuación vamos a hacer un pequeño ejemplo en el cual vamos a usar solo un par de los procedimientos que fueron descritos anteriormente. Vamos a hacer un cronómetro.

A continuación está el código HTML:

<html>
  <head>
    <title>Mi Cronometro</title>
    <style>
      #reloj {
        font-size:4em;
      }
    </style>
    <script src="crono.js"></script>
  </head> 
  <body>
    <script>
        var cronometro = new Cronometro();
    </script>
    <button onclick="cronometro.iniciar()">Inicio</button>
    <button onclick="cronometro.detener()">Detener</button>
    <button onclick="cronometro.reiniciar()">Reiniciar</button>
    

    <div id="reloj">
      0:0
    </div>
</body>
</html>

Y el código JavaScript:

function Cronometro(lugarCarga){
  var self = this;
  self.interval = 0;
  this.upd = function(){
    var secs = self.interval/100;
    var milis = self.interval%100;
    self.lugarCarga.innerHTML = Math.floor(secs)+":"+milis;
  }
  this.paso = function(){
    self.interval = self.interval + 1;
    self.upd();
  }
  this.iniciar = function(){
    self.lugarCarga = document.getElementById('reloj');
    self.id_intervalo = setInterval(self.paso,10);
  };
  this.detener = function(){
    clearInterval(self.id_intervalo);
  };
  this.reiniciar = function(){
    self.interval = 0;
    self.lugarCarga.innerHTML = "0:0";
  };
}

Pueden encontrar los códigos de ejemplo en GitHub.

Muy rápido, muy fácil, navegador web con Python

Python es un lenguaje que por su simpleza y versatilidad ha llegado a ser usado en muchos y muy buenos proyectos. A continuación veremos en este post el código de un navegador web muy simple, con soporte para la mayoría de las características de HTML5. Para poder hacer esto usamos Python2.7 y PySide de 32 bits si el sistema operativo es Windows, si es Linux podemos instalarlo usando los repositorios inestables o de pruebas mediante el clásico apt-get así:

apt-get install python-pyside

Aquí vamos:

# -*- coding: utf-8 -*-
# Tested in Python2.7

from PySide import QtCore, QtGui
from PySide import QtWebKit
from PySide import QtNetwork


class Navegador(QtGui.QWidget):

    def __init__(self):
        # constructor de la clase
        super(Navegador, self).__init__(parent=None)
        self.setWindowTitle("Python Navigator")
        self.showMaximized()
        self.gridLayout = QtGui.QGridLayout(self)
        self.btnAtras = QtGui.QPushButton(self, text='atras')
        self.gridLayout.addWidget(self.btnAtras, 0, 0, 1, 1)
        self.btnAdelante = QtGui.QPushButton(self, text='adelante')
        self.gridLayout.addWidget(self.btnAdelante, 0, 1, 1, 1)
        self.label = QtGui.QLabel(u"Dirección", self)
        self.gridLayout.addWidget(self.label, 0, 2, 1, 1)
        self.txtUrl = QtGui.QLineEdit(self)
        self.gridLayout.addWidget(self.txtUrl, 0, 3, 1, 1)
        self.wvNavegador = QtWebKit.QWebView(self)
        self.gridLayout.addWidget(self.wvNavegador, 1, 0, 1, 4)

        QtNetwork.QNetworkProxyFactory.setUseSystemConfiguration(True)
        QtWebKit.QWebSettings.globalSettings().setAttribute(
            QtWebKit.QWebSettings.PluginsEnabled, True)
        QtWebKit.QWebSettings.globalSettings().setAttribute(
            QtWebKit.QWebSettings.JavascriptCanOpenWindows, True)
        QtWebKit.QWebSettings.globalSettings().setAttribute(
            QtWebKit.QWebSettings.DeveloperExtrasEnabled, True)

        QtCore.QObject.connect(
            self.txtUrl,
            QtCore.SIGNAL("returnPressed()"),
            self.cargarUrl)
        QtCore.QObject.connect(
            self.btnAtras,
            QtCore.SIGNAL("clicked()"),
            self.wvNavegador.back)
        QtCore.QObject.connect(
            self.btnAdelante,
            QtCore.SIGNAL("clicked()"),
            self.wvNavegador.forward)

        _url = "http://www.python.org"
        self.wvNavegador.load(QtCore.QUrl(_url))
        self.txtUrl.setText(_url)

    def cargarUrl(self):
        url = self.txtUrl.text()
        url = url if url.startswith(
            "http://") or url.startswith(
                "https://") else "http://{url}".format(
                    url=url)
        self.wvNavegador.load(QtCore.QUrl(url))


if __name__ == "__main__":
    import sys
    app = QtGui.QApplication(sys.argv)
    nav = Navegador()
    nav.show()
    sys.exit(app.exec_())

Podemos ver que en el bloque de código anterior se crea la clase navegador, en la cual se crean los controles básicos (la caja de texto para la URL, botones de atrás y adelante, el espacio de navegación), después de esto se "empaquetan" por así decirlo en un gridlayout, el cual nos permite hacer que los controles se ajusten de manera dinámica cuando cambie el tamaño de la ventana. Después se habilitan los plugins del elemento mediante el cual se navega para que sea posible ver vídeos en youtube e inspeccionar elementos (muestra el DOM, los scripts y demás de manera muy similar a la de Google Chrome) mediante click derecho, luego se enlazan los botones al navegador mediante los eventos de click y la barra de direcciones al navegador mediante el evento returnPressed y después se carga la URL inicial ("http://www.python.org").
Finalmente se instancia los objetos necesarios para iniciar nuestro navegador.

Fácil, efectivo y contundente, un navegador muy simple con menos de 70 lineas de código.

Aquí esta el enlace al repositorio en GitHub (siéntanse libres de modificarlo) y abajo les dejo una imagen de como se ve.

Consoleando (II)

Después de aprender lo básico es hora de aprender cosas más interesantes, scripts.

¿Qué es un Script?
Un script es un archivo que contiene una secuencia de órdenes que facilitan alguna labor (es un programa).

Ejemplo de un Script
A continuación veremos cómo se hace un script básico, saludo.sh . La labor de éste script es escribir "buenos dias", "buenas tardes" o "buenas noches", lo anterior dependiendo de la hora.
Entonces:

#!/bin/bash
# la linea anterior se pone para que el sistema operativo
# sepa con que interprete debe ejecutar el script

### programa: saludo.sh
let HORA=`date +%H` # capturamos la hora del dia
if [ $HORA -ge 4 ] && [ $HORA -lt 12 ]; then
    echo 'Buenos Dias!!!'
fi
if [ $HORA -ge 12 ] && [ $HORA -lt 18 ]; then
    echo 'Buenas Tardes!!!'
else
    echo 'Buenas Noches!!!'
fi
### fin programa

En este bloque de código podemos ver muchas de las interesantes cosas que tiene el lenguaje bash, uno de los lenguajes usados en las consolas Linux, éste es simple y potente, además nos permite usar comandos del sistema como date, crear variables mediante la orden let, extraer información de los comandos del sistema (una de las formas de hacer esto es mediante las comillas invertidas [ ` ], las cuales interpretan el comando que esté dentro de las comillas y retornan esa cadena convertida en valor, lo cual puede ser almacenado o usado en nuestro programa), usar condicionales ( if, else, case), operadores lógicos ( && y | | ), escribir cadenas mediante la orden echo y muchas más cosas.
Algo que en principio es extraño para quienes hacen scripts es que no entienden qué es -lt o -ge, estos son los operadores de comparación, a continuación los veremos en una tabla con sus significados:

comando	significado
-lt	menor que
-le	menor o igual que
-eq	igual que
-ge	mayor o igual que
-gt	mayor que
-ne	diferente a

Y, ¿Qué hacer con ese código?
Este código se guarda en un archivo de texto, por ejemplo saludo.sh (uso la extensión sh porque es un archivo del lenguaje bash, que es a su vez una mejora de sh), y luego en la consola hago que éste se pueda ejecutar mediante la orden chmod así:

chmod +x saludo.sh

Y, ¿Cómo lo ejecuto?
Para ejecutarlo escribimos en la consola la ruta completa del archivo si estamos en una carpeta diferente a la del archivo, si estamos en la misma carpeta  anteponemos un punto, así:

# si no estamos en la misma carpeta
/home/andres/saludo.sh
# y si estamos en la misma carpeta
./saludo.sh

Entendiendo Javascript (IV)

Quien empieza a usar JavaScript a menudo sabe qué quiere hacer pero no sabe acerca del entorno en el que se desempeña, el navegador. Esto no debería ocurrir, por que conocer el entorno, sus variables, las funciones que se pueden usar y cuando se pueden usar hacen de esta tarea algo menos complejo.

Muy bonito, pero ¿Dónde Estoy?
¿Dónde estoy?, esa es la primera pregunta que debemos hacernos, y para esto es necesario que entendamos que compone el navegador (por ahora pensaremos en el navegador, mas adelante al usar herramientas como NodeJs, la cual esta del lado del servidor pensaremos en otros tipos de entorno) y como se usa.

Composición del navegador
El navegador está compuesto por varios objetos, los cuales de una u otra forma usamos aunque no tengamos conociemiento de ellos, a groso modo podemos decir que son:

• Window: es el objeto principal, en el cual están contenidos los demás objetos del navegador. Se crea un objeto de este tipo para cada ventana que pueda ser abierta (recuerde que en la actualidad los navegadores bloquean muchas de las ventanas emergentes) desde una página Web. El objeto window contiene:
• Navigator: contiene información acerca del navegador, entre estas nombre, versión, tipos MIME soportados por el cliente y otros. 
• Location: contiene información acerca de la página visualizada. 
• History: objeto que almacena información de los lugares visitados.
• Document: Cuando se hace una petición web el navegador descarga una gran cantidad de datos, entre estos el código HTML, luego el convierte ese código HTML en objetos, document es el contenedor de todos los objetos creados en la página web, tales como: 
• enlaces
• formularios
• imágenes
• marcos
• etc.
• Frames: Es una matriz que contiene los distintos objetos frame que puede contener una ventana. Debemos tener en cuenta que cada frame es a su vez otra ventana.

Una vez más, ¿Dónde estoy?

Después de haber echado un vistazo a una gran cantidad de teoría es más fácil inferir que cuando inician nuestros programas en JavaScript nuestro entorno de trabajo es un objeto window.

Concluyendo

Después de ser golpeado por estos nuevos conceptos sabemos que nuestros programas inician dentro de un objeto window, el cual nos ofrece un entorno con una serie de objetos que podemos usar a voluntad, entre estos el document, donde están contenidos los objetos como botones, cajas de texto y demás.

Fuentes
http://www.w3schools.com/jsref/obj_window.asp

Consoleando (I)

Pánico, eso es lo que sienten muchas de las personas que conozco cuando ven esa ventana de fondo negro, un mundo de letras y una raya que aparece y desaparece, ese "demonio" al que suelen llamar consola o terminal, pero si reflexionamos un poco más acerca de esto, vemos que quienes se inventaron este artilugio no eran más que simples mortales que no tenían mas memoria o tiempo que nosotros, es decir, no debe ser tan difícil, solo hace falta práctica y un documento en google drive para tener una ayudita con esos terribles comandos.
Este post es el primero de una serie en los que me gustaría que quienes están menos familiarizados con esta herramienta, dejen de temerle y huirle porque es la base de todo lo que vemos y conocemos hoy en día. Para esta serie de artículos me enfocaré en los sistemas operativos basados en unix, ya que son los que más podrían requerir el uso de esta herramienta.

Primeros Pasos:

• ¿Cómo se usa?
• Se teclea un comando en la linea de comandos, consola, terminal o como sea que le llamen y se oprime la tecla ENTER para ver su resultado.
• para salir de un programa en ejecución generalmente se usa la combinación de teclas Control+C
• En las terminales más avanzadas podemos ver colores que indican el tipo de archivo, los permisos y además podemos usar las teclas de dirección (las flechas de desplazamiento) de arriba y abajo para navegar por los comandos que hemos introducido
• Podemos limpiar la consola (borrar los comandos y resultados anteriores) con la combinación Control+L, este es el equivalente a la orden clear
• Si alguno de los puntos anteriores no resulta, es probable que este usando una linea de comandos antigua como sh o su sistema operativo no sea un sistema operativo basado en unix, por ejemplo windows.
• Primeros comandos

man  # muestra el manual de cualquier comando
# por ejemplo, se puede usar
man ls # este muestra el manual del comando ls
# para salir del manual se oprime la letra q
ls  # lista los archivos de un directorio
pwd # nos muestra en que carpeta estamos ubicados
cd  # nos ubica en la carpeta personal del usuario
cd /ruta/de/destino # nos lleva a una ruta de destino especificada
cd .. # nos lleva a la carpeta anterior
mkdir carpetita # crea una carpeta con nombre carpetita
date # nos dice la fecha y hora actual
echo 'Hola Mundo!' # escribe en pantalla "Hola Mundo!"
cat /ruta/arch # escribe en pantalla el contenido de arch

• Para Recordar
• Casi todos los comandos tienen opciones, estas pueden verse mediante el manual del comando
• la consola sabe diferenciar entre mayúsculas y minúsculas y es MUY ESTRICTA con esto.
• todo lo que ven después de el símbolo # no es tomado en cuenta por la consola, por que es un comentario 
• la practica hace al maestro (si no tiene consola unix puede hacer pruebas online aqui o aqui)

Entendiendo Javascript (III)

Objetos por aquí, objetos por allá, muy bonito, muy bonito, pero de que sirve esto sin la Herencia?

Herencia
Retomando, JavaScript nos provee ciertas herramientas para poder usar programación orientada a objetos, entre estas los prototipos, de esta manera podemos hacer gala de nuestras habilidades con este paradigma, pero aún hace falta una de las mas importantes herramientas, la herencia.
La herencia en JavaScript se hace al igual que las clases mediante el prototipo, pero hay dos maneras de implementarla:

Herencia Mediante Cadena de Prototipos:
Este tipo de herencia se hace mediante el uso del prototipo de los objetos, de esta manera:

// Ejemplo de Herencia por prototipos

// clase padre
function Mamifero(medio, num_extremidades, sonido){
    this.medio = medio; 
    this.extremidades = num_extremidades;
    this.saludo = function(){console.log(sonido)};
}

// clase hija
function Perro(raza){
    this.raza = raza;
}
// especificamos cual es la clase padre
Perro.prototype = new Mamifero("terrestre", 4, "Guauu, Guauu...");
fluffy = new Perro("Doberman");
fluffy.saludo()
// Fin del ejemplo

Lo que acabamos de ver se llama cadena de prototipos, y esta se basa en que una clase hija lo que hace es reemplazar su prototipo por una instancia de la clase padre, por esto se hace la asignación de una instancia de la clase padre al prototipo como vemos en la linea 15.

Herencia mediante llamado al Constructor del Padre:
Este tipo de herencia hace uso del constructor de la clase padre de manera directa, se hace así:

// Ejemplo de Herencia por prototipos

// clase padre
function Mamifero(medio, num_extremidades, sonido){
    this.medio = medio; 
    this.extremidades = num_extremidades;
    this.saludo = function(){console.log(sonido)};
}

// clase hija
function Gato(raza){
    Mamifero.call(this,"terrestre", 4, "Miauu, Miauu...");
    this.raza = raza;
}
// insatancia de la clase
jack = new Gato("Angora")
jack.saludo()
// Fin del ejemplo

Lo que acabamos de ver fue otra manera de usar herencia en JavaScript, esta es más interesante por que encapsula todo dentro del mismo bloque de código. Lo que se está haciendo es que se llama el constructor de la clase padre pero se especifica que los atributos y métodos de la clase padre deben ser establecidos en la clase actual, lo anterior se lleva a cabo mediante el método call, usado en la linea 12, el cual recibe como primer parámetro la referencia al objeto en construcción.

Guía Android (I), Empecemos con el pequeño robot

El pequeño robot (Android) es en la actualidad uno de los sistemas operativos más usados en los dispositivos móviles del mundo, por eso no podemos dejar de lado la importancia de aprender un poco más de a cerca este.

Linux???
Si, aunque parezca asombroso para todos aquellos que dicen que Linux muy complejo y que todo requiere consola, Android es un sistema operativo basado en Linux, lo cual hace que Android sea un poco más estable que otros sistemas operativos y tiene toda las ventajas del kernel Linux.

Powered By Google
Aunque inicialmente este fue desarrollado por Android Inc. este sistema operativo fue adquirido en el año 2005 por el Gigante de Mountain View, Google, y esta es una de las razones del por que en la actualidad cuando se tiene un dispositivo con Android es casi obligatorio poseer una cuenta de correo de Google.

Muy Nutrido...
Android tiene muchas cosas muy interesantes tanto para usuarios como para desarrolladores, como adaptabilidad en cuanto al tamaño de pantallas, gráficos en 2D y 3D, soporta SQLite, múltiples bandas de telefonía móvil, mensajes de texto plano y multimedia, navegadores web, gran soporte multimedia permitiendo usar formatos como MP3, MIDI, Ogg Vorbis, WAV, JPEG, PNG, GIF y BMP entre otros, soporte para streaming, para hardware adicional, un Kit de herramientas para desarrollo en su plataforma (SDK y NDK), un mercado para descargar y vender aplicaciones y mucho más.

Ya Es Muy Conocido
En la actualidad hay en el mundo al rededor de 900 millones de dispositivos con Android.

Fuentes:
Wikipedia, Google.

Entendiendo Javascript (II)

Ya en el articulo anterior entendimos un poco mejor que es JavaScript, ahora ya es necesario aclarar muchas de las cosas maravillosas que podemos hacer con este lenguaje.

Prototipos
Debemos recordar que en JavaScript es un lenguaje basado en prototipos, es decir, el no crea instancias de objetos, en vez de esto clona un objeto que usamos como nos sea conveniente, pero ¿Como como crear una clase con JavaScript?. Para esto podríamos tener en cuenta la siguiente tabla:

Programación Orientada a Objetos	Programación mediante Prototipos
Objeto	Prototipo
Atributo	Variable
Metodo	Función

Aun así no queda muy claro donde y como hacer un prototipo, para esto debemos tener en cuenta que todo objeto creado en JavaScript por defecto tiene un atributo llamado prototype, para poder entender como se usa veamos el siguiente ejemplo:

/* Ejemplo de prototipo */
function Automovil(nombre, modelo){
    this.nombre = nombre;   // este es un atributo
    this.modelo = modelo;   // este es otro atributo
    // la palabra reservada this hace que la variable
    // pertenezca al contexto de la función que
    // representa la clase, si no se usa la variable es local
    // y desaparece al terminar la ejecución de la función.
}
Automovil.prototype.encender = function(){ // uso de prototype
    console.log("run, run..."); // escribimos un mensaje en consola
}

// ejemplo de creacion de un objeto
auto = new Automovil("BMW","X6"); // la palabra new clona el objeto
auto.encender(); // llamado del metodo encender
/* Fin del Ejemplo */

Entendiendo Javascript (I)

En este momento uno de los más importantes lenguajes de programación del mundo es JavaScript, no porque sea el más sencillo, más fácil de entender o de usar, por el contrario, es un tanto complejo y poco legible, en este artículo vamos a tratar de entender un poco mejor este lenguaje.

¿Que es JavaScript?

JavaScript es un lenguaje interpretado, que se define como orientado a objetos, basado en prototipos, imperativo, débilmente tipado y tipado dinámico, y ¿a que se refiere todo eso?.

• Interpretado: NO es necesario compilar el código para poder ejecutarlo.
• Orientado a Objetos: Un lenguaje orientado a objetos permite diseñar un sistema partiendo de los objetos que están inmersos en este y su forma de interactuar. En teoría deberían declararse clases con métodos y atributos pero en JavaScript a diferencia de otros lenguajes no se usan palabras clave como class, de ahí su siguiente característica.
• Basado en Prototipos: Esta es una característica de algunos lenguajes orientados a objetos, los cuales en vez de crear objetos mediante la instanciación de una clase los crean mediante la clonación de objetos de los mismos y posterior extensión mediante cosas que agrega el programador.
• Imperativo: Un lenguaje imperativo es aquel en que el programador le indica de manera explícita a la máquina como debe hacer una tarea.
• Débilmente Tipado: cuando el intérprete empieza a ejecutar las órdenes de nuestro programa este no es "consciente" por así decirlo en todo momento de cual es el tipo del dato que está contenido en una variable, en los lenguajes fuertemente tipados si.
• Tipado Dinámico: Esto hace referencia a que cuando el intérprete empieza a ejecutar el programa este va alterando según las necesidades del programa el tipo de dato de una variable, es decir, cambia la cantidad de memoria que necesita la variable.

Referencias

• http://es.wikipedia.org/wiki/JavaScript
• http://es.wikipedia.org/wiki/Programaci%C3%B3n_basada_en_prototipos

Programando en android más fácilmente, droidparts

En la actualidad las tendencias nos guían a la web y a los dispositivos móviles, y es necesario ir evolucionando en un mercado que cambia tan rápidamente. Ahora bien, si ya haces aplicaciones para dispositivos móviles como android pero por algún motivo solo haces desarrollo nativo y te enfrentas a problemas de escalabilidad y mantenimiento de tus aplicaciones tal vez el droidparts te parezca útil, este framework tiene características interesantes, como:

• Inyección de dependencias para vistas, recursos y más
• Mapeo objeto-relacional para bases de datos SQLite
• Serialización y Deserialización de datos en formato JSON
• Mejora para trabajo con tareas asíncronas (Progreso, resultado de operaciones y reporte de errores)
• Cliente RESTful completo con soporte completo para las operaciones CRUD
• Mejora en manejo de imágenes (Cacheo, búsqueda, carga asíncrona y más) 
• Soporte para manejo de fragmentos, utilidades de android v4 (support-v4) y soporte para action bar en cualquier versión de android mediante ActionBarSherlock.

puedes encontrar documentación aqui.