Para transformar la versión Intrepid Ibex, tenes este otro link.

He encontrado un Post en el que de una manera muy detallada explicaban como tunear nuestro Hardy para que tome la apariencia de un Mac.

He de decir que el resultado me ha sorprendido, es realmente bueno, por lo que he decidido compartirlo con todos vosotros, en este post me limitare a traducir y resumir el tutorial original que se encuentra en ingles y que podeis encontrar en la pagina de Maketecheasier.

Antes de empezar descargaremos los archivos necesarios. Crearemos una carpeta llamada Mac_files en nuestro Home. Y descargaremos los siguientes ficheros.

• Modified Mac4Lin theme

• Mac4Lin icon set

• Mac4Lin wallpaper

• Avant Windows Manager elegant glass theme

Extraeremos el contenido de los archivos Modified Mac4Lin them y Mac4Lin wallpaper en el directorio Mac_files que hemos creado anteriormente.

Aplicar Mac OSX Leopard Theme

Ir a System->Preferencias->Apariencia

Pulsar sobre install y seleccionar el tema Mac4Lin GTK theme (~/Mac_files/Mac4Lin_V0.4/GTK Metacity Theme/Mac4Lin_GTK_v0.4.tar.gz).

De nuevo sobre instalar y seleccionar Mac4Lin icon theme (~/Mac_files/Mac4Lin_Icons_modified.tar.gz) y en la ventana que nos aparece pulsaremos sobre aplicar nuevo tema.

Pulsaremos en el boton Personalizar y elegiremos Mac4Lin_GTK_v0.4, ahora pulsaremos sobre la pestaña Borde de la ventana, y elegiremos Mac4Lin_GTK_v0.4 y cerraremos la ventana.

Ahora pulsaremos sobre la pestaña Fondo (en la parte de arriba de la ventana), pulsaremos sobre el boton añadir y seleccionaremos el siguiente archivo como wallpaper, por su puesto sois libres de cambiar esta imagen por cualquier otra.

~/Mac_files/Wallpapers/Leopard.jpg

Ya podemos cerrar la ventana.

Instalando el Dock (Avant Window Navigator)

Introduciremos los siguientes repositorios. Abrimos un terminal (Alt + F2 --> gnome-terminal)

sudo vim /etc/apt/sources.list

Y en el final del fichero añadiremos

#Avant Window Navigator LEOPARD
deb http://ppa.launchpad.net/awn-testing/ubuntu hardy main
deb-src http://ppa.launchpad.net/awn-testing/ubuntu hardy main

 Salvamos y cerramos. Ahora introduciremos lo siguiente.

sudo apt-get update
sudo apt-get install avant-window-navigator-trunk awn-manager-trunk awn-extras-applets-trunk

Ahora iremos al menú Sistema->Preferencias->AWN manager

A la izquierda, haremos click sobre Themes. Y a la derecha pulsaremos sobre el boton Añadir seleccionando el siguiente archivo.

~/Mac_files/Elegant_glass.tgz

Ahora marcamos la opción Elegant glass theme y pulsamos sobre aplicar.

Ahora en la parte izquierda pulsaremos sobre Applets, en el listado buscaremos stack Aplet, lo seleccionaremos y lo activaremos pulsando el boton Activate.

Ahora, antes de lanzar el Dock, eliminaremos el panel inferior del escritorio, para ello, pulsaremos con el boton derecho sobre una parte libre del panel y pulsaremos en borrar este panel. Ahora ya podemos iniciar el AWN (aplicaciones->Accesorios->Avant Window Navigator).

Instalando OSX Fonts.

Instalaremos “Microsoft core fonts”, para ello abriremos una consola y introduciremos lo siguiente.

Sudo aptitude install msttcorefonts

Ahora copiaremos las fuentes OSX en el directorio de fuentes.

cd /usr/share/fonts
sudo tar xvzf /home/username/Mac_files/Mac4Lin_v0.4/Fonts/OSX_Fonts.tar.gz

Procedemos a su configuración.

cd/
sudo tar xvjpf ~/Mac_files/Mac4Lin_v0.4/Fonts/fontconfig.tbz -C /etc/fonts

Ahora abrimos la ventana de apariencia Sistema->Preferencias->apariencia y seleccionamos la pestaña de Tipologias, Elegiremos los tipos de letra de acuerdo con la siguiente imagen y cerramos la ventana.

 

Cambiar el semáforo de la ventana(controles) a la izquierda.

Abrimos nuevamente un terminal y introducimos

gconf-editor

Que nos abrira el editor de configuración, en la estructura de la izquierda desplegaremos y seleccionaremos.

Apps->Metacity->general

En la derecha buscaremos button_layout, haremos doble click sobre el y cambiaremos su contenido por lo siguiente.

close,minimize,maximize:menu

Cambiar la barra del menú.

Borraremos todos los iconos de aplicaciones que pueda haber en la barra, pulsando sobre cada icono con el boton derecho y seleccionando “quitar del panel”. Nos quedara algo parecido a esto.

También borraremos el icono de terminar sesión que hay a la derecha de la barra. Ahora pulsaremos con el boton derecho sobre una parte libre de la barra (parte derecha) y seleccionaremos añadir al panel y en la lista seleccionaremos “Buscar Archivos” y pulsaremos sobre añadir. En el extremo izquierdo de la barra añadiremos también “Menu Principal”

Ahora instalaremos globalmenu. En la consola introduciremos lo siguiente (solo para 32bits).

cd ~/Mac_files
wget http://gnome2-globalmenu.googlecode.com/files/gnome-globalmenu-0.4-svn964.tar.gz
tar zxvf gnome-globalmenu-0.4-svn964.tar.gz
cd globalmenu
sudo dpkg -i *.deb

en caso de problemas probar con

sudo dpkg -i –force-overwrite *.deb

A mi me dio un problema de dependencias y algún que otro paquete roto, lo solucione entrando en el Gestor de Paquetes Synaptic, pulsando sobre filtros personalizados y sobre Roto, esto me mostró el paquete gnome2-globalmenu-applet, lo desinstalé y cerré la ventana y en la consola introduje.

sudo dpkg -i –force-overwrite *.deb

En caso de error el autor recomienda sudo apt-get install -f, el problema que yo tenia era que me pedía descargar prácticamente 150 Mb.

