Mostrando las entradas con la etiqueta Software Libre. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Software Libre. Mostrar todas las entradas

domingo, 8 de agosto de 2010

Framework de WebSockets: websockets4j

Este fin de semana he estado trabajando duro en un framework para WebSockets que sea conectable a Glassfish 3 y Tomcat 7. Aunque no es solamente conectable a eso, sino que mientras el servidor tenga permitida la creación de hilos y levantar ServerSockets, esto va a andar. El framework es open source con licencia Apache 2, bien permisiva!!.

El framework puede ser descargado de: http://websockets4j.googlecode.com y tiene como interesante que soporta la versión 75 y 76 del borrador del estándar de WebSockets, trataré de irlo actualizando a medida que los browsers vayan soportando versiones nuevas del estándar. Por ahora Google Chrome soporta la versión 75 y Safari 5 la versión 76.
Les dejo acá un videito de una aplicación de chat de ejemplo que hice para demostrar el funcionamiento del framework. Está en inglés porque pertenece al sitio de mi proyecto.
Dicen.. que se puede ver en hd.




Un dato curioso es que el framework no está hecho para funcionar con servlets incluso cuando el handshaking del protocolo es parecido a una solicitud http, bien, la especificación de servlets dice claramente que los servlets son para protocolos de solicitud y respuesta, como el HTTP, pero los websockets se comportan de forma muy distinta. Espero que le sirva a alguno, y pronto estaré trabajando en agregarle soporte para TLS.

Saludos!!

viernes, 6 de agosto de 2010

Encuesta de Sistemas Operativos

Hace tiempo ya cerró la encuesta de sistemas operativos que hice en el blog, realmente los resultados no fueron tan sorprendentes salvo porque la mayoría utilizaba linux, lo cual no es tan raro ya que la mayoría de mis amigos usan linux. De todas formas, es un mensaje de esperanza de que algún día, se dejen de usar los productos de microsoft.

Les dejo acá la imágen.

Saludos!

viernes, 15 de enero de 2010

Google Guice, breve reseña.

Google Guice es un framework para inyección de dependencias. Cuando nos encontramos frente al desarrollo de aplicaciones grandes (o al menos potencialmente grandes) en las que distintos equipos de desarrolladores codifican distintos módulos de una misma aplicación es el caso donde se presenta como obvia la necesidad de un bajo acoplamiento entre dichos módulos. Normalmente se presenta la necesidad de realizar tests automatizados de una o mas clases, o colaboraciones y dicho código posiblemente dependa de código de otro módulo que ni siquiera se encuentre desarrollado, o que resulte extremadamente costoso en tiempo o en recursos realizar dichos test. Aquí es cuando entra en juego la inyección de dependencias. No pretendo en este post explicar la inyección de dependencias en sí, para mayor información sobre ésta ver el siguiente enlace.

Goolge Guice es un excelente framework, el cual implementa el standard JSR 330 para la inyección de dependencias. Posee entre otras las siguientes características:
  • Inyección de dependencias en constructor.
  • Inyección de dependencias utilizando setters.
  • Inyección de dependencias directamente en los atributos de la clase.
  • Intercepción de métodos con filtro por anotaciones (especialmente útil para AOP).
  • Configuración programática de los módulos de la aplicación.
  • Definición de Fabricas (proveedores) y ámbitos para las instancias inyectadas.
  • Otras.
Gracias a estas características, estre framework resulta especialmente útil, algunos de los beneficios de utilizarlo son:
  • Generalización de aspectos en las aplicaciones y su consiguiente reducción de errores.
  • Escribimos código mas mantenible.
  • Escribimos código mejor testeable.
  • Escribimos código mucho más reutilizable.
En el siguiente ejemplo demostramos el uso de Google Guice para el módulo de recordatorio de cumpleaños en el appspot de este blog.

Primero demostraré un framgento de la clase encargada de la lógica de negocio de esta pequeña aplicación:
@Singleton
public class BirthDateManager {

private EntityManager em;

@Inject
public BirthDateManager(EntityManager em) {
this.em = em;
}
...
}


Podemos observar 3 cosas:
  1. Utilizamos el annotation @Singleton para indicarle al inyector que esta clase deberá instanciarla una única vez.
  2. Definimos el constructor que recibe las dependencias de esta clase de reglas de negocio de acuerdo con el patrón inyección de dependencias.
  3. Con la annotation @Inject le indicamos al inyector que debe inyectar dependencias.
