Mostrando entradas con la etiqueta linux. Mostrar todas las entradas
Mostrando entradas con la etiqueta linux. Mostrar todas las entradas

lunes, 15 de septiembre de 2014

De Nano a Emacs, cambiando una resortera por una piedra filosofal.




Hace un tiempo ya que publique un articulo para empezar a usar Vim, en esta entrada y gracias a Jonathan Sandoval puedo tomar un articulo de su blog y adaptarlo para así traer ante ustedes una nueva herramienta, Emacs.

¿Qué es Emacs?
La GNU define a emacs como el editor extensible y [altamente] personalizable. Esta descripción podría perfectamente aplicarse a muchos otros editores si es que no se conoce de emacs, o nunca se ha trabajado en él.
Comenzaré por mencionar que Emacs fue desarrollador por Richard Stallman, un desarrollador de C y de Lisp, que llegó a ser usuario de máquinas Lisp, y emacs, en esencia, es una máquina virtual de Lisp enfocada a la implementación de un potente editor. Emacs es, por tanto, extensible en Emacs Lisp. La naturaleza altamente dinámica de [Emacs] Lisp, le permite modificar (y por tanto, personalizar) virtualmente cualquier parte Lisp. Esto lo diferencia de otros editores que, a pesar de poderse extender a través de otros lenguajes de programación, lo permiten de una manera muy limitada a lo que puede llegar a permitir emacs.
Si en su tutorial de Vim, Oscar llama a este editor un “cañón de neutrones” (lo que sea que esto quiera decir), Emacs vendría a ser algo así como la “piedra filosofal” de los editores de texto (manteniendo la proporción de las metáforas ;)).

Funcionalidades
Veamos entonces, qué se puede realizar con GNU Emacs:


  • Corrector ortográfico (hace uso del que venga instalado en el sistema, aspell o hunspell por ejemplo).
  • Autocompletado de texto.
  • Múltiples archivos pueden ser visibles al tiempo, dividiendo el marco de trabajo.
  • Resaltado de sintaxis, dependiendo del lenguaje de programación que se utilice. 
  • Deshacer, “rehacer” (para emacs, rehacer es una forma de “deshacer”. Esto es bastante poderoso, aunque sea diferente a los demás editores).
  • Emacs soporta una cantidad impresionante de lenguajes de programación y modos de resaltado. 
  • En su administrador de paquetes (SI, emacs tiene un administrador de paquetes al más puro estilo de apt-get o yum) es posible encontrar sintaxis tan exóticas como las de los archivos de configuración de Asterisk.
  • Extensible en Emacs Lisp. (Hay proyectos como Pymacs que permiten que emacs pueda ser extensible en Python).
  • Completado de comandos, palabras y uris de archivos. (Es posible instalar complementes como Ido y Helm, los cuales pueden funcionar juntos, que a su vez expanden enormemente las capacidades de autocompletado y búsqueda de emacs).
  • Compresión y descompresión de ficheros a la hora de ser editados. Puede también trabajar con ficheros cifrados a través de gpg. Soporte para múltiples codificaciones de ficheros, y conversión entre los mismos.
  • Historial de comandos ejecutados recientemente. 
  • Igualmente, es posible instalar extensiones que facilitan que recuerdan los comandos más utilizados. Grabación y reproducción de macros. (Las ediciones de código más complejas se pueden realizar en emacs lisp). 
  • Guardado de la configuración entre sesiones. 
  • Plegado (folding) de bloques de código. 
  • Interfaz gráfica opcional (e innecesaria y poco recomendada). 
  • Probablemente es el editor más configurable y personalizable que hay (alguien me indica uno más personalizable?.
  • Es capaz de emular a Vim con Evil, pero con la potencia de seguir en Emacs :).
  • Compilación y depuración desde el mismo editor. 