Una vez finalizado, pulsaremos con el boton derecho sobre el panel y seleccionaremos Añadir al panel, en la lista buscaremos Global Menu Applet y pulsaremos sobre añadir.

Es posible que este último paso no sea visible hasta que no reiniciemos. Si El menu que acabamos de instalar es de un color diferente al de la barra, pulsaremos con el boton derecho sobre una zona vacia del panel y seleccionaremos propiedades, en la pestaña de Fondo, seleccionaremos Imagen de fondo y pondremos la siguiente imagen.

~/.themes/Mack4Lin_GTK_v0.4/gtk-2.0/Panel

y seleccionaremos

panel-bg.png

Arrastrar el globalMenu hacia la izquierda, justo al lado del icono de la manzana, pulsar con el botón derecho sobre globalMenu y entrar en preferencias y dejarlo tal como indica la imagen.

Configurando la pantalla del login.

Clicamos sobre el icono de la manzana y sobre sistema->administracion->ventana de entrada, en la pestaña Local, hacemos clic en el boton Añadir, Navegamos hasta la ruta ~/Mac_files/Mac4Lin_v0.4/GDM Theme y seleccionamos el archivo Mac4Lin_GDM_v0.4.tar.gz. Pulsamos sobre instalar y seguidamente lo seleccionamos en la lista de temas.

Seleccionamos un color azul como color de fondo, así nuestro login screen nos quedará algo parecida a esta.

Configuración uplash screen.

Primero de todo instalaremos la aplicación.

Sudo aptitude install startupmanager

Entraremos en la aplicación ejecutando en consola sudo startupmanager o mediante los menús sistema->Administración->Start-Up Manager.

Pulsaremos sobre la pestaña aspecto y sobre el botón Administrar temas del Cargador de arranque, pulsaremos sobre añadir y seleccionaremos el siguiente archivo.

~/Mac_files/Mac4Lin_v0.4/GRUB Splash/appleblack.xpm.gz

marcamos el checkbox Usar una imagen de fondo.... y seleccionamos como imagen de fondo appleblack

Ahora pulsamos sobre el botón Administrar temas de Usplash, y añadimos el siguente

~/Mac_files/Mac4Lin_v0.4/USplash Theme/osx-splash.so

Lo seleccionamos y reiniciamos.

Creando el efecto Dashboard.

Instalaremos los Screenlets.

Sudo aptitude install screenlets compizconfig-settings-manager

En el menú Sistema->Preferencias->Configuracion avanzada de los efectos de escritorio en la izquierda pulsar sobre Escritorio y a la derecha sobre Widget layer.

Ahora iremos pulsaremos ALT+F2 y teclearemos screenlets. Pulsamos el botón derecho sobre widget y seleccionamos propiedades, ahora la pestaña opciones y seleccionamos Treat as widget, esto hay que hacerlo en cada widgets ue queramos activar.

Bueno y con esto ya hemos acabado. Os recuerdo que el articulo original lo podéis encontrar en

http://maketecheasier.com/turn-your-ubuntu-hardy-to-mac-osx-leopard/2008/07/23/

- - -

La inteligencia me persigue pero... yo soy más rapido.

A todos nos ha pasado que cuando escribimos con nuestro portatil, de golpe y porrazo como por arte de magia, el cursor salta ubicandose en otra linea, menudo mosqueo, nuestro dedo ha rozado el touchpad.

Si usamos Hardy Heron, podremos desactivarlo o activarlo a nuestro gusto mediante la ventana de preferencias del ratón (pestaña Touchpad) que encontraremos en el menu de ubuntu.

Sistema → preferencias → raton

Linux nos presenta una solución más elegante para este caso, el comando syndaemon, este comando desactiva el touchpad cada vez que pulsamos una tecla, volviéndose a activar el solito cuando dejamos de escribir.

Para poder usar syndaemon primero tenemos que activar SHMConfig, esto lo haremos dentro de la sección correspondiente al Touchpad, en el xorg.conf, tenemos que buscar algo parecido a esto:

Section "InputDevice"
Identifier "Synaptics Touchpad"
Driver "synaptics"

En la última línea de la sección, justo antes de EndSection, añadiremos lo siguiente.

Option “SHMConfig” “True”

Ahora solo nos queda reiniciar y ya podemos utilizar nuestro comando, si queremos ver como actúa, abrir una consola y teclear el comando syndaemon. Ahora abrir otra consola o cualquier documento y escribir lo que sea, podréis ver como se activa y se desactiva el touchpad cuando dejamos de escribir.

Para pararlo cerrar la consola o utilizar el comando ps -e | grep syndaemon y el comando kill.

El comando syndaemon tiene las siguientes opciones.

• -d: inicia el programa como demonio (background).

• -i: Número de segundos que esperará para activarse el touchpad después de la última pulsación, por defecto esta a 2 segundos.

• -t: solo desactiva el tap y el scroll.

• -k: ignora los modificadores de las teclas (tecla control, etc).

• -K: igula que -k pero a demas ignora las combinaciones de teclas (modificador + tecla), ejem. Control + a.

En definitiva, creo que lo más simple es pulsar ALT+F2 y introducir el siguiente comando.

syndaemon -d

Con esto el comando solo sera efectivo hasta que cerremos la sesión, después tendremos que volver a teclearlo. Para que este quede activo siempre tendremos que hacer que se ejecute cada vez que iniciemos sesión, esto lo realizaremos desde sesiones que accederemos mediante.

Sistema → preferencias → sesiones

Pulsaremos sobre añadir y introduciremos lo siguiente.

      Nombre: syndaemon

      Orden: syndaemon -d

      Comentario: desactiva touchpad al escribir

Aceptamos, cerramos y reiniciamos.

Antes de finalizar creo que también puede ser interesante el programa gsynaptics que encontraremos en los repositorios y que por lo tanto podremos instalar mediante aptitude. Se trata de un programa gráfico que nos permite configurar nuestro touchpad.

Hay que tener en cuenta que igual que con syndaemon hay que poner a true SHMConfig.

---

La inteligencia me persigue pero, ... yo soy más rápido.

 

Hoy os voy a mostrar un comando que posiblemente ya conozcáis, es uno de mis preferidos y con el me he pegado alguna que otra vacilada (no seáis mal pensados, es para motivarlos y que se interesen por este mundo, pensar que algunos de mis amigos creen que la informática es eso que ha creado windows para poder navegar por internet, INCREIBLE PERO CIERTO).