Ahora observamos la clase que define el módulo donde configuraremos el inyector:

public class BirthDateModule extends AbstractModule {

@Override
protected void configure() {
bind(EntityManager.class).toProvider(PersistenceFacade.class);
}

}


Con esta simple línea le indicamos al inyector que debe obtener la dependencia de un proveedor, en este caso una fachada de persistencia. A continuación el código interesante de dicha fachada:

public class PersistenceFacade implements Provider<EntityManager> {

@Override
public EntityManager get() {
return emf.createEntityManager();
}
...
}

Vemos que nuestra clase proveedora deberá implementar la interfaz Provider para que Guice sepa cual es el método que nos provee la dependencia.

Finalmente vemos el código que pone todo junto. Obtenemos la clase de las reglas del negocio con las dependencias ya satisfechas a través de un inyector:

        Injector in = Guice.createInjector(new BirthDateModule());
BirthDateManager bdm = in.getInstance(BirthDateManager.class);



Como se puede ver resulta bastante simple:creamos un inyector a partir del módulo y luego le pedimos la clase de reglas del negocio a dicho inyector. Toda la magia ocurre en estas 2 líneas.

Con eso concluyo esta breve demostración de Google Guice. Espero que sea de utilidad.

Saludos!

miércoles, 16 de diciembre de 2009

Videos KDE 4.4

Dejo acá unos videos que demuestran algunas de las características nuevas de Kde 4.4, realmente va a estar muuuuuy bueno.

Saludos!

viernes, 13 de noviembre de 2009

Modem 3g Claro en Linux

Hace un tiempo experimenté con sorpresa que al enchufar el modem claro 3g huawei en mi notebook con ArchLinux, networkmanager me lo reconoció sin problemas.
Al tratar de conectarme me solicitó los siguientes datos:
  • Nro de teléfono: *99#
  • usuario: ctigprs
  • clave: ctigprs
  • APN: internet.ctimovil.com.ar
Bien, con esto logré conectarme pero internet no andaba ni para atrás ni para adelante.

Al mirar mi archivo /etc/resolv.conf vi lo siguiente:

nameserver 4.3.2.1
nameserver 4.3.2.1

#(también podría haber sido 1.2.3.4, no lo recuerdo.)

Esto evidentemente está mal por lo cual luego de un poco de investigación descubrí que los dns eran los siguientes:

#/etc/resolv.conf

nameserver 170.51.255.100
nameserver 170.51.255.167

Bien, en un principio pensé que eso resolvería mi problema de conexión pero no. Al escribir el comando 'route' noté que el dhcp tampoco me entregó bien la puerta de enlace. Inspeccionando un poco vi también que si bien tenía una dirección ip (proporcionada por la negociación ppp), la máscara de red era 255.255.255.255. Teniendo esa máscara resulta obvio que no podría conectarme a ninguna pc en esa red que no sea la mía. Inspeccionando la configuración que entregaba el mismo módem en windows vi que la puerta de enlace en efecto era la misma ip que nos entregó la necociación ppp.

Por lo cual, con el comando route, y suponiendo que mi ip es: 186.122.192.127


# route add default gw 186.122.192.127

Una vez corregido esto, pude navegar perfectamente con el modemcito.

Les dejo acá un snapshot de como se vería la configuración parael modem en knetworkmanager.



Saludos!

miércoles, 28 de octubre de 2009

Procesamiento de Texto Eficiente

Muchas personas cuando realizan procesamiento de textos tienden a dar formato a medida que van escribiendo, terminan la idea, establecen fuentes, tamaños y colores a los elementos del documento. Ésta idea si bien es intuitiva, genera luego muchas "desprolijidades" en el documento, algunas perceptibles y otras no, ésto trae otras consecuencias como por ejemplo las siguientes:

  • Se vuelve muy difícil la actualización eficiente y veloz del formato del documento.
  • Cambiar partes del texto a menudo requiere lidiar con las "mañas" del formato.
  • Resulta complejo utilizar herramientas útiles como la generación automática de índices.
¿Cuál podría ser la solución a este problema?

La solución propuesta por la mayoría de los procesadores de texto es simple: Separar el formato de la estructura del documento.

La idea principal es volver a la primaria e identificar los elementos característicos de un texto tales como:
  • Títulos en diferentes niveles.
  • Párrafos.
  • Epígrafes
  • Citas
  • Notas al Pie
  • Etc
Incluso se podría ser mas granular como por ejemplo oraciones o partes remarcadas de una oración.