En esta lista traté de listar lo mismo que en el artículo de Vim fue listado. Ahora haré un breve repaso de características de Emacs que son únicamente fáciles gracias a su diseño altamente extensible: 
  • Cliente de correo electrónico (rmail, gnus).
  • Lector de noticias. Cliente de IRC (ERC). 
  • Organizador personal (org-mode). Esta es probablemente una de las extensiones más impresionantes que tiene emacs, y por las que muchos usuarios deciden iniciar la carrera de aprendizaje de este editor. Yo lo uso como mi agenda personal, administrador de proyectos, y ofrece, por ahí derecho, la posibilidad de editar textos complejos que pueden ser exportados a formatos como HTML, LaTeX (y por tanto, a PDF), texto, plano, entre otros. Con org-mode es posible realizar programación literata e investigación reproducible. 
  • Interfaces a las aplicaciones de control de revisiones con VC (subversion, git, bazaar, mercurial, etc.). 
  • Administrador de procesos (Proced). 
  • Administrador de archivos (Dired). Este modo es especialmente interesante para realizar ciertas operaciones con archivos. 
  • Administrador de paquetes (package.el).


Utilizando emacs

Dado que esta es una [no tan] corta introducción, solo indicaré el uso básico de emacs. A diferencia de Vim, que hace uso de distintos modos para trabajar, emacs utiliza complejas combinaciones de teclas con Control, Alt, y otras (yo por ejemplo tengo configurada la tecla Win). La convención es que C-x quiere decir control junto con x, y C-x a quiere decir, primero Control-x, y posteriormente solo la tecla a. Igualmente, Alt se denota con M- por lo que M-x quiere decir, Alt junto con la tecla x (M quiere decir Meta, y se refiere a una tecla que tenían viejos teclados). Para abrir emacs basta con ejecutar lo siguiente en la linea de comandos:
emacs
Una vez en el editor, pueden presionar C-x C-f para abrir o crear un nuevo archivo. Una vez realicen cambios, pueden presionar C-x C-s para guardar los cambios. Ahora, para salirse de emacs basta con que presionen C-x C-c .

Otros comandos

  • C-SPC (Control + la barra espaciadora). Inicia la selección de texto.
  • C-w : Cortar.
  • M-w : Copiar.
  • C-y : Pegar.
  • C-a : Va al principio de la linea.
  • C-k : Corta desde la ubicación del cursor hasta el final de la linea.
  • M-7 C-k : Corta siete veces la linea.
  • C-u 5 0 C-y : Pega cincuenta veces lo recientemente copiado.
  • TAB: Tabula la linea actual.
  • C-_ : Deshacer.
  • C-x o : Cambia a la siguiente ventana.
Espero que aprendan mucho de este articulo y si quieren profundizar en Emacs pueden ir directamente a el articulo de donde se extrajo la información.


Si te gusto el post
compartelo... :D

lunes, 4 de agosto de 2014

Tutorial de NodeJS I, llevando la potencia de V8 al servidor


Es verdad que hace algún tiempo Brendan Eich tuvo como labor crear un lenguaje que enriqueciera los navegadores y éste uso una poca de sus poderes magicos y entrego al mundo Javascript, tiempo después Google entrego al mundo de la mano de Lars Bak V8, una de las mejores maquinas virtuales que interpretan Javascript, y luego Ryan Dahl , un muchacho inquieto decidió portar V8 para que funcionara independientemente, y esto fue llamado Node.js.


Node.js es un entorno de programación para servidor basado en el lenguaje de programación Javascript, con I/O de datos en una arquitectura orientada a eventos y basado en el motor Javascript V8. Fue creado con el enfoque de ser útil en la creación de programas de red altamente escalables, como por ejemplo, servidores web.

Instalando NodeJS

El la pagina oficial del proyecto pueden descargar el instalador, para Windows y Mac es muy sencillo, solo basta bajar el instalador y ejecutarlo como se hace comúnmente en cada plataforma, para sistemas linux por otro lado es necesario descargar el código fuente, para instalarlo en distribuciones debian o basadas en debian debemos:

1. Descargar los fuentes
wget -c http://nodejs.org/dist/v0.10.30/node-v0.10.30.tar.gz
2. Instalar dependencias
apt-get install GCC make libssl-dev
3. descomprimir el paquete
tar -zxf node-v0.10.30.tar.gz
4. Entrar a la carpeta
cd node-v0.10.30
5. configurar
./configure
6. compilar (y tomar una buena tasa de café por que se toma su tiempo)
make
7. Instalar
sudo make install
Muy bien, esto deberia instalar nodejs y otra herramienta fabulosa llamada npm, la cual permite gestionar paquetes de nodejs y manejar dependencias, entonces para probar que se instalo correctamente ejecutamos:
node --version
npm --version
de esta manera tendremos las versiones de nodejs y npm respectiva mente.
Espero que esta primera parte sea util para ustedes.


Por favor
Comparte este post. 
:D

miércoles, 19 de febrero de 2014

Tutorial ¿Cómo compilar Python3 en Linux Debian?


Muchos ya lo han dicho, hay que dejar de lado Python2.X y aunque aun falta para ello he aquí un tutorial para compilar en nuestra maquina linux (debian para ser exactos) Python3.3.

Instalación de dependencias
Como super usuario (root) ejecutamos la siguiente instrucción en la linea de comandos:
apt-get install make build-essential  zlib1g-dev  libbz2-dev  libncurses5-dev  libreadline6-dev  libsqlite3-dev  libssl-dev  libgdbm-dev liblzma-dev tk8.5-dev

Descarga y compilación
Ahora bien, debemos descargar el código fuente y compilarlo, para ello ejecutamos las siguientes instrucciones:
wget -c http://python.org/ftp/python/3.3.4/Python-3.3.4.tgz
tar -zxf Python-3.3.4.tgz
cd Python-3.3.4
# Proceso de compilación
# primero se configuran los makefile para el sistema
./configure
# inicia compilación
make
# se hacen pruebas para saber que todo salió bien, 
# es recomendable pero no obligatorio.
make test
# instalación de los binarios en el sistema
make install

Finalmente solo queda probarlo ejecutando python3.3.

Espero que les haya gustado.

Si te gusto el post
compartelo... :D

lunes, 25 de noviembre de 2013

Puesta en producción de una aplicación web con Django y Nginx


Cuando se usan frameworks para desarrollo web todo se hace más fácil, excepto la puesta en producción, una muestra clara de esto es django, un framework que permite que cosas como hacer un entorno de administración parezca juego de niños y que realizar consultas que parecen concebidas en la maligna mente del mismo Satanás sea una tarde de picnic. Desafortunadamente a la hora de poner en producción un proyecto empezamos a ver dificultades. Este post tiene como objetivo mostrar una sencilla manera de poner en producción nuestros proyectos con Django mediante el servidor Nginx.

Nota: Todo el proceso de configuración esta preparado para Linux Debian y derivados, si usas una distribución diferente es probable que cambien las rutas de los archivos de configuración.

Primero que todo, ¿Qué es Nginx?

Nginx es un servidor web y proxy inverso ligero de muy alto rendimiento, es software libre de código abierto y multiplataforma, tiene las siguientes características:
  • Servidor de archivos estáticos, índices y autoindexado.
  • Proxy inverso con opciones de caché.
  • Permite realizar balanceo de carga.
  • Tolerancia a fallos.
  • Soporte de HTTP sobre SSL.
  • Soporte para FastCGI con opciones de caché.
  • Servidores virtuales basados en nombre y/o en dirección IP.
  • Streaming de archivos FLV y MP4.
  • Soporte para autenticación.
  • Compatible con IPv6.
  • Soporte para protocolo SPDY.
  • Soporte para compresión gzip de paquetes.
  • Habilitado para soportar más de 10.000 conexiones simultáneas.
Muy bien, pero ¿Qué pasa con lo clásico?
Muchos se preguntaran ¿Por qué Nginx y no Apache2?, pienso que hay varias cosas al respecto:
  • La cantidad de recursos que demanda Apache2 son mucho mayores que los demandados por Nginx.
  • La velocidad alcanzada por Nginx es mucho mayor que la de Apache2 a la hora de responder peticiones.
  • Nginx es muchisimo más fácil de configurar que Apache2 puesto que Apache2 usa engorrosos XMLs, Nginx no.