Bueno el comando en cuestión es tree y nos da una visión más o menos estructurada y jerárquica de los archivos y directorios de nuestro disco, lo mejor es que lo veamos, hoy no me quiero enrollar mucho.

La forma más básica es teclear el comando tree sin ninguna opción.

banyut@hades:~/Escritorio/dendrograma.bin$ tree
.
|-- dades.txt
|-- dades.txt~
|-- dendrograma.bat
|-- dendrograma.jar
|-- dendrograma.sh
|-- img
| |-- H_N.jpg
| |-- H_R.jpg
| |-- V_N.jpg
| |-- V_R.jpg
| |-- ico1.png
| `-- ico2.gif
|-- ini
| |-- English.l
| |-- English.l~
| |-- Idiomes.ods
| |-- catala.l
| |-- dendo.ini
| `-- spanish.l
`-- logs
|-- dendograma_log.xml
|-- dendograma_log.xml.1
`-- logger.dtd

3 directories, 20 files

Al introducir tree sin argumentos este nos devuelve toda la jerarquía de archivos y directorios a partir del directorio actual. Esto lo podemos cambiar, pudiendo indicar la ruta a partir de la cual queremos crear el árbol de directorios.

banyut@hades:~/Escritorio/dendrograma.bin$ tree /etc/thunderbird/
/etc/thunderbird/
|-- pref
| `-- thunderbird.js
`-- profile
|-- US
| |-- localstore.rdf
| `-- mimeTypes.rdf
|-- localstore.rdf
|-- mimeTypes.rdf
`-- prefs.js

3 directories, 6 files

Si queremos crear un árbol de nuestro sistema tendremos que teclear

tree /

Nos puede interesar listar solo los directorios.