Ahora bien, este enfoque permite que muchas personas editen partes de un documento sin tener que preocuparse por el formato, cosa que en general cuando se trata de la edición de grandes documentos sucede muy a menudo. La técnica es simple. se define un estándar estructural, el cual es más facil de definir y aplicar que la común definición de un fromato estándar y al finalizar el documento se aplica el formato editando los estilos.

A continuación muestro cómo se realiza esto dentro de OpenOffice:


Dejo remarcado en la imágen el combo con el que podemos indicarle al procesador de texto que tipo de elemento tenemos seleccionado.
Generalmente éstos elementos ya traen un formato predeterminado aunque a mi parecer es bien feo.

Una vez que decidimos comenzar con el formateo de nuestro documento desplegamos el diálogo que también se puede ver en la imágen y con click derecho podremos acceder a las propiedades de su formato.

Principios similares se aplican en sitios web con las hojas de estilo en cascada (CSS) aunque estas últimas son mucho mas extensas en cuestión de definición de formato.

Espero que les sirva para sacar documentos mas prolijos y utilizando siempre formatos abiertos.

Saludos!

lunes, 28 de septiembre de 2009

Instalando Glassfish en Archlinux

Hace relativamente poco he empezado mi vida como desarrollador JavaEE, como servidor de desarrollo utilizo GlassFish simplemente porque es de sun y es el que viene con Netbeans, el cual también utilizo.
En mi pc habitual de desarrollo de JavaEE me he encontrado que correr el IDE y el servidor en el mismo lugar es contraproducente para la velocidad de desarrollo, digamos, todo se tarda muchísimo, por lo cual he instalado Glassfish en una pc aparte y acá comento mi experiencia.

Primero que nada, quiero decir que glassfish no viene en los repos asíque hay que instalarlo usando yaourt.
#yaourt -S glassfish
Hay que correrlo como root porque sino el script de instalación falla y nos quedamos con el servidor a medias.

Luego de instalarlo se puede arrancar. Los dominios de glassfish se colocan en el directorio domains de la instalación (yaourt lo pone en /opt/glassfish), estoy usando el dominio por defecto ya que trae todos los servicios en los puertos estándar asíque prácticamente sale corriendo "out of the box".
Algo que extrañé es un script en /etc/rc.d para controlarlo, igual nada me impide hacerlo y lo hice.

Glassfish tiene un workaround para que funcionen las conexiones al servicio jndi y es que el nombre de host debe resolver a la ip externa de la pc, por lo cual hay que manipular el archivo /etc/hosts para que quede similar a esto:
127.0.0.1 localhost.localdomain localhost
192.168.1.8 juan-desktop
Para Controlarlo se utiliza el binario asadmin que se encuentra en el directorio bin, entonces por ejemplo mi dominio se llama domain1 (el que viene por defecto, y estas son las opciones para controlarlo):

asadmin start-domain domain1 # Arrancar el domain1 y si dado el caso, servidor también
asadmin stop-domain domain1 # Parar el dominio1 en el servidor y dado el caso, el servidor tb.

Si le añandimos la opción --debug, podemos arrancar el servidor en modo debug (lo cual sirve para los ides, entoces acá les presento mi script de shell para controlar a glassfish.

#!/bin/bash


case "$1" in

start)
/opt/glassfish/bin/asadmin start-domain domain1
;;
stop)
/opt/glassfish/bin/asadmin stop-domain domain1
;;
debug)
/opt/glassfish/bin/asadmin start-domain --debug domain1
;;

debug-restart)
$0 stop
sleep 5
$0 debug
;;
restart)
$0 stop
sleep 5
$0 start
;;
*)
echo "usage $0 {start, stop, debug, restart, debug-restart}"
;;
esac


Los sleep se los pongo simplemente para darle un descanso a la pc entre parada y arrancada.

Conexión con Netbeans

La conexión con netbeans es ultra facil, uno se dirige a la pestaña de servicios, en el item de servidores, le da click derecho y le pone agregar nuevo servidor, aparecerá un asistente y hay que colocar los siguientes datos, aclarando que 4848 es el puerto de adminsitración por http de mi glassfish standalone.




Espero que les sirva, saludos!

lunes, 14 de septiembre de 2009

Un Increible editor de texto: VIM

VIM Es un editor de archivos de texto de consola basado en VI. Es increiblemente poderoso aunque puede parecer un poco tosco al principio y poco amigable.