La información mencionada la obtuve de aquí, aquí y aquí.

Muy bien, entonces, manos a la obra
En este momento me parece adecuado explicar cómo funciona la conexión entre django y Nginx:

Nginx es el encargado de atender las peticiones externas por el puerto 80 (protocolo HTTP), éste a su vez envía los datos de la petición a uWSGI mediante un puerto auxiliar, quien hace de intermediario en el proceso de comunicación y finalmente uWSGI entrega los datos de petición a nuestro proyecto django para que éste ejecute la acción correspondiente e inicie el proceso inverso para responder a la petición. Escogí uWSGI porque me pareció muy fácil de usar y en éste enlace hay una comparativa de rendimiento en la cual el tiempo de respuesta es mejor que el de Gunicorn.

Configuremos Nginx
Debemos crear el archivo de configuración para nuestro proyecto, recuerda que si el puerto 80 está siendo usado por Apache2, por alguna otra aplicación o por el mismo Nginx por otra configuración debes liberar primero el puerto, en caso de ser Apache2 debes editar el archivo /etc/apache2/ports.conf y cambiar el puerto 80 por uno diferente, luego reiniciar el servicio Apache2 así:
$ service apache2 restart
Después de esto debes crear el archivo de configuración en la carpeta /etc/nginx/sites-avaliable, el nombre del archivo lo eliges tú, yo elegí como nombre archivo.conf. El contenido del archivo debe ser el siguiente:
# archivo.conf
server {
    listen      80; # puerto por el que escucha la aplicación
    server_name midominio.co; # nombre o ip del servidor
    charset     utf-8;

    # tamaño maximo de subida
    client_max_body_size 75M;

    # Ruta de la carpeta media
    location /media  {
        alias /var/www/proyecto/media; # reemplace por su ruta a media
    }

    # Ruta de la carpeta static
    location /static {
        alias /var/www/proyecto/static; # reemplace por su ruta a media
    }

    # Configuración de las peticiones que no son resueltas con las
    # reglas anteriores. Estas son reenviadas al servidor django
    location / {
        uwsgi_pass 127.0.0.1:8001; # 127.0.0.1:PUERTO_AUXILIAR
        include     uwsgi_params;
    }
}
Cabe resaltar que el puerto auxiliar seleccionado es el 8001, este dato es importante puesto que debemos tenerlo en cuenta para iniciar la labor de uWSGI.
Después de esto es necesario habilitar la nueva configuración creando un enlace simbólico del archivo en la carpeta sites-avaliable de Nginx así:
$ cd /etc/nginx/sites-enabled
$ ln -s ../sites-avaliable/archivo.conf .
Finalmente reiniciamos el servidor Nginx
$ service nginx restart

Configuremos nuestro entorno
Primero es necesario crear un entorno para el proyecto con la orden mkvirtualenv vista en el post anterior y luego activamos el entorno creado con la orden workon:
$ mkvirtualenv entorno
$ workon entorno
después de ésto es necesario instalar las dependencias de nuestro proyecto django, personalmente pienso que es bueno trabajar con django 1.5 o superior, puesto que aasi tendremos muchas de las nuevas características, además django 1.6 fue liberado hace un par de semanas.
$ pip install django
$ pip install ....
$ pip install ....
Ahora necesitamos instalar uWSGI:
$ pip install uwsgi
Nota: Para instalar uWSGI es necesario tener instalados en el sistema el compilador gcc y los paquetes de desarrollo de python, para el caso de linux debian y derivados con python2.7 deben instalarse como superusuario así:
$ apt-get install gcc-4.5 python2.7-dev
Finalmente creamos el archivo para iniciar el proceso de conexión entre Nginx y django, este archivo es un script bash al que yo llame start.sh, este debe tener el siguiente contenido:
#!/bin/bash
uwsgi --socket :8001 --wsgi-file wsgi.py -d mensajes.log