banyut@hades:~/Escritorio/dendrograma.bin$ tree . -d
.
|-- img
|-- ini
`-- logs

3 directories

El punto indica que quiero listar el directorio actual, la instrucción anterior hubiera funcionado igual si lo hubiésemos omitido (tree -d).

Tree por defecto no muestra los archivos ocultos, si queremos que los muestre tendremos que añadir la opción -a.

banyut@hades:~/Escritorio/dendrograma.bin$ tree -a
.
|-- .oculto.txt
|-- dades.txt
|-- dades.txt~
|-- dendrograma.bat
|-- dendrograma.jar
|-- dendrograma.sh
|-- img
| |-- H_N.jpg

Si os fijáis, el primer archivo (.oculto.txt) no había salido en el listado anterior, la opció -a hace que nos lo muestre.

Otra opción que nos puede interesar mucho es que junto con el nombre de cada archivo se incluya la ruta completa. También dejaremos la opción de mostrar los ficheros ocultos para que veais como se pueden combinar dos o más opciones.

banyut@hades:~/Escritorio/dendrograma.bin$ tree -af
.
|-- ./.oculto.txt
|-- ./dades.txt
|-- ./dades.txt~
|-- ./dendrograma.bat
|-- ./dendrograma.jar
|-- ./dendrograma.sh
|-- ./img
| |-- ./img/H_N.jpg
| |-- ./img/H_R.jpg
| |-- ./img/V_N.jpg
| |-- ./img/V_R.jpg
| |-- ./img/ico1.png
| `-- ./img/ico2.gif
|-- ./ini
| |-- ./ini/English.l
| |-- ./ini/English.l~
| |-- ./ini/Idiomes.ods
| |-- ./ini/catala.l
| |-- ./ini/dendo.ini
| `-- ./ini/spanish.l
`-- ./logs
|-- ./logs/dendograma_log.xml
|-- ./logs/dendograma_log.xml.1
`-- ./logs/logger.dtd

3 directories, 21 files

Ahora quiero que me muestre el propietario o el UID del archivo (-u), el grupo o GID (-g) y el tamaño de cada archivo (-h).

banyut@hades:~/Escritorio/dendrograma.bin$ tree -ugh
.
|-- [banyut banyut 216] dades.txt
|-- [banyut banyut 0] dades.txt~
|-- [banyut banyut 26] dendrograma.bat
|-- [banyut banyut 197K] dendrograma.jar
|-- [banyut banyut 57] dendrograma.sh
|-- [banyut banyut 4.0K] img
| |-- [banyut banyut 19K] H_N.jpg
| |-- [banyut banyut 19K] H_R.jpg
| |-- [banyut banyut 19K] V_N.jpg
| |-- [banyut banyut 19K] V_R.jpg
| |-- [banyut banyut 1.6K] ico1.png
| `-- [banyut banyut 1.3K] ico2.gif
|-- [banyut banyut 4.0K] ini
| |-- [banyut banyut 1.5K] English.l
| |-- [banyut banyut 1.5K] English.l~
| |-- [banyut banyut 15K] Idiomes.ods
| |-- [banyut banyut 877] catala.l
| |-- [banyut banyut 2.7K] dendo.ini
| `-- [banyut banyut 1.8K] spanish.l
`-- [banyut banyut 4.0K] logs
|-- [banyut banyut 20K] dendograma_log.xml
|-- [banyut banyut 384] dendograma_log.xml.1
`-- [banyut banyut 2.3K] logger.dtd

3 directories, 20 files

Podemos quitar la tabulación con la opción (-i)

banyut@hades:~/Escritorio/dendrograma.bin$ tree -ughi
.
[banyut banyut 216] dades.txt
[banyut banyut 0] dades.txt~
[banyut banyut 26] dendrograma.bat
[banyut banyut 197K] dendrograma.jar
[banyut banyut 57] dendrograma.sh
[banyut banyut 4.0K] img
[banyut banyut 19K] H_N.jpg
[banyut banyut 19K] H_R.jpg
[banyut banyut 19K] V_N.jpg
[banyut banyut 19K] V_R.jpg

Para no hacerme muy pesado, aquí tenéis otras posibles opciones.

-l     Sigue los enlaces simbolicos.
-P patron lista solo los que coincidan con el patron.
-I  patron lista los que no coincidan con el patron.
-p   muestra el tipo de archivo y sus permisos.
-s   tamaño en bytes.
-D  muestra la fecha de la última modificación.
-r   ordena la salida alfabeticamente de forma descendente.
-t   ordena por ultima modificación.
--dirsfirst coloca los directorios antes que los ficheros.
-n   salida sin colores.
-C   activa el coloreado en la salida.
-L nivel Máximo nivell que mostraremos al crear el árbol.
-o file Envía la salida al fichero indicado

Bueno he dejado un par para comentar ya que creo que vale la pena. Tenemos la opción -A que nos dibuja las lineas (tabulaciones) del árbol de una forma más agradable.

monti@hades:~/Escritorio/dendrograma.bin$ tree -A
.
├── dades.txt
├── dades.txt~
├── dendrograma.bat
├── dendrograma.jar
├── dendrograma.sh
├── img
│ ├── H_N.jpg
│ ├── H_R.jpg
│ ├── V_N.jpg
│ ├── V_R.jpg
│ ├── ico1.png
│ └── ico2.gif
├── ini
│ ├── English.l
│ ├── English.l~
│ ├── Idiomes.ods
│ ├── catala.l
│ ├── dendo.ini
│ └── spanish.l
└── logs
├── dendograma_log.xml
├── dendograma_log.xml.1
└── logger.dtd

3 directories, 20 files

y ahora tenemos una que en un momento determinado nos puede ser de utilidad, la opción -H nos parsea la salida convirtiéndolo en código html, probarlo vale la pena ver la salida de este comando.

tree -H . -o mi_dir.html
firefox mi_dir.html

Con la opción (-T title), podemos poner un titulo a la pagina web, tambien tenemos la opción (--nolinks) que eliminará los links de la pagina web y por último podemos definir la codificación de caracteres que usará la pagina web. (--charset cod).

Si usamos las opciones P o I, tendremos que tener a nuestra disposición los siguientes operadores.

'*' sustituye ninguno o todos
'?' sustituye un unico carácter
'[...]' Cualquier carácter que se encuentre entre los corchetes ( los rangos se crearan con '-').
'[^...]' Cualquier carácter que no se encuentre entre los corchetes.
'|' es como un OR, separa diferentes patrones.

un ejemplo.

banyut@hades:~/Escritorio/dendrograma.bin$ tree -P *.jpg
.
|-- img
| |-- H_N.jpg
| |-- H_R.jpg
| |-- V_N.jpg
| `-- V_R.jpg
|-- ini
`-- logs

3 directories, 4 files

- - -
La inteligencia me persigue pero, ... yo soy más rápido.

Ya conocemos los tipos básicos con los que podemos trabajar, sabemos que son las variables y que operaciones podemos realizar con ellas cada variable y tipo. Esto es lo primero que hay que conocer cuando uno se enfrenta a un nuevo lenguaje de programación.

Lo siguiente que aprenderemos antes de introducirnos de lleno en las particularidades de python son las estructuras de control, gracias a ellas, nuestros programas podrán tomar decisiones, repetir fragmentos de código, etc.

En este apartado, veremos como el tipo booleano coge una especial importancia, ya que prácticamente todas las estructuras que veremos en este capitulo hacen uso de ellos para decidir el camino a seguir. Estas condiciones por muy complejas que sean, siempre tendrán que acabar en un verdadero o falso (0 o 1), si verdadero ejecutaremos un fragmento de código y si falso ejecutaremos otro.

La primera sentencia que veremos será if (podriamos traducirlo a Si) y es del tipo condicional. La sentencia if toma una decisión basándose en el resultado de verdadero o falso de una expresión.

La estructura básica es:

if expresion:

Linea_1

Linea_2

Linea_3

Cuando el flujo del progra llege al if, se valorara expresion en caso de que expresion sea verdadera, se ejecutaran las lineas de código Linea_1 y Linea_2 por último se procesará Linea_3. Si al contrario expresion es falso (false), se omitirá todo el bloque del if y el programa continuará en la siguiente sentencia, en nuestro caso Linea_3.

Veamos un ejemplo.

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

tip_num = "impar"

if (num % 2) == 0:

tip_num = "par"

print num, "es un numero", tip_num

bueno si no entendéis todo el código no os preocupéis, ahora nos centraremos solo en la sentencia if.

• La primera linea pide al usuario que introduzca un número y lo guarda en la variable num.

• La línea 2, declara y inicializa la variable tip_num con el valor de impar.

• La última muestra un mensage por pantalla.

No, no nos hemos olvidado de la línea 3, veamos la sintaxis del comando if era.

If expresion:

tip_num = “par”

En este mismo momento tip_num tiene el valor de impar, la sentencia si expresión es true, se ejecutara el código que contiene el bloque del if y canviará el valor de la variable tip_num, si por el contrario es false, el programa saltará todas las líneas de codigo que pertenecen al bloque if.

Como veis todo el jugo está en expresion, cuyo resultado tiene que ser un booleano (true/false). En nuestro ejemplo expresión es.

(num % 2) == 0

La primera parte de la expresión, es la operación módulo, si hacemos memòria lo que hacia era dividir un número por otro (en este ejemplo num / 2) y devolvía el resto de la división. Refrescando un poco las matemáticas, al dividir por dos, el resto de la división solo pude ser 0 o 1.

Por lo tanto, al comparar el resultado con 0 solo sera true cuando el resultado sea 0, lo que es lo mismo, cuando num sea par y es eso precisamente lo que queremos saber.

Si el num es par la expresión nos quedará: 0 == 0 (true)

Si num es impar obtendremos: 1 == 0 (false)

Un rollo ya lo sé, y tal vez un pelín complicado para un primer ejemplo, pero es importante que entendáis que en este capitulo cuando hablemos de expresión, sepáis que nos estamos refiriendo a una combinación de operaciones dentro de una misma instrucción cuyo resultado siempre será un booleano (true o false).

If : else.

La utilidad de la sentencia if que hemos visto en el apartado anterior dejaba mucho que desear, ya que lo único que nos permitía era ejecutar una parte del código o no. La potencia de if, es que nos permite elegir entre dos caminos diferentes según el resultado de expresion.

If expresion:

si_cierto_esto

else:

si_falso_esto

 

Ahora podríamos reescribir nuestro ejemplo anterior de esta forma.

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

if (num % 2) == 0:

tip_num = "par"

else

tip_num = "impar"

print num, "es un numero", tip_num

Aunque en el ejemplo no se vea, la diferencia de código es importantísima.

If : elif: else

Imaginaros que a demás de saber si un número es par o impar, quiero distinguir entre pares grandes y pares pequeños.

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

 

if (num % 2) == 0:

if num > 100:

tip_num = "par Grande"

else:

tip_num = "par pequeño"

else

tip_num = "impar"

print num, "es un numero", tip_num

De esta forma podríamos anidar tantos if como queramos, el problema es que el código cada vez se hace más difícil. En estos casos tenemos los if anidados cuya sintaxis es:

If expresion:

si_cierto_esto

elif expresion:

si_cierto_esto

elif expresion:

si_cierto_esto

elif expresion:

si_cierto_esto

.

.

.

si_cierto_esto

else:

si_falso_esto

Como en los casos anteriores el último else es opcional. Podemos poner tantos elif como queramos, las distintas ramificaciones del bloque, se procesan por orden y de manera secuencial, valorará expresión por expresión, empezando por la primera hasta encontrar una que sea verdadera, en ese momento ejecutara el modulo de código de rama correspondiente y cuando lo finalice saldrá del bloque if, sin valorar ninguna expresión más.

Esto quiere decir que en el bloque if pueden haber más de una instrucción cierta, pero el programa solo ejecutará la primera que encuentre. Veámoslo con un ejemplo, continuamos con nuestro código y lo adaptamos a los nuevos conocimientos adquiridos.

 

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

if (num % 2) == 0:

tip_num = "par pequeño"

elif (num % 2) == 0 and num > 100:

tip_num = "par Grande"

else

tip_num = "impar"

print num, "es un numero", tip_num

Este código presenta un problema, sabéis cual? Pues si, el programa nunca encontraría un par grande, ya que la primera expresión será siempre cierta para todos los número pares, por lo que la siguiente expresión nunca se evaluaria.

Un código más correcto podría ser este.

# [dice si un numero es par o impar]

num = int(raw_input('Introduce un numero: '))

if (num % 2) != 0:

tip_num = "impar"

elif num > 100:

tip_num = "par Grande"

else

tip_num = "par pequeño"

print num, "es un numero", tip_num

Esto se podía haber hecho de muchas formas diferentes, prueba tu ha hacerlo aplicando otras condiciones.

Hay un caso que se da muy a menudo y que se venia resolviendo con if. Son los casos en los que teníamos que asignar un valor A o B dependiendo de que una expresión sea cierta o no.

if expresion:

x = A

else:

x = B

En estos casos tenemos una alternativa.

X = si_cierto if expresion else si_falso

Con esto, el código anterior nos quedaría.

X = A if expresion else B

 

donde X seria igual a A si expresion = true.

X seria igual a B si expresion = false.

La sentencia while (mientras).

Esta instrucción repite todo su bloque de código mientras la expresión evaluada sea cierta.

While expresion:

hago

hago

hago

un ejemplo sencillito.

# [cuenta de 1 a 10]

num = 1

while num <= 10:

print num

num += 1

 

# Mientras num sea menor o igual que 10 se repetirá el codigo.

El funcionamiento es simple, el programa evalúa la expresión, si esta es cierta, ejecuta el código del bloque, cuando acaba vuelve a evaluar la expresión, si es cierta ejecuta nuevamente el código, así hasta que expresión devuelva false, en cuyo caso, se ejecutará la siguiente línea de código existente después del bloque while.

Si os ha quedado alguna duda, este nuevo ejemplo os las aclarará.

# [adivina un numero]

import random

num_pensado = random.randint(1, 10)

num_elegido = int(raw_input('Adivina que numero he pensado del 1 al 10: '))

veces = 0

while num_pensado != num_elegido:

num_elegido = int(raw_input('Fallaste!!! vuelvelo a intentar: '))

veces += 1

print "has acertado en ", veces, "intentos"

He colado alguna cosa que igual no sabeis aún que es lo que hace, ya lo veremos todo más adelante, ahora centraros solo en el bucle while y en su expresion.

Los bucles son uno de los principales problemas de cuelges en las aplicaciones, no es difícil entrar en un bucle en la cual su expresion siempre sea falsa.

# [Bucle infinito]

num = 1

while num <= 10:

print num

print “FIN”

En este caso se trata de un accidente, pero hay veces en el que nos puede interesar crear un bucle infinito.

# [hasta el infinito y mas alla]

while 1 == 1:

hago_algo

Igual que en el caso del if, while tambíen nos ofrece la posibilidad de modificar el flujo del programa.

while expresion:

hago_algo

if expresion: break #salgo de while

if expresion: continue #salto al inicio del while

hago_algo

else:

aveces_lo_hago

Veamos un ejemplos.

# [numero primo]

y = int ( raw_input("Introduce un numero: "))

x = y / 2

while x > 1:

if y % x == 0:

print y, 'es divisible por ', x

break

x = x - 1

else:

print y, 'es primo'

Si ejecutáis el código veréis que la instrucción else se ejecutará siempre y cuando finalizamos el bucle while de forma natural, osea cuando su expresión es false, si por el contrario salimos de while, mediante la instrucción break, el codigo que contiene el bloque else no será ejecutado.

Si dentro de un bucle se ejecuta la instrucción continue, saltaremos al inicio del bucle, ignorando todo el código restante que pudiese quedar, volviendo a evaluar la expresión del while y en caso de ser cierta, continuaríamos en la primera linea del bloque.

No se aconseja el uso de las instrucciones break y continue, aunque en un principio pueda parecer atractiva la idea, el uso de ellas crea programas difíciles de seguir.

For – in

Explicar esta instrucción sin haber explicado las listas es un poco difícil. Podríamos decir que lo que hace es recorrer una secuencia independientemente del tipo de datos, en definitiva se puede utilizar para cualquier objeto sobre los que podemos acceder a sus elementos de manera indexada.

Haremos una pequeña introducción y lo dejaremos hasta el siguiente capitulo donde explicaremos las listas.

La sintaxis.

For elemento in objeto:

. . .

else:

. . .

Igual que en while, podemos modificar el flujo del bucle con continue o break.

For x in ['paco', 'juan', 'antonio']:

print x

# [sumatorio]

sum = 0

for x in [1, 3, 4 ,5]:

sum + = x

print x

El primer for, repite 3 veces el código de su bloque (print x), en la primera interacción, x coge el valor de paco, en la segunda de juan y por último de antonio.

Por último un par de ejemplos más.

T = [(2, 1), (3, 1), (7, 2)]

for (x, y) in T:

print x, y

 

for i in range(10):

print i

Bueno, lo dicho en el siguiente capitulo veremos las listas y podremos explicar un poco mejor este ultimo bucle.

- - -

abre tu mente 1 + 1 = 10    (no siempre es dos)

Bueno, a pesar de las múltiples ventajas que presenta atpitude respecto a apt-get, aún se sigue viendo de una forma abrumadora el uso de apt-get, la fuerza de la costumbre supongo. En esta entrada miraré de aclarar las ventajas de aptitude respecto a apt-get.

Lo primero dejar claro que tanto apt-get como aptitude usan los mismos repositorios (/etc/apt/sources.list) y los comandos básicos son muy similares (install, upgrade, etc), aunque no todos se comportan exactamente de la misma manera.

La principal ventaja de aptitude respecto a apt-get, la encontramos a la hora de desinstalar los paquetes, en principio apt-get identifica las dependencias que un programa necesita a la hora de instalarlo, pero no hace lo mismo a la hora de desinstalarlo, dejando un rastro de paquetes huérfanos de los que no se preocupa de desinstalar, (problema que creo que esta en proceso de solución).

De todas formas tampoco supone un grave problema pues mediante apt-get autoremove, podremos desinstalar todos los paquetes huerfanos que la opcion remove de apt-get ha dejado en el sistema.

Aptitude, ofrece prácticamente las mismas opciones que apt-get, es más, ofrece prácticamente todas las opciones del paquete apt compuesto por cerca de una veintena de herramientas, agrupándolas todas bajo un único comando al más puro estilo de una navaja suiza.

A la hora de buscar un paquete, apt-get tiende a devolver muchos más resultados que aptitude, esto es debido a que aptitude solo busca por el nombre del paquete (para mi es el comportamiento deseado) mientras que apt creo recordar que también lo hacia por contenido.

Esto tiene sus ventajas y sus inconvenientes, muchas veces tenemos que usar pipes para filtrar y poder entender los ilegibles resultados de apt. Sin embargo los resultados de aptitude nos vienen ordenados y justificados cosa que es muy de agradecer.

Además aptitude, no solo muestra las dependencias de los programas, también nos ofrece una lista de paquetes recomendados, los cuales puede resultar interesante de instalar.

También permite tener varias distribuciones en /etc/apt/sources.list, de manera que al actualizar el sistema podamos elegir la distribución sobre la que queramos el paquete. Esto lo haremos mediante la opción -t <release>.

Otra cosa que es muy de agradecer es el log que aptitude crea en /var/log/aptitude, el cual viene de perlas a la hora de revisar lo instalado.

Podría seguir comparando ambos, pero lo reconozco soy un seguidor de aptitude y creo que usar apt-get es ir en contra corriente, aptitude es la evolución natural de apt.

Ejecutando aptitude sin argumentos, entraremos en la interfaz de aptitude que nos permite realizar prácticamente todas las acciones (búsqueda, instalación, actualización, administración de paquetes, etc). En la pagina de esDebian, hay un fantástico tutorial sobre aptitude en general y en el que dedican gran parte a describir la interfaz gráfica, lo teneis aquí Tutorial de Aptitude.

La sintaxis del comando es

aptitude [opciones] <acción>  paquetes

Las opciones son:

-D : Muestra las dependencias de los paquetes cambiados automáticamente.
-d: Descarga los paquetes (/var/cache/apt/archives)pero no los instala ni los borra
-F <formato>: Especifica el formato en el que se mostraran los resultados.
-f: fija las posibles dependencias rotas.
-s: simula las acciones, pero no las realiza. Esta opción no necesita privilegios de root.
-t <distribución>: Establece la distribución desde la que instalaremos los paquetes.

sudo aptitude -t experimental ...

-O <orden>: Especifica el orden en el que se mostraran los resultados de la busqueda.
-q: no muestra los indicadores de progreso.
-V: muestra las versiones de los paquetes que serán instalados.
-v: verbose, información extra.
-w <ancho>: ancho de la pantalla que sera usado para mostrar la salida del programa.
-y: responde yes a todas las preguntas de si/no.
-Z: Muestra el espacio en disco usado o liberado de cada paquete individual al instalar, actualizar o desinstalar.
-u: actualiza la lista de paquetes al iniciar el programa.

Dónde las acciones pueden ser.

install: instala el paquete o paquetes y todas sus dependencias. Si en el nombre del paquete aparece una tilde o un signo de interrogación (~, ?), estos serán tratados como un patrón de búsqueda y instalará todos los paquetes que lo cumplan.

Si se quiere instalar una versión en concreto de un paquete pondremos el nombre del paquete seguido del signo igual y la versión deseada.

Sudo atpitude install vim=7.1-138

remove: Elimina el paquete y todas las dependencias que queden huerfanas.

reinstall: descarga y reinstala un paquete.

purge: Elimina el paquete, todas las dependencias que queden huerfanas y sus ficheros de configuración.

hold: Bloquea un paquete, cancelando cualquier actividad sobre él (instalación, actualización o borrado), en definitiva, previene futuras actualizaciones.

unhold: desbloquea un paquete.

markauto: marca los paquetes como instalados manualmente.

unmarkauto: hace la operación inversa a markauto, desmarcando los paquetes.

forbid-version: impide que se actualice el paquete a una versión determinada.

update: Descarga las listas de paquetes nuevos i/o actualizables.

safe-upgrade: realiza una actualización segura, actualiza o instala los paquetes a la versión más reciente, pero no borra ninguno, esta opción puede traer problemas en algunas instalaciónes donde es necesario desinstalar un paquete para poder instalar otro.

full-upgrade: Actualiza los paquetes a la versión más reciente, borrando o instalando lo que sea necesario, soluciona el problema de safe-upgrade.

forget-new: elimina la información interna que identifica que paquetes son nuevos.

search: busca un paquete, también podemos aplicar un patrón.

Sudo aptitude search '~' vim

show: Nos da información sobre un paquete.

clean: Elimina los archivos descargados en la instalación de paquetes.

autoclean: Elimina los archivos de descargas obsoletos.

why, why-not: Nos informa porque un paquete puede o no puede instalarse en nuestro sistema, why busca las dependencias de un paquete y why-not identifica los conflictos.

changelog: descarga y muestra el registro de cambios del paquete.

download: una muy interesante opción, descarga los deb del paquete, igual que con install podemos seleccionar una versión particular del paquete.

- - -

Hay 10 tipos de personas, los que saben binario y los que no.

Son muchas las situaciones en las que nos pueda interesa poder acceder a nuestro equipo a través de internet, bien sea un servidor web, ftp, acceso remoto, etc.

Para cualquiera de los usos que le queramos dar, siempre nos hará falta conocer la IP pública de nuestra máquina, es aquí donde empieza el problema, en la mayoría de los casos, el proveedor de internet por defecto nos proporciona una ip dinámica, salvo previo pago claro esta, en ese caso dispondremos de una preciosa ip fija.

El problema de la ip dinámica, es que esta cambia, perdiendo así la conexión con nuestro equipo. Para este pequeño problemilla, disponemos de una sencilla solución, se trata de utilizar DNS (Domain Name System), Que es DNS?? para no enrollarme y hacerlo entendible hasta para mi sobrina de 7 años, lo reduciré al extremo de decir que simplemente es un nombre que sustituye a una dirección IP.

IP: 216.239.59.103 DNS: www.google.es

En definitiva, para ir a la pagina del google, podemos poner en nuestro explorador tanto la IP como el DNS, ala que a gusto me he quedado y perdonar los más puristas.

Hay compañías que nos ofrecen servicios de redirección de manera gratuita, entre otras tenemos NOIP, DYNDNS, etc. Estas compañías nos ofrecen la posibilidad de referirnos a nuestro equipo no a través de la IP, sino mediante un nombre, vamos algo parecido a lo que hemos visto antes sobre la dirección del google.

El proceso es simple, darnos de alta es tan fácil como acceder a una de estas compañías, para nuestro ejemplo utilizaremos dyndns www.dyndns.com y darnos de alta en ella.

Bien ya hemos ganado algo, ahora cada vez que cambie nuestra ip ya no tendremos que avisar a todo el mundo de que nuestra ip ha cambiado, simplemente tendremos que ir a esta pagina y actualizarla con nuestra nueva ip.

Bueno, esto se puede mejorar aún más, en los repositorios tenemos el programa ddclient, este actualiza por nosotros la dirección IP de manera automática cada vez que esta cambia.

Sudo aptitude install ddclient

Cuando finalize la instalación editaremos o crearemos el siguiente fichero dejándolo tal como se indica a continuación.

Sudo vim /etc/ddclient.conf

# Configuration file for ddclient generated by debconf

#

# /etc/ddclient.conf

pid=/var/run/ddclient.pid

protocol=dyndns2

use=if, if=eth1

server=members.dyndns.org

use=web, web=checkip.dyndns.org

login=banyut

password='bbsinsed'

banyut.homeip.net

Que hay que tener en cuenta.

En la linea use=if, if=eth1 , “eth1” lo tenéis que cambiar por lo que corresponda a vuestra configuración, posiblemente en vuestro caso sea eth0, si dudáis comprobarlo mediante el comando ifconfig

Las tres ultimas lineas las tenéis que adaptar a vuestra configuración particular, en login tendréis que poner el nombre de la cuenta que habéis dado de alta. En la segunda el password, este tiene que ir entre comillas simples, en mi caso es bbsinsed, y por último la tercera linea, en ella tenéis que poner la dirección de vuestro equipo, la que habéis seleccionado al daros de alta en el servicio DNS.

Y eso es todo, solo un par de cosas más, si estáis detrás de un router, tendréis que redirigir los puertos correspondientes para que el servicio funcione. De igual manera hay muchos routers que implementan la funcionalidad que ofrece ddclient, en ese caso es mejor que configuréis la opción del router.

- - -

En la caja ponía Windows XP o superior, por eso instalé ubuntu.

Ya hemos utilizado variables en el articulo anterior, su uso es simple y no dista mucho de cualquier otro lenguaje de programación.

Las variables son útiles para poder guardar información que más tarde necesitaremos. En ellas se puede guardar prácticamente cualquier cosa (números, caracteres, strings, listas, conjuntos, etc).

En python no hace falta declarar explícitamente las variables antes de su uso, estas se crean en el momento en el que les asignamos un valor y se destruyen automáticamente al salir de su ámbito (En este punto explicar que es el ámbito de las variables sin hacer mención a cosas que aún no conocemos se me hace difícil, así que lo dejaremos para los capítulos siguientes, de todas formas y para hacer boca, hablamos de ámbito para indicar el espacio en el que la variable es visible o dicho de otra forma, se puede utilizar, no os preocupéis es algo que ya veremos).

Al asignarle un valor a una variable, esta automáticamente coge el valor y el tipo del dato que le hayamos pasado. Esto es lo que se conoce como “tipado dinamico”

banyut@hades:~$ python

Python 2.5.2 (r252:60911, Apr 21 2008, 11:12:42)

[GCC 4.2.3 (Ubuntu 4.2.3-2ubuntu7)] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>> a=3

>>> type(a)

<type 'int'>

>>> a=3.0

>>> type(a)

<type 'float'>

>>> a='c'

>>> type(a)

<type 'str'>

Después de la última asignación de la variable a, esta es del tipo carácter, por lo que la variable solo puede operar con los operadores aritméticos que le corresponden, tal y como vimos en el capitulo anterior.

>>> a = a + 1

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: cannot concatenate 'str' and 'int' objects

>>> a= a + '1'

>>> print a

'c1'

A tener muy en cuenta es que en python no se permite hacer referencia a una variable a la que nunca se le haya asignado un valor.

>>> print b

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

NameError: name 'b' is not defined

>>> b="ya tengo valor"

>>> print b

ya tengo valor

A todos nos tiene que haber quedado claro que el operador de asignación es el signo '=' que no hay que confundir con '=='.

El nombre de una variable, ha de empezar por una letra o por el carácter guión bajo, seguido de letras, números o guiones bajos, teniendo en cuenta que solo se permiten los caracteres del alfabeto inglés, así que olvidaros de la 'ñ' o la 'ç'. De igual manera, tampoco se puede usar como variables ninguna de las siguientes 31 palabras que python tiene reservadas.

And del from not while as elif

global or with assert else if pass

yield break except import print class exec

in raise continue finally is return def

for lambda try

Phyton distingue entre mayúsculas y minúsculas, así la variable 'A' es diferente de la variable 'a'.

>>> nom="Juan"

>>> Nom="Pedro"

>>> print nom, Nom

Juan Pedro

Ya hemos visto que la asignación de una variable se realiza mediante el signo igual '='.

>>> nombre = "pepe"

>>> un_vector = (3,5,6)

>>> una_lista = [3,5,6]

>>> dias_semana = ['Lunes', 'Martes', 'Miercoles', 'Jueves', 'Viernes']

>>> un_entero = 3

>>> un_float = 3.0

>>> un_complejo = 3 + 4j

>>> otro_float = un_entero + un_float

>>> un_boolean = True

>>> otro_boolean = un_boolean == False

Si no tenéis mucha experiencia en programación puede que la última asignación os desoriente un poco, pero no os preocupéis mucho, dentro de poco veréis como la entendéis a la perfección.

Vemos que a una variable le podemos asignar.

• Un valor a = 3

• El valor de otra variable b = a, ahora b = 3

• El resultado de una operación c = 3 + 2, ahora c = 5.

Python nos permite asignaciones múltiples.

>>> ciudad = municipio = "Tarragona"

>>> ciudad

'Tarragona'

>>> municipio

'Tarragona'

A la variable ciudad y a la variable municipio, les asignamos la cadena “Tarragona”. Tambien podemos asignar valores diferentes en las asignaciones múltiples.

>>> anyo, mes, dia, hermanos = 1966, "decembre", 13, ["Juan","Roser","Maria"]

La primera variable (anyo), cogerá el primer valor (1966), la segunda variable el segundo valor, etc.

Veamos otra posibilidad, crearemos un vector al que le asignaremos los números del 1 al 5.

>>> v = (1, 2, 3, 4 5)

>>> v

(1, 2, 3, 4 5)

Ahora cada uno de esos valores los asignaremos a una variable diferente.

>>> lunes, martes, miercoles, jueves, viernes = v

Lunes coge el valor de 1, martes 2, miercoles 3, etc. Otra manera de hacerlo.

>>> v = range(1,6)

>>> v

[1, 2, 3, 4, 5]

>>> lunes, martes, miercoles, jueves, viernes = v

>>> jueves

4

>>>

Este tipo de asignaciones es especialmente útil cuando necesitamos que una función nos devuelva más de un resultado (función?? ya lo veremos más adelante). En este punto también se ha introducido la función range(), de momento lo único que hemos de saber es que esta función nos devuelve una lista de enteros que puede variar según los parámetros que le pasemos, en su forma más sencilla se le pasara un único parámetro que sera su limite superior, devolviendo una lista ordenada que ira de 0 a limite-1.

En el capitulo pasado vimos las operaciones aritméticas, en este hemos dicho que el resultado de una operación se puede asignar a una variable, veamos como se realiza todo esto.

>>> a = 1

>>> a = a + 1

>>> a

2

>>> a += 1

>>> a

3

Las lineas 2 y 5 realizan la misma operación. El operador de la linea 5 '+=' se utiliza cuando operamos sobre la misma variable a la que vamos a asignar, es lo mismo que decir a la variable a le sumamos 1. Este tipo de operación se puede realizar con prácticamente todos los operadores aritméticos.

>>> a = 2

>>> a *= 10

>>> a /= 2

>>> a **= a

>>> a

10000000000L

Nos tiene que quedar claro cual es el tipo de devolverá la operación que realicemos, si es una comparación nos devolverá, True o False, si la operación es con cadenas de texto posiblemente nos devuelva una cadena de texto, etc. Así que a la hora de asignar a una variable el resultado de una operación hemos de tener en cuenta que tipo de dato devolverá.

>>> nombre = "Juan"

>>> mida = len(nombre)

>>> nombre_largo = mida > 6

>>> nombre

'Juan'

>>> mida

4

>>> nombre_largo

False

En ocasiones la asignación de una variable, sobre todo si se trata de listas o tuplas, puede ocasionar una sentencia tan larga que nos sea difícil de leer, en este caso podemos dividir la asignación en varias lineas, esto se consigue añadiendo al final de la linea el carácter '\'.

>>> meses = ['enero', 'febrero', 'marzo', \

... 'abril', 'mayo', 'junio', \

... 'julio', 'agosto', 'setiembre', \

... 'octubre', 'noviembre', 'diciembre']

>>> meses[3]

'abril'

>>> meses[10]

'noviembre'

>>>

Algunas Recomendaciones.

Dejaremos siempre un espacio a cada lado de:

• Asignación: a = a + 1

• Asignación aumentada (+=, *=, -=, etc): a += 1

• Comparaciones (==, <, >, !=, <=, >=, not, in, not in, etc): a == 3

• Operadores aritméticos: c = (a + b) * (c + d)

 

Hoy he tendido que reinstalar mi equipo, el caso es que instalé la máquina virtual de java , jdk de sun en su última versión, probé los programas que utilizan java y todos iban a las mil maravillas.

Luego instalé eclipse desde los repositorios y cual fue mi sorpresa al ver que algunos de los programas habían dejado de funcionar. El problema estaba en que la instalación de eclipse había cambiado la maquina virtual del sistema por la que el paquete trae.

El problema tiene fácil solución, si se sabe claro, recuerdo lo que me costo encontrarla en su día, cuando el programa azureus dejo de funcionar por un tema parecido. Este es el motivo por el que me he decidido a publicar este comando.

En definitiva se trata del comando update-java-alternatives y lo que hace es elegir la maquina virtual de java que el sistema utilizará por defecto.

En la consola escribiremos el siguiente comando.

update-java-alternatives -l

Obtendremos algo parecido a esto.

banyut@hades:~$ update-java-alternatives -l
java-1.5.0-sun 53 /usr/lib/jvm/java-1.5.0-sun
java-6-openjdk 1061 /usr/lib/jvm/java-6-openjdk
java-6-sun 63 /usr/lib/jvm/java-6-sun
java-gcj 1042 /usr/lib/jvm/java-gcj

Este comando nos muestra las posibles maquinas a utilizar, para asignar-la solo tenemos que poner el nombre de esta, en mi caso me quedare con la que muestra en la tercera fila, para ello teclearemos lo siguiente.

sudo update-java-alternatives -s java-6-sun

El comando tiene más opciones que podéis consultar en la documentación mediante el comando man.

man update-java-alternatives

---
abre tu mente 1 + 1 = 10 no siempre es 2.