Entre las características que mas me han impresionado se encuentra lo siguiente:

  1. Edición de multiples archivos en pestañas.
  2. Sintaxis resaltada para muchos tipos de archivos de configuración.
  3. Soporte de muchos plugins.
  4. Autocompletado de código.
  5. Code-Fold esto es, esconder código dentro de bloques de programación.
  6. Backup y recuperación de archivos que se están editando.
  7. Comodidad de realizar todo sin levantar las manos del teclado.
Realmente tiene muchas cosas, aún así tiene la ventaja/desventaja según como se lo vea que no se explicita mucho sobre cómo hacer cosas entonces el usuario nuevo realmente no puede entenderlo ni "sacarlo" intuitivamente. Es por eso que he preparado algunos tips para los que quieran aprender a usarlo.

Antes que nada, quisiera comentar que VIM viene ya para muchas plataformas, en las que se incluyen windows, linux y mac os.

Enlaces:
Página de descarga de Vim
VIM en Wikipedia
VI en wikipedia

Existe para los que lo tienen instalado un tutorial que dura 30 minutos que lo pueden hacer y con eso conocer todo lo necesario sobre el vim, para acceder al tutorial escribir el siguiente comando:
$vimtutor
Espero que les resulte de utilidad. Saludos!

lunes, 7 de septiembre de 2009

Conocer tu hardware en Linux.

Muchas veces nos encontramos ante la necesidad de conocer características de nuestro hardware. Existen distintas alternativas, por ejemplo el comando:
cat /proc/cpuinfo
Nos da informacíon sobre el microprocesador que estamos usando.
cat /proc/meminfo
Nos da información sobre el uso de la memoria.
lspci
Nos da información sobre los dispositivos conectados al bus PCI de nuestra placa madre.
lsusb
Nos da información sobre los dispositivos USB conectados.

Hoy sin embargo me he encontrado con un comando que me ha resultado de suma utilidad que es dmidecode.

De por si dmidecode sin parámetros tira información completa sobre todo lo que tenemos en la pc, pero puede filtrarse con por tipos de dispositivo. La sintaxis para usar el comando es la siguiente:
dmidecode --type [nro de tipo]
Acá dejo una tabla de los distintos tipos extraida de las propias manpages de dmidecode.

Type Information
────────────────────────────────────────
0 BIOS
1 System
2 Base Board
3 Chassis
4 Processor
5 Memory Controller
6 Memory Module
7 Cache
8 Port Connector
9 System Slots
10 On Board Devices
11 OEM Strings
12 System Configuration Options
13 BIOS Language
14 Group Associations
15 System Event Log
16 Physical Memory Array
17 Memory Device
18 32-bit Memory Error
19 Memory Array Mapped Address
20 Memory Device Mapped Address
21 Built-in Pointing Device
22 Portable Battery
23 System Reset
24 Hardware Security
25 System Power Controls
26 Voltage Probe
27 Cooling Device
28 Temperature Probe
29 Electrical Current Probe
30 Out-of-band Remote Access
31 Boot Integrity Services
32 System Boot
33 64-bit Memory Error
34 Management Device
35 Management Device Component
36 Management Device Threshold Data
37 Memory Channel
38 IPMI Device
39 Power Supply
40 Additional Information
41 Onboard Device

Espero que les sea de tanta utilidad como a mi.

Saludos!

domingo, 30 de agosto de 2009

Lista de Programas Open Source

Les dejo acá un link que encontré de wikipedia con una lista resumida de paquetes open source, para aquellos curiosos que anden buscando algo en particular.

Lista de Programas Open Source

Saludos!

domingo, 23 de agosto de 2009

Emesene 1.5

Hoy Me estoy enterando que ha salido una nueva versión de emesene.
Este cliente para Windows live Messenger tiene importantes novedades. Actualmente lo estoy teniendo en proceso de prueba.
La noticia en sí me parece importante ya que este proyecto no ha tenido movimientos desde hace mas de 1 año. Al parecer se está trabajando en una versión 2.

De momento he notado que en esta versión se han solucionado los problemas de "cuelgue" de la gui cuando uno intenta hacer cosas que requieren la red y ésta no responde en el tiempo adecuado.

El plugin de "ahora estoy escuchando" ha incorporado a amarok2 como reproductor, aunque hay que seguirle diciendo de qué reproductor leer. (Kmess detecta esto automáticamente). Pero tiene una característica muy simpática que te pone como avatar la tapa del disco de la canción que uno se encuentra escuchando.

He visto varios plugins nuevos.