Aquí viene la parte importante, cuando django genera un proyecto él crea una carpeta de proyecto, dentro de ésta hay una carpeta con los archivos de configuración, éstos son settings.py, urls.py, __init__.py y wsgi.py


debe hacer una copia del archivo wsgi.py a la raíz del proyecto y en éste mismo lugar poner el archivo start.sh así:

Después es necesario permitir la ejecución de este archivo mediante la orden:
$ chmod +x start.sh
Luego podemos iniciar el proceso así:
$ ./start.sh
Si tienes alguna duda o comentario puedes hacerla en la sección de comentarios, espero que sea útil.

Si te gusto el post
compartelo... :D

martes, 27 de agosto de 2013

Consoleando (III)

En artículos pasados he intentado mostrar un poco de las potencia de la consola, pero en realidad la potencia de la consola de los sistemas basados en Unix está en la posibilidad de tener muchísimos pequeños programas que se enlazan de manera mutua para hacer una labor compleja, por éste motivo existen las tuberías o Pipes.

Entre un Tubo...
El uso de tuberías o Pipes permite que el usuario ejecute un proceso y con la información de salida de éste alimente un nuevo proceso, de esta manera se pueden encadenar de manera sucesiva la cantidad de tareas que se desee. El operador encargado de las tuberías es la barra vertical ( | ), ésta es usada en otros lenguajes como el operador de bits OR, para el caso de bash ésta se usa como operador de tubería.

Y, ¿Cómo se usa?
Su uso es sencillo: Basta con separar los procesos con la barra vertical ( | ), lo cual hará que la salida del primer proceso ejecutado sea la entrada del segundo proceso, así:
ps -ef | grep root
En éste ejemplo podemos ver dos instrucciones:
La primera es ps con el argumento -ef, de ésta manera se hace una lista de todos los procesos existentes y muestra muchos de los datos relevantes del proceso, entre estos el comando con el que fue lanzado.
La segunda instrucción es grep con el argumento root, ésta instrucción filtra todas las líneas que contengan la palabra root, de manera que al unir ambas tareas mediante una tubería se mostrarán todos los procesos que contengan la palabra root, es decir, se filtrarán los procesos del usuario root y aquellos que en la línea de comandos tengan ésta palabra.

Un ejemplo más
¿Cómo cerrar un proceso de acuerdo al nombre?, esa es una de las tareas que podrían ser automatizadas. Por ejemplo, si hacemos una aplicación cliente-servidor que internamente usa la instrucción fork (ésta instrucción crea copias del proceso original) podríamos eliminar todas las instancias de la aplicación mediante el uso de las siguientes instrucciones:

  • ps : Lista todos los procesos de la máquina.
  • grep : Filtra las aplicaciones de acuerdo a un patrón especificado.
  • awk : Permite hacer operaciones sobre cadenas, como separarlas por palabras (tokenizarlas) y más.
  • xargs : Pasa los parametros que recibe mediante la tubería a una instrucción especificada.
  • kill : Termina una aplicación.
y las instrucciones se encadenarían así (en una sola línea):

ps -ef | grep NombreProceso | grep -v grep | awk '{print $2}' | xargs kill

La anterior secuencia de comandos y tuberías funciona así:

  1. ps -ef : Lista todos los procesos de la máquina.
  2. grep NombreProceso : Filtra todos los procesos que contengan la subcadena NombreProceso.
  3. grep -v grep : Quita las líneas que contengan la cadena grep (para que no se incluya el proceso del filtro anterior).
  4. awk '{print $2}' : Entrega únicamente el segundo token de cada línea, para éste caso es el número de identificación de cada proceso.
  5. xargs kill : Ejecuta el comando kill sobre cada uno de los números de proceso entregados.
Una de las grandes ventajas de la consola es que mediante el uso de tuberías se pueden automatizar procesos complejos de administración de máquinas y demás.

Espero que les sea de utilidad.

jueves, 25 de julio de 2013

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:

comandosignificado
-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

miércoles, 24 de julio de 2013

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)

jueves, 18 de julio de 2013

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.