Las transferecnias contra un cliente WLM inician (cosa que en otros clientes lamentablemente fallaba).

Iré actualizando el post a medida que vea cosas interesantes.

Saludos!

jueves, 20 de agosto de 2009

De Ubuntu a ArchLinux Sin dolor Parte 3

Para ver el desarrollo previo ver:
Parte 1
Parte 2

Ahora llega el momento de hacer la instalación definitiva, la cual se resume en 3 pasos:
  1. Copiar todos los archivos que venimos instalando a una partición nueva.
  2. Configurar Grub
  3. Reiniciar en nuestro nuevo sistema.
NOTA: Para quien quiera pisar su ubuntu, recomiendo realizar este paso desde un live cd, borrar el ubutnu que tenía y copiar todos los archivos de arch en la partición donde tenía su root.

Para el primer paso utilicé la herramienta de edición de particiones gparted, e hice espacio suficiente para un sistema base ya que el sistema desde el cual instalé es mi entorno de producción habitual y por un tiempo posiblemente lo necesitaré para responder a urgencias hasta que quede el sistema arch bien configurado.

Una vez creada una partición con espacio suficiente la formateamos en ext4

#mkfs.ext4 /dev/sda2 (en mi caso)

Y una vez formateada, la montamos, por ejemplo yo la monté en /mnt/arch.

Ahora toca el turno de copiar todos los archivos, para ello podemos usar el comando rapido:

cp -r /home/juan/archroot/* /mnt/arch

O utilizar algún gestor de archivos, yo personalmente copié todo utilizando el programa Midnight Commander (mc).

En estos momentos estamos a pocos momentos de finalizar:
Vamos a pasar a modo chroot pero esta vez montando los directorios dev, proc y sys.

mount -o bind /dev /mnt/arch/dev
mount -t proc none /mnt/arch/proc
mount -o bind /sys /mnt/arch/sys

y entramos a modo chroot:
chroot /mnt/arch
Ahora es un buen momento para establecer la clave de root:
passwd clave de root nueva
Configuramos grub a gusto, para quien no sepa como hacerlo les dejo una guia de la arch wiki.
Y eso es todo. Al reiniciar tendremos nuestro menu de grub esperandonos con Archlinux.

Espero que les haya sido de utilidad, cualquier duda posteen en comentarios.

Saludos!

miércoles, 19 de agosto de 2009

De Ubuntu a ArchLinux Sin dolor Parte 2

En un post anterior describí el proceso de instalación de Archlinux en un chroot en particular en ubuntu.
También se encuentra disponible la parte 3 de este proceso.
Ahora le toca el turno a la configuración necesaria para que el sistema pueda arrancar.

Antes que nada, toda la configuración la realicé dentro del chrroot, entonces antes de empezar hay que correr el siguiente comando:
chroot /home/juan/archroot
Cambiando por el directorio donde estén instalando arch.

/etc/rc.conf

El archivo rc.conf se nos instala junto con el paquete initscripts. En archlinux básicamente nos permite configurar el sistema completo en un solo lugar, por ahora será poco lo que toquemos, yo en particular toqué las siguientes líneas:
LOCALE="es_AR.utf8"
TIMEZONE="America/Argentina/Mendoza"
KEYMAP="es"
HOSTNAME="juan-work"
Y luego agregué hal a daemons
DAEMONS=(syslog-ng network netfs crond hal)
Si nos tenemos la suficiente fe de que todo funcione a la primera, podemos agregar gdm (o kdm) a los daemons también.

/etc/locale.gen

Descomenté la siguiente línea y las demás las dejé comentadas:
es_AR.UTF-8 UTF-8
Luego de eso corrí:
locale-gen
Para generar las locales y así tener el sistema en castellano.

xorg.conf

Por defecto arch no tiene xorg.conf pero eso no es un problema en absoluto, en efecto si tenemos hal corriendo no es necesario siquiera tenerlo, pero aprovechando que estamos en un linux funcionando, nos podemos permitir copiar el xorg.conf. Para ello nos salimos del chroot:
exit
cp /etc/X11/xorg.conf /home/juan/archroot/etc/X11
udev

Necesitamos ajustar los permisos de ciertos dispositivos especiales de forma que nos de lo siguiente:

ls -alF /dev/
...
crw------- 1 root root 5, 1 ago 18 15:52 console
crw-rw-rw- 1 root root 1, 3 ago 18 15:52 null
crw-rw-rw- 1 root root 1, 5 ago 18 15:52 zero

Para ello, yo en particular realicé:
chmod a+w /dev/null
chmod a+w /dev/zero
mtab y fstab

mtab lo copiaremos en la etapa de instalación definitiva.

Finalmente podemos configurar /etc/fstab a nuestro gusto y necesidad.

martes, 18 de agosto de 2009

De Ubuntu a ArchLinux Sin dolor Parte 1

En esta serie de entradas voy a ir comentando como va mi migración de un desktop en producción (en mi trabajo) de Xubuntu 9.04 a ArchLinux.

Se encuentra disponible la continuación de este proceso:

Para empezar comento que me baso en esta guía que encontré en la wiki de arch. Pero que detallaré el proceso y lo modificaré según mi experiencia, manos a la obra!

Primero que nada definimos un lugar donde instalaremos el sistema, yo decidí ponerlo en mi home, porque tengo espacio.

$cd --
$mkdir archroot
$cd archroot


Luego de eso, bajar y descomprimir pacman en nuestro directorio.


$wget ftp://ftp.archlinux.org/core/os/i686/pacman-3.3.0-3-i686.pkg.tar.gz
$wget ftp://ftp.archlinux.org/core/os/i686/pacman-mirrorlist-20090616-1-i686.pkg.tar.gz
$tar xzvf pacman-3.3.0-3-i686.pkg.tar.gz
$tar xzvf pacman-mirrorlist-20090616-1-i686.pkg.tar.gz


Pueden bajar la versión mas actualizada de pacman si quieren, pero no es tan necesario.

Ahora con esto pasamos a modo root, y necesitamos copiar la configuración de pacman para usarla en nuestro sistema ubuntu.

$sudo cp etc/pacman.conf /etc/
$sudo cp -r etc/pacman.d /etc/


Ahora editamos el archivo /etc/pacman.d/mirrorlist y le descomentamos algunos mirrors.

Ahora vamos a instalar en nuestro sistema ubuntu una version compilada estáticamente de pacman de forma que podamos usarlo sin problemas, todo esto lo hacemos como root.

#sudo su
#cd /root/
#wget http://repo.archlinux.fr/i686/pacman-static-3.2.2-1.pkg.tar.gz
#cd /
#tar zxvf /root/pacman-static-3.2.2-1.pkg.tar.gz
#mv /usr/bin/pacman.static /usr/bin/pacman


Finalmente para comodidad editamos el .bashrc del root con la siguiente línea:

alias pacman='pacman -r /home/juan/archroot'
Nota: cambiar la ruta /home/juan/archroot por la ruta donde vayan a instalar arch.
Para que tome los cambios
#bash

Ahora podemos manejarnos comodos con pacman.

#pacman -Suy

Para actualizar el pacman que habiamos instalado.

Ahora instalaremos lo necesario para que el sistema corra

El kernel de linux, utilidades de red, y otras cosas.

#pacman -Sf base kernel26 inetutils filesystem grub vim nano pacman

El conjunto base tiene el sistema base.

La razón por la que instalo pacman de nuevo es para satisfacer sus dependencias. También instalo vim y nano personalmente porque yo uso los 2 editores indistintamente. Uso la opción f de pacman para que me sobreescriba archivos que pueden ya existir en mi chroot.

Luego instalar xorg y el entorno de escritorio, yo particularmente instalaré xfce, pero cada uno deberá instalar el entorno que mejor le vaya.

#pacman -S xorg gdm xfce4

Eso es todo por ahora, iré completando el post a medida que voy avanzando.

Saludos!

martes, 11 de agosto de 2009

TuxGuitar

Para todos aquellos a quienes les gusta tocar guitarra (como a mi) les presento este simpático programa escrito en java por un autor Argentino, TuxGuitar, pueden acceder a la página desde este link.

Mediante este soft tenemos varias formas de editar nuestras canciones, como por ejemplo en pentagrama, tablatura o ambos, también nos ofrece una opción de reproducir lo que escribimos usando el midi de la computadora.



Algunas características:
  • Muchos acordes pre programados, listos para añadir a la tablatura / partitura.
  • Podemos ver equivalencia entre el mastil de la guitarra y las notas.
  • Aspecto gráfico muy agradable.
  • Posee un afinador (no toma sonidos sino que nos da ejemplos de los sonidos de cada cuerda).
  • Exportación a varios formatos.
  • Importación de varios formatos, incluyendo midi.
En mi opinión es un muy buen software que nos ayudará a escribir las canciones a medida que las vamos sacando y por qué no, componiendo.

Espero que les sea de utilidad. Saludos!

jueves, 6 de agosto de 2009

KDE 4.3

Acá les dejo un video que muesta las principales características de KDE 4.3.



Saludos!

Distribuir Particiones en Linux

Hoy comentaré algunos lineamientos a tener en cuenta a la hora de definir particiones cuando estamos instalando un sistema Linux.

El Sistema de Archivos.

Lo primero a tener en cuenta son los sistemas de archivos a utilizar. Es común tener un windows por ahi metido para juegos, o porque simplemente aún no nos animamos a hacer el cambiaso, o en mi caso, desarrollo aplicaciones de escritorio y necesito tener algún lugar donde probar parecido a un entorno en producción (y jugar tambien!). Si este es nuestro caso pues entonces recomiendo utilizar nuestra partición de datos en NTFS (tristemente).

Fuera de eso, para linux, por su estabilidad yo recomiendo Reiserfs o Ext4, con ext 4 tenemos posibilidades de recuperar archivos eliminados sin consecuencias catastróficas, y reiser se comporta realmente muy bien.

Distribución de Particiones.

Normalmente vamos a necesitar varias particiones con distintos objetivos.

  1. Una partición para la raíz (/).
  2. Una partición para el home (/home): la ventaja de utilizar esto es que todas nuestras configuraciones sobreviven a las formateadas.
  3. Una partición para los programas de usuarios (/usr): yo personalmente no lo uso, pero no es mala idea si somos de esas personas a las cuales les gusta tener todo el repositorio instalado :P.
  4. Una partición para el kernel (/boot): El objetivo de tener esto es mas bien para la gente fan de compilar su propio kernel, pueden prescindir de usar un initrd y compilar dentro del kernel sólo el sistema de archivos del tipo que sea boot y los demás sistemas de archivos compilarlos como módulos.
  5. Una partición para datos masivos o para compartir con otros sistemas tipo windows.
  6. Una partición para swap; esta, como todas menos la raíz, son opcionales. Especialmente a la swap la podemos tener como archivo y moverla o agrandarla según nos sea conveniente. La ventaja de tenerla como partición la veremos más adelante.


Tamaños de Particiones

Sobre los tamaños de las particiones se puede discrepar un poco, pero en líneas generales sería lo siguiente:

La raíz, lo suficientemente grande como para contener el sistema y sus programas, si usamos una partición de usr entonces puede ser mas bien chica incluso menos de 2 gigas, sino unos 15 o 20 gigas deberían bastar.

Si usamos partición de boot, con unos 100 megas será suficiente, sólo necesita poder contener 1 o 2 kernels.

La partición de home, tan grande como necesitemos para contener nuestros documentos de uso frecuente y esas cosas, si vamos a usar partición de datos, pues no necesitamos que sea tan grande.

La swap por lo general debería ser del doble de la memoria ram, claro está que si tenemos 4 gigas de ram no vamos a gastarnos 8 de disco solo para algo que rara vez se va a usar, como máximo yo diría 2Gigas, una cosa a tener en cuenta es que mientras menos ram real tengamos más necesaria va a ser la swap.

Ubicación para mejorar la performance

Las particiones de menos acceso deberían encontrarse en los extremos del disco (al principio o al final) y las de acceso mas frecuente deberían encontrarse en la mitad del disco, esto es porque el disco pierde muchísimo tiempo moviendo la cabeza lectora a lo ancho del disco por lo tanto si nuestros datos están en el medio nos aseguraríamos que el peor caso sea desplazarse hasta la mitad del ancho del disco, (lo cual es el caso promedio para un acceso cualquiera).

Si tenemos un segundo disco, sería conveniente que la swap se encontrara en éste, de forma que pueda cargar aplicaciones a memoria y paginar al mismo tiempo sin tener que pagar los costos de mover la cabeza lectora.

Si tenemos poca ram nos conviene utilizar partición de swap en la mitad del disco. Si tenemos mucha con un archivo de swap nos bastará.

Bueno, este es el final, cualquier duda no duden en postearla.

Saludos!

miércoles, 5 de agosto de 2009

Archlinux: de KdeMod 4.2 a Kde 4.3

Bueno, escribo este post para orientar un poco con lo que parecen ser grandes noticias. Por empezar arch finalmente ha abandonado la filosofía de empaquetado original de KDE con lo cual ahora podremos instalar o desinstalar aplicaciones individuales sin necesidades de repositorios externos como lo son kdemod.

Para información mas completa sobre este tema ver este link



De KdeMod a KDE

Como alguna vez hice en sentido opuesto toca darle la despedida kdemod, quienes aparentemente ya no tienen razón de existir como repositorio de paquetes kde y espero que se dediquen al gran live cd Chakra Project.

La forma mas fácil de sacar kdemod de nuestras vidas es arrancarlo de un golpe seco.

#pacman -Rc kdemod

Eso eliminaría todo lo que tenga que ver con kdemod de nuestro sistema. Hay que notar que con esto no sólo se elimina kdemod, sino que tabmién se borran muchas aplicaciones KDE como lo son Kmess y Amarok, hay que tener especial cuidado en este punto. Yo personalmente tuve un problemita con el sonido que me volvió loco que mas tarde comentaré. Ahora instalamos lo que queremos.

Yo personalmente instale kdebase, kdeutils, kdeartwork, kdemultmedia, kdegraphics, kdeplasma-addons y algunos paquetes de kdesdk (como kate por ejemplo) y también algunos paquetes de kdeutils como ark, okteta (no uso todas las apps de kde aunque no parezca :P).

Problemas Post-Instalación.

Personalmente no tuve problemas post instalación con el propio kde, a simple vista está bien estable. Tuve que reinstalar apps que no son propias del empaquetado kde como comenté mas arriba (amarok, kmess, etc).

Como parte de la desinstalación de kdemod desinstalé el motor xine para phonon sin darme cuenta con lo cual tuve problemas para hacer andar el sonido. Pero se resuelve instalando phonon-xine

#pacman -S phonon-xine

También hay que recordar reisntalar nuestro gtk-qt-engine si es que tenemos la desgracia de que alguno de nuestros programas preferidos se encuentra escrito en gtk (en mi caso firefox).

Comentarios sobre KDE 4.3

Para finalizar comento que kde 4.3 de momento se encuentra bien estable, he intentado provocar alguno de los bugs conocidos (como achicar los paneles mas de lo permitido) y por ahora lo que he probado está corregido. Finalmente digo que el tema nuevo AIR no resultó ser lo que esperaba, si bien lo continuaré probando me costó mucho elegir un fondo de pantalla con el que se viera bien.

Saludos!

domingo, 2 de agosto de 2009

Javascript Embebido

Muchas veces resulta práctico proveer a nuestras aplicaciónes de una funcionalidad de scripting, de forma que el usuario sea capaz de escribir sus propios plugins. Un ejemplo sería que escribimos una aplicación de reproducir canciones, entonces si agregamos un motor de scripts, nuestros usuarios serían capaz de escribir por dar un ejemplo una alarma que haga sonar música a una determinada hora.

Para embeber un motor de Javascript en nuestra aplicación java, podemos utilizar un motor de javacript desarrollado por Mozilla para el lenguaje java, Rhino

Rhino permite con muy pocas líneas hacer que nuestro programa compile y ejecute javascript.

Rhino implementa hasta la versión 1.7 de javascript, y una de las posibilidades que tiene es la de acceder a nuestros objetos java "transparentemente" desde nuestra aplicación java. También nos permite acceder a objetos javascript desde nuestra aplicación java.

Para ver un ejemplo de su uso les dejo un link de Wikipedia.

Saludos!

jueves, 23 de julio de 2009

Aplicaciones Matemáticas

Muchas veces, como estudiantes, requerimos realizar cálculos matemáticos, de todo tipo, ecuaciones, derivadas, integrales, operaciones con matrices, etc.

Dentro del software libre existen aplicaciones que están muy buenas para este tipo de tareas:
  • Maxima.
  • Octave.
Ambas aplicaciones, más que hacer cálculos aislados, nos permiten realizar scripts con desarrollos matemáticos y el software los ejecuta. En particular Octave utiliza el lenguaje matlab y es capaz de ejecutar scripts Matlab.

Existen Interfaces Gráficas que nos facilitan la escritura de estos scripts, para máxima existe uno muy bueno que se llama WX Maxima, y para octave Qt Octave. Para realizar operaciones sencillas me ha resultado mas intuitivo WX Maxima.

Para activar la funcionalidad de gráficos (plot) de octave, necesitamos tener instalado un paquete que se llama "GNU Plot".

Bueno, con esto finalizo esta mini mini guía sobre aplicaciones matemáticas. Cualquier duda, postearla en comentarios.

Saludos!