monocaffe

Sharing Apache Tomcat and Apache Web Server

2012-01-17T23:30:00.000Z

Today's problem is sharing one single virtual host with different Tomcat instances. For example, say you have your Apache (the web server) with a virtual host for intranet and you have in different Tomcat instances different applications like: monitoring, dashboard and hradmin. You want your users to be directed to the correct application if they access the URL http://intranet/dashboard or http://intranet/hradmin.

In this example I'm using three Tomcat servers and this applications:

server1:8080/monitoring/
server1:8080/dashboard/
hr1:8080/hradmin/
hr2:8080/hradmin/

The server1 Tomcat is running two different applications and the hr1 and hr2 are running the hradmin application which we want to be load balanced and since it's critical, to be always available.

The first thing to do is create the jkworkers.properties file:

# This names are the ones defined bellow
worker.list=server1,hrlb
worker.lock=P
worker.status.type=status

# Single server running monitoring and dashboard
worker.server1.type=ajp13
worker.server1.host=192.168.1.2
worker.server1.port=8080
worker.server1.disabled=false
worker.server1.socket_timeout=60000
worker.server1.connect_timeout=60000

# Two workers for two servers running a critical application
worker.hr1.type=ajp13
worker.hr1.host=192.168.1.3
worker.hr1.port=8080
worker.hr1.disabled=false
worker.hr1.socket_timeout=60000
worker.hr1.connect_timeout=60000

worker.hr2.type=ajp13
worker.hr2.host=192.168.1.4
worker.hr2.port=8080
worker.hr2.disabled=false
worker.hr2.socket_timeout=60000
worker.hr2.connect_timeout=60000

# Loadbalancer configuration for the critical application
worker.hrlb.type=lb
worker.hrlb.balance_workers=hr1,hr2
worker.hrlb.sticky_session=true
worker.hrlb.sticky_session_force=false
worker.hrlb.method=R

Of course, you should use the DNS names instead of the IP addresses. Also, there are many more options to be set here, but this should give you a good start.

Second, you need your jk.conf file:

JkWorkersFile /etc/apache2/conf.d/jkworkers.properties
JkLogFile /var/log/apache2/mod_jk.log
JkLogLevel info
JkLogStampFormat "[%a %b %d %H:%M:%S %Y]"
JkOptions +ForwardKeySize +ForwardURICompatUnparsed -ForwardDirectories
JkRequestLogFormat "%w %V %T"
JkShmFile /var/log/httpd/jk.shm
<Location /jkstatus>
    JkMount status
    Order deny,allow
    Deny from all
    Allow from 127.0.0.1
</Location>

And finally, you can set up your virtual host in the, for example, intranet.conf file:

<VirtualHost *:80>
  ServerName intranet
  RewriteEngine on

  # Here we set where we want the url http://intranet/ to go
  RedirectMatch ^/$ /dashboard/

  DocumentRoot /srv/www/htdocs/docroot
  CustomLog  /var/log/apache2/access_reports combined
  ErrorLog  /var/log/apache2/error_reports
  
  # You can even setup a jongo proxy
  ProxyPass /jongo/ http://192.168.1.5:8080/jongo/
  ProxyPassReverse /jongo/ http://192.168.1.5:8080/jongo/
  
  # It's important that this names are the same used in your Tomcat
  JkMount /dashboard/* server1
  JkMount /monitoring/* server1
  JkMount /hradmin/* hrlb
</VirtualHost>

What we're doing here is telling the Apache server to listen on port 80 for all requests to the intranet host and to forward this requests to their corresponding applications:

http://intranet/ goes to http://server1/dashboard/
http://intranet/dashboard/ goes to http://server1/dashboard/
http://intranet/monitoring/ goes to http://server1/monitoring/
http://intranet/hradmin/ goes to http://hr1/hradmin/ or to http://hr2/hradmin/

Where you put this files depends on your httpd.conf configuration.

This example will allow a vanilla Apache to serve three different applications (one load balanced) from three Tomcat servers (server1, hr1 and hr2)

Python and Jongo

2012-01-14T10:32:00.000Z

For some reason or another, I've always found Python support for RDBMS lacking behind Java, specially in the ORM area. Just imagine, there are no officially supported Python drivers to connect to an Oracle database and you must install the Oracle client... ugh!

Anyway, by having a Jongo server connected to your database you don't have to worry about installing any Python modules, you'll only need a standard Python 2.4+ installation with simplejson or Python 2.5+ which already support JSON.

Let's see, for example, an application which accesses the CIDB database and the Car table:

import jongo

class Car(jongo.JongoModel):
    def __init__(self, id=None, model=None, maker=None, fuel=None, transmission=None, year=None):
        jongo.JongoModel.__init__(self)
        self.id = id
        self.idCol = "cid"
        self.model = model
        self.maker = maker
        self.fuel = fuel
        self.transmission = transmission
        self.year = year

class CarStore(jongo.JongoStore):
    def __init__(self):
        jongo.JongoStore.__init__(self)
        self.model = Car
        self.proxy = jongo.Proxy("localhost:8080","cidb","car", Car)

if __name__ == '__main__':
    carstore = CarStore()
    carstore.load()
    for car in carstore.data:
        print car

    c1 = Car(None, "206cc", "Peugeot", "Gasoline", "Manual", 2008)
    carstore.add(c1)
    carstore.sync()

    c1 = carstore.getAt(carstore.count() - 1)
    c1.set('model', "206")
    c1.set('maker', "PPegoushn")
    carstore.update(c1)
    carstore.sync()

    # We need to refresh the object since it has changed after the sync
    c1 = carstore.getAt(carstore.count() - 1)
    carstore.remove(c1)
    carstore.sync()

Since this is Python, the code is pretty straightforward and self documented, right? For more information and examples on working with Python and Jongo check this page.

Jongo Beta 0.1

2011-12-16T23:00:00.000Z

Last night I uploaded the first version of Jongo. This is a beta version and all of the projected functionality is provided.

All REST to CRUD operations are implemented (PUT, POST, GET, DELETE).
JDBC errors mapping to HTTP errors.
POST requests accept form and JSON data.
Full HTTP response with JSON or XML
Grails style dynamic finders.
Complex Queries.
Deploy-able web applications in the apps directory.
Administration Console with jQuery.
Demo mode which creates a in-memory database with demo data and deploys a demo application called cidb (made using ExtJS)
Support for MySQL, Oracle and Hypersonic.

In future versions support for more RDBMS will be added, like Microsoft SQL Server and Sybase using the jTDS JDBC Driver. Also support for PostgreSQL and SQLite is projected.

A couple of screenshots:

This is the administration console, from where you can control the tables Jongo will provide access to. It's completely made with jQuery and is a good example of how to work with jQuery.Ajax() and Jongo.

The cidb application is a demonstration of how to use ExtJS rest stores without any server side coding.

If you find Jongo useful please leave your feedback. Find any bugs, errors or have a cool idea? Open a ticket!

Jongo as a JavaScript Application Server

2011-12-05T20:52:00.001Z

Jongo is built on top of the Jetty webserver, allowing a developer to use only one server to build a full application using static content (html, css, images) and JavaScript. For Jongo to be able to deploy your application, you need to activate the jongo.allow.apps option in the jongo.properties file.

Continue and create a folder in your JONGO_HOME named apps/myapp and develop you application there, something like this:

An example of a MVC ExtJS Application

If everything went fine, the next time you run jongo, you'll see this in your logs (if debug mode is enabled):

2011-12-05 22:02:04 o.j.JongoJetty [DEBUG] Loading apps
2011-12-05 22:02:04 o.j.JongoJetty [DEBUG] Creating Servlet for myapp

Now navigate to http://jongo-server:port/myapp/ and your application should work.

Jongo and ExtJS

2011-12-05T20:23:00.001Z

To work out some issues other developers might have when working with Jongo, I've started to develop a JavaScript only application (pretty much like the Administration Console) and get some insights into using a great JavaScript framework named ExtJS.

ExtJS provides a clean MVC framework which fits perfectly with a Jongo back-end.

By using a rest proxy like this:

Ext.define('User', {
    extend: 'Ext.data.Model',
    fields: ['id', 'name', 'email']
});

Ext.define('Users', {
    extend: 'Ext.data.Store',
    model: 'User',
    proxy: {
        type: 'rest',
        url : '/jongo/user',
        reader: {
            type: 'json',
            success: true,
            root: 'response'
        }
    }
});

Our application is ready to perform all rest operations on the database without doing any server-side coding. Give it a try, you'll be pleased.

Un gobierno en funciones no puede aprobar la ley Sinde

2011-12-02T11:58:00.001Z

Hoy verás este texto en decenas de blogs. Si estás de acuerdo con él, reprodúcelo donde consideres oportuno.

Ante la previsible aprobación de la polémica “Ley Sinde”, los periodistas, bloggers, usuarios, profesionales y creadores de Internet seguimos manifestando –como hicimos en el Manifiesto de 2 de Diciembre de 2009- nuestra firme oposición a una norma que incluye modificaciones legislativas que afectan al libre ejercicio de las libertades de expresión, información y el derecho de acceso a la cultura a través de Internet.

En principio no parece de recibo que un Gobierno en funciones adopte esta decisión en su último o uno de sus últimos Consejos de Ministros. Sería doblemente grave que se confirmaran las presiones ejercidas por EEUU, a través de su embajada en Madrid, como revelaron los cables de Wikileaks.

En todo caso insistimos en estos razonamientos:

Los derechos de autor no pueden situarse por encima de los derechos fundamentales de los ciudadanos, como el derecho a la privacidad, a la seguridad, a la presunción de inocencia, a la tutela judicial efectiva y a la libertad de expresión.
La suspensión de derechos fundamentales es y debe seguir siendo competencia exclusiva del poder judicial. Ni un cierre sin sentencia. Este anteproyecto, en contra de lo establecido en el artículo 20.5 de la Constitución, pone en manos de un órgano no judicial -un organismo dependiente del ministerio de Cultura-, la potestad de impedir a los ciudadanos españoles el acceso a cualquier página web.
La nueva legislación creará inseguridad jurídica en todo el sector tecnológico español, perjudicando uno de los pocos campos de desarrollo y futuro de nuestra economía, entorpeciendo la creación de empresas, introduciendo trabas a la libre competencia y ralentizando su proyección internacional.
La nueva legislación propuesta amenaza a los nuevos creadores y entorpece la creación cultural. Con Internet y los sucesivos avances tecnológicos se ha democratizado extraordinariamente la creación y emisión de contenidos de todo tipo, que ya no provienen prevalentemente de las industrias culturales tradicionales, sino de multitud de fuentes diferentes.
Los autores, como todos los trabajadores, tienen derecho a vivir de su trabajo con nuevas ideas creativas, modelos de negocio y actividades asociadas a sus creaciones. Intentar sostener con cambios legislativos a una industria obsoleta que no sabe adaptarse a este nuevo entorno no es ni justo ni realista. Si su modelo de negocio se basaba en el control de las copias de las obras y en Internet no es posible sin vulnerar derechos fundamentales, deberían buscar otro modelo.
Consideramos que las industrias culturales necesitan para sobrevivir alternativas modernas, eficaces, creíbles y asequibles y que se adecuen a los nuevos usos sociales, en lugar de limitaciones tan desproporcionadas como ineficaces para el fin que dicen perseguir.
Internet debe funcionar de forma libre y sin interferencias políticas auspiciadas por sectores que pretenden perpetuar obsoletos modelos de negocio e imposibilitar que el saber humano siga siendo libre.
Exigimos que el Gobierno garantice por ley la neutralidad de la Red en España, ante cualquier presión que pueda producirse, como marco para el desarrollo de una economía sostenible y realista de cara al futuro.
Proponemos una verdadera reforma del derecho de propiedad intelectual orientada a su fin: devolver a la sociedad el conocimiento, promover el dominio público y limitar los abusos de las entidades gestoras.
En democracia las leyes y sus modificaciones deben aprobarse tras el oportuno debate público y habiendo consultado previamente a todas las partes implicadas. No es de recibo que se realicen cambios legislativos que afectan a derechos fundamentales en una ley no orgánica y que versa sobre otra materia.

Java's Ghost JVMs

2011-10-19T15:51:00.002+01:00

It's a nice day when you end up digging through some of the JDK source code to find out what is broken with one of the JDK tools like JPS or JConsole. Today was one of those days.

The problem was with our JBoss monitoring tool which depends on jconsoles LocalVirtualMachine.getAllVirtualMachines() method. For some reason, after a controlled restart of the farm, a couple of servers were being reported as offline. Looking at the log files, I was able to see that the PID for this servers was wrong and the process couldn't connect to retrieve the data (this is done using JMX).

The solution was to see what this method was doing with the source code from LocalVmManager.java and PerfDataFile.java

So how does tools like JPS, JConsole or VisualVM know the JVMs running in a system? They simply look in the folder /tmp/hsperfdata_foo where a 32KB data file with the PID as name is created for each JVM.

Back to our problem. After the restart, some of the files that should have been removed when the JVM was killed were still there, so this was giving the monitoring process a wrong PID and it couldn't connect to the JVM and do its magic.

Solution: remove the unused files and everything works as expected.

So, the next time you need to know all the JVM running on your system, remember this: $ls /tmp/hsperfdata_*/

RESTing with Jongo

2011-10-08T18:35:00.000+01:00

For the last few weekends and as part of a week of holidays where I had to stay at home taking care of my convalescent wife I started a project called Jongo which is a RESTful interface for JDBC that allows any application to directly access a RDBMS using the different HTTP methods. The idea came from working with CouchDB's RESTful JSON API but using the ability of Java's JDBC to be database independent.

So what does all this gibberish means? To put it in a simple way, you can, for example, develop JavaScript only applications with a database back-end without doing any server side development.

For example, say you have a table with some users and you want to GET the first one:

$ curl -X GET "http://localhost:8080/jongo/user/1"

{"success":true, "count":1, "resource":"user", "response":[{"birthday":"null","credit":"45.00","lastupdate":"null","name":"foo user","age":30,"id":4}]}

If you want to INSERT a new user, you would POST it with:

$curl -X POST -d '{"name":"foo user", "age":30, "credit":45.0}' "http://localhost:8080/jongo/user"
{"success":true,"response":[{}]}

Since the default format is JSON, we provide a JSON object or an array of JSON objects. This will be formatted to native SQL values and inserted in the database as new user.

To UPDATE an user, you would perform a PUT request with the new values:

$ curl -X PUT -d  '{"name":"user change", "age":34}' "http://localhost:8080/jongo/user/4"
{"success":true,"response":[{}]}

And finally, the DELETE:

$ curl -X DELETE "http://localhost:8080/jongo/user/4"
{"success":true,"response":[{}]}

I hope this explains a little what a RESTful webservice is and how Jongo helps on publishing your RDBMS without any server-side development.

My Logback.xml template

2011-10-05T11:40:00.000+01:00

This is a simple working XML configuration to start using Logback on your Java projects as fast as possible:

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
    
  <!-- Console -->  
    
  <appender name="S" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>%d{yyyy-MM-dd HH:mm:ss} %c{1} [%p] %m%n</pattern>
    </encoder>
  </appender>
  
  <!-- HTML Rolling Appender -->
  
  <appender name="H" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/jongo.html</file>
    <encoder class="ch.qos.logback.core.encoder.LayoutWrappingEncoder">
        <layout class="ch.qos.logback.classic.html.HTMLLayout">
            <pattern>%msg%n</pattern>
        </layout>
    </encoder>
    <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
      <fileNamePattern>logs/jongo.html.%i</fileNamePattern>
      <minIndex>1</minIndex>
      <maxIndex>3</maxIndex>
    </rollingPolicy>
    <triggeringPolicy class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
      <MaxFileSize>1024KB</MaxFileSize>
    </triggeringPolicy>
  </appender>
  
  <!-- Plain Text Rolling Appender -->
  
  <appender name="R" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <Append>true</Append>
    <File>logs/jongo.log</File>
    <encoder>
      <pattern>%d{yyyy-MM-dd HH:mm:ss} %c{1} [%p] %m%n</pattern>
    </encoder>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
      <fileNamePattern>logs/jongo.log.%d{yyyy-MM-dd}</fileNamePattern>
      <maxHistory>30</maxHistory>
    </rollingPolicy>
  </appender>
  
  <logger name="org.w3c.tidy" level="OFF"/>
  <logger name="ch.qos" level="OFF"/>
  <logger name="org.slf4j" level="OFF"/>

  <root level="DEBUG">
    <appender-ref ref="S"/>
<!--    <appender-ref ref="H"/>-->
<!--    <appender-ref ref="R"/>-->
  </root>
</configuration>

Simply copy/paste this to your logback.xml file and it should work but you should modify it to make it work as you please.

Grails and Tomcat 7 Datasource

2011-09-12T11:30:00.003+01:00

This should be fast and easy. You want a shared datasource on your Tomcat 7 server, which you can change without deploying a new Grails war and that is shared between all your Grails applications on this same Tomcat server.

You have to configure your DataSource.groovy file with this:

production{
pooled = false
dbCreate = "update"
jndiName = "java:comp/env/jdbc/MyGrailsDS"
}

Generate your war, place it for deployment and go configure the conf/context.xml file on your Tomcat server.

<Resource name="jdbc/MyGrailsDS" auth="Container" type="javax.sql.DataSource" username="abc" password="abc" driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql://localhost:3306/my_grails_schema"/>

Start your Tomcat 7 server and enjoy. Now you can change the database your applications point at by simply changing the configuration on the context.xml file.

Ubuntu Black Screen over VNC

2011-06-09T15:49:00.000+01:00

Trying to share your desktop with Ubuntu and when you connect to it a black screen is shown but you can see control taken over it?

Disable visual effects in System-> Preferences-> Appearance-> Visual Effects-> None

Easy.

Monitor Tomcat/JBoss served connections

2011-05-12T16:24:00.000+01:00

Say you want to monitor how many connections each of your JBoss/Tomcat servers are serving, because, you might want to make sure load balancing is working correctly. This can be accomplished by reading this information from an MBean, in this case the GlobalRequestProcessor.

jconsole screenshot of a jboss jvm

The image speaks by itself. So, depending on how your Tomcat server is being accessed, you can count the number of served requests it has processed and many more data which could become useful someday.

Java Daemon

2011-04-13T13:10:00.001+01:00

Here's a little Bash script to run any Java application as a daemon. The only change you'll have to implement in your Java application is a handler for UNIX kill signals. Something like this:

    Signal.handle(new Signal("INT"), new SignalHandler () {
        public void handle(Signal sig) {
            System.exit(10);
        }
      });

That's an example, handle exceptions and other signals properly.
Now that your application is ready to handle a signal, be sure to be very special with the signal 10 and exit with code 10. Why 10? Read the kill manual page and you'll see there are no standard signals with this value.

Here's the Bash code:

#!/bin/bash
#
# Startup Script

JAVA_HOME="/opt/jre1.6.0_18/"
runnable="com.test.TestApplication"
pid=""

do_start () {
    if [ ! -d "${JAVA_HOME}" ] ; then
        echo "${JAVA_HOME} Directory doesn't exist."
        exit 1
    else
        if [ ! -x "${JAVA_HOME}/bin/java" ] ; then
            echo "Java binary error: not found or not executable"
            exit 1
        fi
    fi

    local path="lib/*"
    local opts="-Ddebug.level=INFO"

    # Launch the process
    local exit_code=10
    while [ $exit_code -eq 10 ]; do
        "${JAVA_HOME}/bin/java" ${opts} -cp "${path}" ${runnable}
        exit_code=$?
    done
}

do_stop () {

    getPID 
    kill ${pid} > /dev/null 2>&1 && echo "Stoping process ${pid}"
}

do_status () {

    getPID 
    kill -0 ${pid} > /dev/null 2>&1 && echo "Process is running"
}

do_restart () {

    getPID 
    kill -10 ${pid}  > /dev/null 2>&1 && echo "Restarting"
}

getPID () {
    # not the best, but works on most linux
    pid=$( ps -ef | grep  ${runnable} | grep -v grep | awk '{ print $2 }' )
}

case ${1} in
    start)
        do_start
    ;;

    stop)
        do_stop
    ;;

    status)
        do_status
    ;;

    nohup)
        # I really like this hack 
        nohup $0 start > /dev/null 2>&1 &
    ;;
    
    restart)
        do_restart
    ;;

    *)
        echo "Usage: $0 start|nohup|restart|stop|status"
        exit 1
    ;;
esac

exit 0

I believe the script is pretty straight forward. Cool thing is that if you use start, you will run your application normally, but using the nohup option, it will call nohup on the script and run itself in daemon mode. Now, the only way to stop this process is to call the stop option or directly kill it. Also, if your process somehow listens for any event, you can implement a special one which allows the process to restart itself. For example, if your application is a web service, you can call curl http://localhost/restart

Groovy Conflicts with Grails

2011-03-02T15:54:00.000Z

If you get this error:

Error creating bean with name 'pluginManager' defined in ServletContext resource [/WEB-INF/applicationContext.xml]: Invocation of init method failed; nested exception is java.lang.NoSuchMethodError: org.codehaus.groovy.control.SourceUnit.getSource()Lorg/codehaus/groovy/control/io/ReaderSource;

Check your WEB-INF/lib folder for older version of Groovy. In my case, this happened after installing some plugins using the STS plugin manager.

Grails hasMany Delete

2011-02-16T16:31:00.001Z

Suppose the following:

class Group{
    String name
    static hasMany = [users:User]
}

class User{
    String name
}

This means, you have lots of Users for some Group, but also a User might have other Groups, so can't use a "belongsTo". To delete a Group is really easy:

def b = Group.get(0)
b.delete(flush:true)

On the other hand, you might want to delete a User, but not the Group:

def b = User.get(0)
b.delete(flush:true)

This will throw a lot of exceptions from Hibernate and JDBC. How are you supposed to do it? Well, first of all, you'll need a way to get a Group for a given User, but since "users" is transitive, you can't do something like Group.findByUser(user) so go ahead and add the following code to your Group class:

static Group findByUser(User user){
    def criteria = Group.createCriteria()
    def result = criteria.get {
        users {
            idEq(user.id)
        }
    }
    return result
}

Now, go to your UserController delete method and add the following

if (userInstance) {
    try {
        AlertGroup g = Group.findByUser(userInstance)
        if(g){
            g.users.remove(userInstance)
        }
        userInstance.delete(flush: true)
...

The clear call will empty the references in the current object so you don't get any trouble.

CoffeScript and Canvas

2011-02-10T18:37:00.000Z

I keep playing with CoffeeScript, and what better way than using canvas!

<html>
    <head>
        <title>CoffeScript Canvas</title>
        <script src="coffee-script.js"></script>
        <script type="text/coffeescript">
            draw = () -> 
                canvas = document.getElementById('coffee')
                if canvas.getContext
                    ctx = canvas.getContext('2d')
                    ctx.fillStyle = "rgb(200,0,0)"
                    ctx.fillRect(10, 10, 55, 50)

                    ctx.fillStyle = "rgba(0, 0, 200, 0.5)"
                    ctx.fillRect(30, 30, 55, 50)

            draw()
        </script>
        <style type="text/css">
            canvas { border: 1px solid black; }
        </style>
    </head>
    <body>
        <canvas id="coffee" width="150" height="150"></canvas>
    </body>
</html>

Well, it's basically the same as with JavaScript.

CoffeeScript in 1, 2, 3...

2011-02-03T19:52:00.000Z

Ok, this is very easy, but nowhere to be found on the CoffeeScript site and shows how easy it's to get started.
I mean, really, why? If you're going to develop on Javascript, you don't want to "build" your code.
So, all you need is some simple HTML and the following:

<script src="coffee-script.js"></script>
<script type="text/coffeescript">
alert "Hello CoffeeScript!"
</script>

Now add the "coffee-script.js" file in your path, and open it with your browser. No servers, no compilers, no NodeJS and nothing to install.

Central GNU Screen/SSH Server

2011-01-20T23:36:00.008Z

I'm not going to explain why screen is such a great tool because it's and there are many blogs who will tell you so. What I'm going to explain is how you can use screen to setup a central server to manage and monitor who connects to your servers and what do they do.
Screen has the special ability that allows us to log and connect to running sessions. This becomes handy in our current objective: setting up a central server where all users must connect so they can connect to other servers.
The idea is pretty basic and has lots of advantages:

No user management for each server
Users know only one, easily changed password for all servers
Greater control of user actions
Monitor unscheduled access
Log user activity

Of course, there are some disadvantages:

Single point of failure
Single point of entrance
Can become a pain when transfering files

First, we need to setup a single server with the following:

SSH Client
GNU Screen
User account for each user (limit the user's group using quotas)
Common user account on each server you wish to connect to (i.e. foo)

You have your screen server, and on each server you have a user (i.e. foo) with the same password (i.e. bar123). Now secure you SSH configuration by allowing access only from the screen server to the foo user (and admin just in case):

# /etc/hosts.allow
sshd: 192.168.0.2/255.255.255.0
sshd: 192.168.0.3/255.255.255.0
# /etc/hosts.deny
sshd: ALL
# /etc/ssh/sshd_config
AllowUsers foo admin
PermitRootLogin no

Your users should be able now to:

Connect to the screen server using someuser@screenserver
Connect to your servers only from the new screen server using foo@webserver

Use some `screen` magic

If you include screen in this whole setup, you'll be able to log user activity in the servers by correctly configuring screen. First, add the following configuration to /etc/screenrc:

# Scrolling
defscrollback 1500
termcapinfo xterm* ti@:te@

# Detach on close
autodetach on

# Disable key binds
bind H echo "Disabled" # Don't allow the user to disable logging
bind d echo "Disabled" # Don't allow to detach
bind ^d echo "Disabled" # Don't allow to detach
bind c echo "Disabled" # Don't allow to create
bind ^c echo "Disabled" # Don't allow to create
bind S echo "Disabled" # Don't allow to split
bind : echo "Disabled" # Don't allow to issue commands

# no startup msg
startup_message off

# Logging
deflog on
logtstamp on
logfile /tmp/screen-logs/%t-%Y%m%d-%n.log

On each user's home folder, create an empty .screenrc file. This file should be owned by root with read only permits (since you don't want the users to modify it). This way, no user will be able to override the general configuration.

Next, download the manager.sh script and add your servers:

servers=(
    "foo@bar1"
    "foo@bar2"
    "foo@bar3"
)

This script allows a user to select a server from the given list and launchs a ssh session inside a screen session:

 /usr/bin/screen -S user.bar1 -t user.bar1 /usr/bin/ssh foo@bar1

Since you're controlling and monitoring all the screen sessions, you can easily know what the users are doing on each server by watching the log files: user-20110116-0.log

Well, I hope this is useful for someone else. Leave a comment for any suggestions.

Adding Tags to your Tags

2011-01-18T17:51:00.003Z

I'm working on a Plugin to allow for Grails to easily draw HTML5 Graphs using the RGraph library. The problem with this plugin is that we have to provide a lot of attributes for any given tag to work, for example, the Rose Chart:

<rgraph:rose name="rosetest"
title="Rose Chart Test"
values="[1, 2, 3]"
tooltips="['Fred', 'Rich', 'Alex']"
zoom="true"
width="500" height="500"/>

The code for this tag was the following:

def rose = { attrs ->
    draw(new Rose(attrs))
}

But this is what I wanted:

<rgraph:rose title="Rose Chart Test" zoom="true">
    <rgraph:attribute name="rosetest2"/>
    <rgraph:attribute values="[1, 2, 3,]"/>
    <rgraph:attribute tooltips="['Fred', 'Rich', 'Alex']"/>
    <rgraph:attribute width="500"/>
    <rgraph:attribute height="500"/>
<rgraph:rose>

My objective is to be able to use a map given by the controller to draw the whole thing in three lines of code. But first, to acomplish this, we need to create a new tag named attribute which saves the given attribute to the page scope:

def attribute = { attrs ->
    this.pageScope.attrs << attrs
}

Now we modify our tags to look like:

def rose = { attrs, body ->
    attrs << initTag(body)
    draw(new Rose(attrs))
}

This new method initTag is for DRY:

def initTag(def body){
    this.pageScope.attrs = [:]
    body()
    return this.pageScope.attrs
}

Here initTag instantiates a new map in the attrs key in the page scope. Then, the body is executed, which continues processing the tags inside the rose tag and reads all the attribute tags. Each attribute tag simply saves the given attributes to the scope. Finally, when all attribute tags are read, initTag method returns all the attributes to the tags attrs variable, which is used to instantiate a new Rose object used to paint the JavaScript code.

function rosetestRGraphDraw(){
    var rosetest = new RGraph.Rose('rosetest', [1, 2, 3]);
    rosetest.Set('chart.zoom', true);
    rosetest.Set('chart.width', 500);
    rosetest.Set('chart.tooltips', ["Fred", "Rich", "Alex"]);
    rosetest.Set('chart.title', "Rose Chart Test");
    rosetest.Set('chart.height', 500);
    rosetest.Draw();
}

Now, this works, but what if I wanted to, instead of putting each attribute by it's own, to have the controller return a map with all the data I need and use the g:each tag. Then, we need to modify the attribute tag like this:

def attribute = { attrs ->
    def m = [:]
    m.put attrs.name, attrs.value
    this.pageScope.attrs << m
}

<rgraph:rose title="Rose Chart Test 2" zoom="true">
    <rgraph:attribute name="name" value="rosetest2"/>
    <rgraph:attribute name="values" value="[1, 2, 3]"/>
    <rgraph:attribute name="tooltips" value="['Fred', 'Rich', 'Alex']"/>
    <rgraph:attribute name="width" value="500"/>
    <rgraph:attribute name="height" value="500"/>
</rgraph:rose>

The HTML might not be so nice this way, but now we can do this:

<rgraph:rose title="Rose Chart Test 2" zoom="true">
    <g:each in="${someMap}" var="${entry}">
        <rgraph:attribute name="${entry.key}" value="${entry.value}"/>
    </g:each>
</rgraph:rose>

Grails debug logging

2010-12-03T15:03:00.000Z

There are two things about logging in Grails which can be a little pain. The first one is to activate debug logging in some domain or controller class during testing. To make this work, use the following with each class under testing:

mockLogging Foo, true

Now, all the debug messages in you class Foo will be generated.

The other thing which can be a pain, is enabling debug in general, and Hibernate debugging in particular. Well, not this time, since you have to only add the following to your Config.groovy file:

log4j= {

...

    debug 'com.foo.app',

          'org.hibernate'

}

Yes, Grails is that easy!

Video Streaming Linux/iPad

2010-12-01T20:05:00.001Z

People like to complicate things a lot. I've been reading of ways to stream video to my iPad. When a solution starts with "Install Wine" I give up. Is not that I don't like Wine, it just feels dirty.
Anyway, the problem is that Apple likes to do stupid stuff to put some crazy locks on hardware and software. I really like the iPad so I'm putting up with some of its problems, but this video streaming thing was getting on my nerves until I found OPlayer HD

So, go to your computer and run a simple HTTP server with some Python magic:

$python -c "import SimpleHTTPServer;SimpleHTTPServer.test()"

BTW, you should do this on a folder where you keep your movies.

Now, install OPLayer and go to the web browser it has. Point it to your server: http://192.168.0.2:8000 for example, and watch/download your movies.

Cool!

OPlayer also has a feature in which runs an HTTP server on the iPad. With this, you can upload your movies to the device from your computer, any computer.

Very cool!

On a final note, I was hoping this would be something VLC would bring, but what a disappointment. There's yxplayer, or something of the like, that is supposed to do the same thing. I've not tested it, I liked OPlayer, so I won't bother.

Another thing, the battery drains like crazy when playing a video over the network, so

Grails Enum

2010-11-20T12:25:00.000Z

¿Soporta Groovy enums?

Sí, como con cualquier objeto de Java, podemos acceder a ellos desde Groovy. Hacer que estos funcionen con Grails ya es un poco más complicado ya que tenemos que tener en cuenta el comportamiento de Hibernate al encontrarse un enum.

Después de un poco de trial & error, finalmente logre una solución que se ajusta a lo que quería.

public enum BookType{
  EBOOK("eBook"),
  PAPERBACK("PaperBack"),
  HARD("Hard Cover"),
  AUDIO("Audio Book")

  String type

  BookType(String type){
    this.type = type
  }

  static list() {
    [EBOOK, PAPERBACK, HARD, AUDIO]
  }
}

Luego utilizamos este enum en nuestro modelo:

class Book{
  String name
  BookType type

  static constraints = {
     type(nullable:false)
  }
}

Lo mejor de esto es el comportamiento de Hibernate, que crea la tabla book_type con la columna type y enlaza los valores del enum con nuestro modelo. A continuación, podemos utilizar los valores de nuestro enum al crear un libro:

<g:select name="bookType" id="bookType"
from="${BookType.list()}" 
value="${fieldValue(bean: bookInstance, field: 'bookType')}" 
optionValue="type"/>

GUI vs CLI

2010-10-06T22:33:00.000+01:00

Yesterday I was with a colleague who sadly, runs Windows 7. I was really trying to help him on setting up his development environment and at the end I was getting pretty frustrated by all the clicking and moving windows around. Anyway, this is not a rant against Windows. My colleague asked me why I felt more comfortable on the CLI. Easy to answer, it's faster... if you know what you're doing.

To put some numbers behind my assertion, I started timing some tasks which I do daily:

Copying files and folders.
Moving files and folders.
Create symbolic links.
Edit text files.
Create folders

Pretty standard stuff everyone does daily on a computer.
After I started timing some of this tasks and thinking about new ones, I came into the conclusion that this wasn't a fair contest, for the GUI. Some basic tasks can be easily done and quite fast (not as fast as in the CLI) but others are impossible. Any task which involved more than 3 iterations are mind numbing, like:

Finding a file in a list of compressed files.
Renaming a list of files.
Editing a bunch of image files.
And many more.

On the other hand, I've spent the last ten years working from a CLI pretty much all the time, so I've got some experience which makes me feel comfortable and productive.
Anyway, here are my results which were timed, of course, on the CLI ($time read x)

No más Facebook

2010-09-24T21:00:00.000+01:00

Cuando un servicio como Facebook deja de funcionar durante un par de horas, mucha gente se pregunta ¿por qué? La respuesta sólo la saben ellos, pero queda clara una de las mayores debilidades de Facebook: centralizado.

Centralizado
Esto significa que sólo existe en un sitio, una sola empresa lo controla y sólo una empresa se beneficia. Por lo que todas las decisiones son unilaterales por parte de una empresa, y las empresas tienen un único objetivo, ganar dinero. ¿Cómo gana dinero Facebook? No sólo con los pequeños anuncios que aparecen en la página, ya que en realidad, no hay muchos. El negocio está en vender los datos que poseen. Os recomiendo el documental "Revolución virtual: El precio de lo gratuito":

"En este nuevo negocio de la información la moneda de cambio, no es tanto el dinero físico como los datos y características del usuario potencial del entorno web. Así vemos como nuestra privacidad se diluye, se trafica con ella, en favor de los intereses económicos de las grandes empresas virtuales."

Diaspora
Hace unos meses se hizo mucha publicidad sobre "Diaspora" donde la idea principal, es conseguir crear un clon de Facebook que no este controlado por ninguna empresa. Para lograr este cometido, la única solución es utilizar un sistema distribuido.
El código de Diaspora fue liberado hace poco, lo cual significa que todo el mundo se ha puesto a revisarlo y las conclusiones en principio no parecen nada prometedoras tanto por el lenguaje (Ruby) como por la arquitectura de servidores distribuidos y por muchos fallos de diseño y seguridad.

Appleseed, GNUSocial y Status.Net
Sí, Diaspora no es la primera ni será la última competencia que va a intentar quitar el reinato de las redes sociales a Facebook, de hecho, el proyecto Appleseed, lleva funcionando y liberando versiones desde el año 2005. Status.Net es un clon de Twitter que funciona mucho mejor y Drumbeat es usado a diario por muchas personas detrás de Firefox asi que ¿por qué se ha hecho tanta publicidad a Diaspora habiendo tantos otros proyectos iguales y con más evolución? Supongo que será porque siempre que se escribe de Diaspora se trata de 4 chavales universitarios de NY contra la gigante Facebook, y esto vende muchas portadas.
Aquí os dejo una lista de otros proyectos de redes sociales distribuidas y abiertas:

zeldab
movim
ucentric
openlink data spaces
socialriver
mozilla's drumbeat
diso project
appleseed
higgin's project
gnusocial
smob
onesocialweb
status.net

Por último y para quienes deseen profundizar más en el tema, os dejo éste reporte hecho para la W3C sobre las redes sociales y las posibles soluciones al problema que es Facebook para la privacidad. Ahora sólo falta que el FarmVille funcione sin Faceboo.

PermGen Out of Memory

2010-09-03T11:12:00.002+01:00

Si te encuentras con este error es porque probablemente estés trabajando en una aplicación enterprise bastante grande. El principal problema de este error es que la JVM no muere, por lo que es cuestión de suerte saber que algún nodo de nuestro sistema ha dejado de funcionar.

Intentemos entender lo que es el espacio PermGen. Primero debemos entender sobre los tres mecanismos de recolección del GC de Java:

Young
Tenured
Perm

Podéis leer más sobre estos mecanismos aquí. El Perm(anent) se caracteriza por responsabilizarse del código binario de clases y métodos. De esta forma se separan las instancias de los objetos, del código que los describe. Por lo que si la JVM llena este espacio por completo, no podremos crear instancias nuevas de objetos que no lo hayan sido anteriormente ya que sus firmas no podrán ser metidas en el PermGen.

Dado que cualquier aplicación utiliza hoy en día Spring, Hibernate y cuarenta librerías más, el espacio para PermGen se puede llenar bastante rápido sino tenemos cuidado. Antes de solucionar este problema, vamos a intentar reproducirlo.

Si nuestra aplicación se ejecuta en algún servidor de aplicaciones, lo más sencillo será reducir el tamaño máximo del PermGen al mínimo, tal que el servidor funcione, despliegue nuestra aplicación pero falle con la primera petición. Esto lo logramos variando los valores del argumento para la JVM MaxPermSize.

A continuación vamos a medir esto utilizando jconsole ya que es bastante gráfico. Lo primero será activar el servicio JMX de la JVM añadiendo los siguientes argumentos:

com.sun.management.jmxremote.port=12346"
com.sun.management.jmxremote.authenticate=false"
com.sun.management.jmxremote.ssl=false"

Arrancamos el servidor de aplicaciones y jconsole.

A continuación realizamos una petición a nuestra aplicación y podemos ver como aumenta el uso del PermGen:

Y continuamos hasta que alcanzamos el límite dado (64m):

Después de esto, jconsole se desconecta y no podremos seguir analizando, aunque nuestra aplicación sigue funcionando y es posible que no se pierda funcionalidad, pero es inestable y en el momento en el que se intente crear una instancia de un objeto cuya "firma" no se encuentra en el PermGen, fallará.

La solución inmediata a este problema es claramente aumentar la cantidad de memoria disponible para el PermGen y por ende, de la JVM o seguir analizando el problema. Volvamos a arrancar el servidor de aplicaciones y nos conectamos con jconsole. Hacemos una petición:

¡Casí! Vamos a pulsar el botón "Perform GC" a ver qué sucede:

¿Nada? ¿No se limpia el PermGen? Dado el nombre de este espacio de memoria era bastante obvio el resultado. Otra solución que encontramos en Internet es añadir la siguiente opción a la JVM -XX:+CMSClassUnloadingEnabled veamos qué sucede:

Nada, seguimos igual. Probemos con otra de las soluciones -XX:+CMSPermGenSweepingEnabled

De igual manera parece que no ha habido ningún cambio favorable

 y el rendimiento se ha visto impactado negativamente y la misma petición ha tomado el triple de tiempo en ser procesada.

Puede que sencillamente, nuestra aplicación en realidad necesita tal cantidad de memoria ya que utilizamos una cantidad ingente de librerías. Como se puede ver en el siguiente gráfico, después de una larga sesión de stress, la memoria PermGen se mantiene estable:

Esto es un servidor de aplicaciones el cual utiliza gran cantidad de librerías, contextos y distintas complejidades que pueden hacer que ciertas referencias se mantengan y eviten que el GC haga su trabajo, por lo que vamos a intentarlo con una aplicación J2SE. Esta es sencillamente un servicio REST que nos permite hacer búsquedas contra unos EJB's. Para hacer pruebas es muy útil y como podemos ver, su funcionamiento es similar al servidor de aplicaciones:

Se utiliza cierta cantidad de memoria del PermGen y después de varias peticiones, esta se mantiene estable, incluso después de añadir las posibles soluciones indicadas más arriba no hay ningún cambio.

Dado que no hay un crecimiento continuo y que éste se detiene una vez hayamos pasado por todas las posibles combinaciones y usos de nuestra aplicación, es posible indicar un valor máximo para el PermGen que sea lo bastante como para sostener nuestras aplicaciones y justo en el consumo de memoria.

Redesplespliegues

Ahora hablemos de nuestro amigo el ClassLoader. Un servidor de aplicaciones como Tomcat o JBoss utilizan un artilugio que se encarga de cargar los ficheros .class de los JARs que componen nuestra aplicación.

Los ClassLoader tienen una jerarquia, donde el servidor de aplicaciones tiene uno o varios "propios" y por debajo de estos tenemos a los que se crean para cada una de nuestras aplicaciones. Dentro de ésta jerarquía las clases de nuestro ClassLoader pueden utilizar las de arriba, pero no al revés. Por lo tanto, al crear un nuevo objeto, sucede lo siquiente:

Cada objeto mantiene una referencia a su objeto .class.
Cada objeto .class mantiene una referencia con su ClassLoader.
Cada ClassLoader mantiene una referencia para cada clase que ha cargado.

Dado que cada una de nuestras aplicaciones tiene su ClassLoader, al volver a desplegar se destruyen todas las referencias al anterior para crear uno nuevo. Pues va a ser que no:

El ClassLoader vuelve a ser creado y por ende todas las referencias a clases antiguas se pierden y se crean nuevamente, pero no se realiza ninguna limpieza del PermGen... ever! Si continuamos redesplegando nuestra aplicación y haciendo peticiones, volveremos a quedarnos sin Perm.

Incluso si eliminamos el despliegue, el Perm no es liberado.

Soluciones

Podemos concluir que el PermGen nunca se libera de forma significativa y que debemos controlar su uso siguiendo estos consejos:

La solución más rápida es aumentar su tamaño máximo.
Ordenar y desarrollar nuestras aplicaciones de tal forma que se maximice el uso de las librerías provistas por el servidor de aplicaciones.
Utilizar librerías comunes entre distintos proyectos y añadir dichas librerías al ClassLoader del servidor de aplicaciones. Un buen ejemplo son los conectores JDBC.
Evitar referencias externas a nuestra aplicación a objetos internos de la misma (ClassLoader Leak).

Solución JRockit

JRockit, la máquina virtual de Oracle que era de BEA y utilizada por defecto por WebLogic no implementa un PermGen, por lo que este problema no existe y el GC recolecta de forma normal siempre que se eliminen las referencias, por lo que si la aplicación contiene un leak de este tipo, tendremos un Out of Memory del HEAP que son más fáciles de ver y monitorizar.

Nota final
Mientras he estado realizando las distintas pruebas, he podido comprobar que al añadir la opción CMSPermGenSweepingEnabled el rendimiento baja significativamente, incluso en una aplicacion J2SE por lo que no lo recomiendo para nada.

Más información
http://www.jroller.com/agileanswers/entry/preventing_java_s_java_lang
http://www.oracle.com/technetwork/java/gc-tuning-5-138395.html
http://www.alessandroribeiro.com/?q=en/node/39
http://stackoverflow.com/questions/88235/how-to-deal-with-java-lang-outofmemoryerror-permgen-space-error
http://blogs.sun.com/fkieviet/entry/classloader_leaks_the_dreaded_java
http://docs.jboss.org/jbossas/jboss4guide/r2/html/ch2.chapter.html

No más JavaScript!

2010-08-05T13:13:00.000+01:00

Bienvenido CoffeScript

Hace poco tuvo lugar OSCON y uno de los eventos más populares fue el Emerging Languages Camp donde muchas personas muy inteligentes dieron distintas presentaciones sobre nuevos lenguajes de programación, buenas practicas, patrones, etc. Por lo que después de ver las distintas presentaciones obvias como la de PyPy y Clojure me llamo la atención CoffeScript.

CoffeScript permite, utilizando una sintaxis muy parecida a la de Python, generar código JavaScript. Por ejemplo, una de las cosas que odio a muerte de JavaScript es su supuesto soporte de objetos. Veamos como se hace con CoffeScript:

class Animal
  constructor: (@name) ->

  move: (meters) ->
    alert @name + " moved " + meters + " meters"

class Person extends Animal
  move: (meters) ->
    super(meters)

  walk: (steps) ->
    this.move(0.6 * steps)

me = new Person "Ale"
me.walk(10)

El código JavaScript generado es el siguiente:

var Animal, Person, me;
var __extends = function(child, parent) {
    var ctor = function(){};
    ctor.prototype = parent.prototype;
    child.prototype = new ctor();
    child.prototype.constructor = child;
    if (typeof parent.extended === "function") parent.extended(child);
    child.__superClass__ = parent.prototype;
  };
Animal = function(_a) {
  this.name = _a;
  return this;
};
Animal.prototype.move = function(meters) {
  return alert(this.name + " moved " + meters + " meters");
};
Person = function() {
  return Animal.apply(this, arguments);
};
__extends(Person, Animal);
Person.prototype.move = function(meters) {
  return Person.__superClass__.move.call(this, meters);
};
Person.prototype.walk = function(steps) {
  return this.move(0.6 * steps);
};
me = new Person("Alex");
me.walk(10);

Ugh!

Sistemas de control de versiones (VCS)

2010-07-03T18:19:00.000+01:00

Sistemas de control de Versiones

No es posible llevar a buen puerto ningún proyecto sin
la utilización de un sistema de control de versiones.
Es mi opinión que todo desarrollador debe
tener amplios conocimientos de al menos dos sistemas
de control de versiones: funcionamiento, características
y comandos más usados. No digo que todos deban ser expertos
pero sí conocer el funcionamiento básico de estos, cosas como:

checkout
commit
merge
update

Ahora mismo estamos en proceso de definir una nueva arquitectura
para nuestro SCV y al ahondar en el estudio de los mismos, nos damos
cuenta de la gran cantidad de opciones y sistemas que existen.

Existen ciertas características que diferencian a estos sistemas y que es
conveniente explicar:

Atomic Commits

Una de las características más importantes (y principal razón para
eliminar CVS de todo sistema). Significa que al realizar un commit
cada fichero es tratado de forma individual, por lo que si el proceso
es interrumpido en cualquier momento, nuestro código no quedará en un
estado inconsistente.

CVS: no
Subversion: sí
Git: sí
Bazaar: sí
Mercurial: sí

Renombrar o mover ficheros o directorios

Al mover o renombrar un fichero o directorio se
mantiene su historial de cambios.

CVS: no
Subversion: sí
Git: sí
Bazaar: sí
Mercurial: sí

Merge inteligente

El sistema es capaz de realizar un merge inteligente de los cambios que sufre
un fichero incluso después de que este haya sido renombrado.

CVS: no
Subversion: no
Git: no
Bazaar: sí
Mercurial: sí

Copia de ficheros

Al copiar un fichero, se mantiene la historia en ambas copias.

CVS: no
Subversion: sí
Git: no
Bazaar: no
Mercurial: sí

Clonado del repositorio

Podemos clonar el repositorio a una copia local manteniendo
la misma funcionalidad sin necesidad de permisos especiales
en el servidor central.

CVS: no (CVSup)
Subversion: no (SVN::Mirror)
Git: sí
Bazaar: sí
Mercurial: sí

Propagación de cambios

Los cambios entre repositorios son posibles.

CVS: no
Subversion: sí
Git: sí
Bazaar: sí
Mercurial: sí

Permisos del repositorio

Se permiten definir permisos de acceso a distintas partes del repositorio.

CVS: limitado
Subversion: sí
Git: sí
Bazaar: sí
Mercurial: sí

Conjuntos de cambios

Podemos crear conjuntos de cambios que son relevantes entre sí en un
único paquete atómico que puede ser cancelado o propagado como sea
necesario.

CVS: no
Subversion: implicitos
Git: sí
Bazaar: sí
Mercurial: sí

Historial de ficheros linea a linea (annotate, blame)

Deseamos revisar los cambios realizados sobre cada línea de un fichero
y quien lo ha realizado

CVS: sí
Subversion: sí
Git: sí
Bazaar: sí
Mercurial: sí

Trabajo en un directorio

El sistema permite realizar checkouts y restringir commits
de un único directorio.

CVS: sí
Subversion: sí
Git: no
Bazaar: no y sí
Mercurial: más o menos

Mensajes de commit por fichero

Se pueden asignar distintos mensajes de commit a cada fichero o conjunto.

CVS: no
Subversion: no
Git: no
Bazaar: no (bzr-gtk sí)
Mercurial: no

Integración con Eclipse

CVS: sí
Subversion: sí
Git: sí
Bazaar: en desarrollo
Mercurial: sí

Estado de desarrollo

CVS: en mantenimiento. Nada nuevo
Subversion: desarrollo activo
Git: desarrollo activo
Bazaar: desarrollo activo
Mercurial: desarrollo activo

Quienes usan cada uno

CVS

SourceForge, GNU Emacs, SQLite, FreeBSD.

Subversion

SourceForge, Google Code, Apache, KDE, GNOME, gcc, Python, Ruby, Samba,
MPlayer, Mono, Django, Zope, vim y un largo etc.

Git

GitHub, Linux kernel, VLC, Perl, RoR, Android, Wine, Xorg, Fedora, etc.

Bazaar

Launchpad (Ubuntu y todos los proyectos en Launchpad), Apt,
Squid, Mailman, MySQL, Monocaffe Connections Manager.

Mercurial

BitBucket, Google Code, OpenJDK, MoinMoin, Aptitude, Xine, Xen, Mozilla, OpenSolaris, etc.

Claro que existen muchos otros VCS que los mostrados aquí, pero estos
son los más populares, los mejor documentados y son software libre.

Eclipse Helios for Linux Developers

2010-06-23T22:29:00.000+01:00

Hoy ha salido Eclipse Helios (3.6) incluyendo una serie de mejoras y ciertamente en mi caso no podía haber salido en mejor momento ya que llevo unas semanas retomando la programación con C utilizando Eclipse. Lo más llamativo en ésta ocasión es -aparte del desarrollo para J2EE6- es la versión para desarrolladores de Linux.

En estos momentos se está descargando -sobre conexión 3G va algo lento- por lo que en algunos días habrá post con los detalles e intentar explicar un poco cómo puede Helios ayudar a facilitar -aun más- el desarrollo de aplicaciones para Linux.

Java Template Engines, fight!

2010-06-16T21:53:00.000+01:00

One of the greatest features Java provides for enterprise applications, are the many
frameworks, libraries and tools provided by many third-party developers. In the web development
front, we find many useful resources and today I'm gonna compare the most popular template
systems a Java developer will find.

Basically, instead of using several HTML pages, you produce some templates which allows you
to easily maintain most of the static content of a site without having to touch 40 different files. This
way, if we want to modify the header of any site, simply by editing our header template, all the headers
on our site will change.

A template system is comprimised of three main components:

Template Engine
Content Resource
Template Resource

You can find more information about the theory behind template systems in the Wikipedia Entry.

J2EE Templates

Our candidates are:

Freemarker
Velocity
StringTemplate
MVEL

Freemarker

License:

BSD-style

Tested Version:

2.3.16

Dependencies:

None

Advantages:

XML/HTML Templates (no need to learn a new language).
Very simple and straight to the point.
Plugins for lots of IDEs.

Disadvantages:

Latest version is almost 8 months old.
Simplicity comes at a price: not as powerful as the others.

As stated on the projects' site "It simply generates text" and it does it greatly. It was very easy to get to work with it and appart from the example below, I was able to generate
SQL queries, HTML pages and Configuration files without a problem, from a file or from in-code templates. Also, having the ability to provide a OutputWriter was great.

public class FreemarkerExample extends TemplateExample{

    Configuration config = new Configuration();
    Template freemarkerTemplate;
    OutputStreamWriter output = new OutputStreamWriter(System.out);
    
    Map<String,String> dataModel = new HashMap<String,String>();
    
    public FreemarkerExample(String user){
        this.user = user;
        dataModel.put("user", this.user);
    }
    
    @Override
    public void print() {
        try {
            freemarkerTemplate = new Template("Template", new StringReader("Hello Freemarker, I'm ${user}\n"), config);
            freemarkerTemplate.process(this.dataModel, this.output);
        } catch (TemplateException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }

    @Override
    public void printFromFile() {
        try {
            freemarkerTemplate = config.getTemplate("templates/freemarker.xml");
            freemarkerTemplate.process(this.dataModel, this.output);
        } catch (TemplateException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Velocity Engine

License:

Apache

Tested Version:

1.6.4

Dependencies:

None

Advantages:

Very alive. This version is from a few weeks back.
The most powerful.
Most popular.

Disadvantages:

Ugly syntax.
Complex.

Without a doubt, the most powerful and complex project. If you take into account all the parts that conform Velocity (Engine, Tools, DVSL, Texen, Anakia, etc.) you have almost
all of your needs covered. If you take only the Velocity Engine, you'll want to rip your eyes off because of the syntax. Also, the variable names are very easy to
get lost inside complex pieces of code, and when we're talking about velocity, they will.

I really wish they followed Python's way with the syntax. Instead of using all those counter intuitive pound signs. I mean, for any Unix/Linux user, those are comments
and believe me, your mind won't get used to them, ever!

It was the hardest to get running and creating a new context can be a mess in big systems when developers start putting data in there.

public class VelocityExample extends TemplateExample {

    VelocityEngine engine = new VelocityEngine();
    VelocityContext context = new VelocityContext();
    
    public VelocityExample(String user) {
        this.user = user;
        context.put("user", this.user);
    }
    
    @Override
    public void print() {
        StringWriter writer = new StringWriter();
        StringReader reader = new StringReader("\nHello Velocity, I'm $user\n");
        try {
            Velocity.evaluate(context, writer, this.user, reader);
            System.out.println( writer.toString() ); 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void printFromFile() {
        StringWriter writer = new StringWriter();
        try {
            Template template = engine.getTemplate("templates/velocity.vm");
            template.merge( context, writer );
            System.out.println( writer.toString() ); 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

StringTemplate

License:

BSD

Tested Version:

3.2.1

Dependencies:

ANTLR

Advantages:

Powerful and simple
Not limited to Web.
Not a Java only project.

Disadvantages:

Counter-intuitive usage of the dollar sign.
Single person project. Not much activity.
Not much documentation.
No IDE plugins

Watching an article about StringTemplate is what drove me into writing this post. I thought: "finally someone is implementing a StringBuilder that behaves like it should". But no, it was another template engine, but I wanted to see how it works. And it was fast and easy to learn, but the way the the dollar sign is used kept me head banging on the table. You only have to take a look at this to cry: $if(title)$<title>$title$</title>$endif$. Now imagine a thousand lines of it.

If you get used to this syntax, having a template engine that works in several programming languages is a very good thing.

public class StringTemplateExample extends TemplateExample{
    
    StringTemplate template = new StringTemplate("Hello StringTemplate, I'm $user$");
    
    public StringTemplateExample(String user) {
        this.user = user;
        template.setAttribute("user", this.user);
    }
    
    @Override
    public void print(){
        System.out.println(template);
    }
    
    @Override
    public void printFromFile(){
        StringTemplateGroup templateGroup = new StringTemplateGroup("xml group", "templates");
        StringTemplate xmlTemplate = templateGroup.getInstanceOf("xml");
        xmlTemplate.setAttribute("user", this.user);
        
        System.out.println(xmlTemplate.toString());
    }
}

MVEL2

License:

Apache 2.0

Tested Version:

2.0.17

Dependencies:

None

Advantages:

Easiest to use of all
Nice syntax
Very alive. Latest version is from March 2010

Disadvantages:

The eval method should accept a File object directly.
No IDE plugins

I really liked MVEL2 for its simplicity and power. You get a very nice template engine and a very nice expression language which will look very familiar to Java programmers. No weird syntax and the usage of @{var} was a good decision since it's not something you see in any other place, allowing the programmer to easily adjust to the engine.

public class MVELExample extends TemplateExample{
    
    Map<String,String> map = new HashMap<String,String>();

    public MVELExample(String user) {
        this.user = user;
        map.put("user", user);
    }
    
    @Override
    public void print() {
        System.out.println((String)TemplateRuntime.eval("Hello MVEL, I'm @{user}\n", map));
    }

    @Override
    public void printFromFile() {
        try {
            System.out.println(TemplateRuntime.eval(new FileInputStream(new File("templates/mvel.xml")), map));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Conclusion

For an enterprise system the decision is clear: Velocity. It's the most known and powerful tool of them all. It might also have the ugliest syntax but if you get your mind around it and install your IDE plugin, things start looking better. If Velocity wasn't the most known of them all, I would definitely go with MVEL2 for everything, from complex systems to simple ones. From Web apps, to Swing apps.

Ubuntu Baja Resolución

2010-05-30T13:42:00.000+01:00

Ubuntu Netbook es la versión de Ubuntu para netbooks, los cuales traen unas pantallas en las que cada pixel debe ser aprovechado. Al instalar éste sabor de Ubuntu en una maquina virtual, me gusto como se distribuian los diferentes elementos básicos como el menú, la barra de tareas y la barra de título de las ventanas, así que decidí hacer lo mismo para mi portatil, el cual, con una resolución máxima de 1024x768 y una pantalla de 14'' necesita cada pixel.

Partiendo de una instalación base de Ubuntu, instalamos el Applet para GNOME "window-picker-applet" y descargamos el tema "Dust Metacity Mod". Se descomprime el tarball e instalamos con el administrador de temas los dos temas que obtenemos (aparecen como Dust Fedora).

Por otro lado, podemos incorporar sólo el efecto de eliminar las barras de título utilizando ésta parte del tema.

Ya tenemos todo lo que hace falta, por lo que vamos a eliminar la barra de abajo quitando primero todos los widgets que estén allí (barra de tareas, botón de mostrar escritorio y el workspace switcher)

Luego, movemos la barra superior a la parte inferior utilizando el dialogo de preferencias de dicha barra y eliminamos el Menú por defecto de Ubuntu. A continuación añadimos los Applets "Main Menu" y "Window Picker".

Con esto se han ganado unos 35 pixeles de espacio vertical y si utilizamos Chromium en lugar de Firefox, ganamos otros 35 pixeles

Botones en un TreeView

2010-05-19T21:53:00.001+01:00

Esto ha sido algo complicado de conseguir, pero después de algo de trial&error, he logrado añadir unos botones a un TreeView en MCM. En Internet es algo complicado encontrar información sobre esto y de hecho, no encontré nada por lo que ha tocado investigar distintas aproximaciones y al final estoy bastante contento con el resultado.

Así que, veamos como añadir un botón con imagen a un TreeView en PyGTK. Dado que no existe un CellRenderer para los botones -¿grave fallo?- hay que buscar otras soluciones como utilizar un CellRedererPixbuf o lo que es lo mismo, una imagen. En este caso voy a utilizar una del stock.

El primer método que nos interesa es para obtener la selección actual del TreeView para saber contra cual registro debemos actuar:

def get_selection(self):
    cursor = self.view.get_selection()
    model = self.view.get_model()
    (model, iter) = cursor.get_selected()
    if iter == None:
        return None
    alias = model.get_value(iter, 0)
    return alias

Es fácil ver lo que se hace aquí que es obtener a partir de la selección del TreeView los campos del registro. En este caso (MCM) el primer campo contiene el alias de la conexión el cual es único (podría haber sido un UID numérico) y es esto lo que el método va a devolver. Se puede escoger la columna deseada cambiando el valor de ese cero.

A continuación, añadimos a nuestro ListStore o TreeStore, una columna para contener imágenes, creamos la imagen que deseamos utilizar y la añadimos al ListStore junto con los demás campos del registro:

def connections_model(self):
    """Creates a ListStore with the Connections data"""
    store = gtk.ListStore(str, str, str, str, str, str, str, str, str, str, gtk.gdk.Pixbuf)
    img = self.dialog.render_icon(gtk.STOCK_CLEAR, gtk.ICON_SIZE_BUTTON)

    for cx in self.connections.values():
        cx_list = cx.to_list()
        cx_list.append(img)
        store.append(cx_list)
    return store

El ultimo argumento del ListStore es gtk.gdk.Pixbuf lo cual indica al nuevo objeto que debe contener objetos de éste tipo. En MCM cada objeto Connection, tiene un método llamado to_list() que devuelve las propiedades del objeto como una lista, añadimos la imagen a dicha lista y ésta al ListStore.

Con esto ya obtendríamos un TreeView con una imagen de stock al final de cada registro, pero ahora tenemos que hacer que dicha imagen haga algo al hacer doble-click en ella.

Para lograr esto -y aquí empieza lo complicado- vamos a utilizar el evento button-press-event del TreeView, por lo que debemos crear un método para el callback de éste evento y conectarlo con el TreeView al crearlo:

# Configure Tree Properties
view.set_headers_clickable(True)
view.connect('button-press-event', self.cell_click_event, store )

El callback de button-press-event debe recibir al widget, el evento y vamos además a añadir nuestro store ya que -aunque éste no sea el caso- nos puede ser útil:

def cell_click_event(self, widget, event, store):
    path = widget.get_path_at_pos(int(event.x), int(event.y))
    #row = int(path[0][0])
    column = path[1]
    col_title = column.get_title()
    if col_title == 'Delete' and event.type == gtk.gdk._2BUTTON_PRESS:
        alias = self.get_selection()
        dlg = UtilityDialogs()
        response = dlg.show_question_dialog(constants.deleting_connection_warning % alias, constants.are_you_sure)
        if response == gtk.RESPONSE_OK:
            del self.connections[alias]
            self.redraw_tree()

El elemento más útil aquí es el objeto event del tipo gtk.gdk.Event con el cual vamos a obtener algo como esto:

<gtk.gdk.Event at 0x1ed9b20: GDK_BUTTON_PRESS x=1000.00, y=31.00, button=1>

Eso dos campos (x,y) son las coordenadas donde se ha hecho el click y con esto podemos obtener un path con el cual obtener la columna y el registro sobre el que se está actuando. Dicho path contiene la siguiente información:

((3,), <gtk.TreeViewColumn object at 0x2684af0 (GtkTreeViewColumn at 0x27d09b0)>, 27, 13)

El primer valor de la tupla path es una tupla en la que el primer valor es el indice del registro sobre el que nos encontramos. Está comentado ya que gracias al metodo "get_selection()" no nos hace falta, pero sabemos que hemos actuado sobre el cuarto registro del TreeView. Lo que nos interesa de aquí es el TreeViewColumn del que vamos a obtener su titulo y si se cumplen las condiciones: doble-click sobre la columna con titulo Delete, actuamos, en este caso mostrando un dialogo de confirmación, borrando el registro y dibujando el TreeView.

Monocaffe Connections Manager 0.9.3

2010-05-11T19:11:00.000+01:00

Nueva versión disponible de Monocaffe Connections Manager: 0.9.3

http://launchpad.net/mcm/

Se han añadido las siguientes carácteristicas:

Cliente VNC integrado
Edición de conexiones
Formulario para reportar fallos, ideas o spamearme.
Mensaje de error al fallar un cliente
Traducciones al francés, alemán y castellano.

Se han resuelto algunos fallos gracias a los reportes de algunos usuarios.

Finalmente, screenshot!

PyGTK Colores por defecto

2010-05-04T00:59:00.000+01:00

Me he encontrado con un pequeño problema al intentar modificar los colores de los campos de MCM ya que es bastante complicado encontrar los colores por defecto utilizados por el tema. El problema se acentuaba al utilizar temas oscuros ya que se modificaban los colores de la aplicación para pintar los campos con fondo blanco.

Un poco de trial & error y esto es lo obtenido:

class DefaultColorSettings(object):
    def __init__(self):
        def_settings = gtk.settings_get_default()
        color_scheme = def_settings.get_property("gtk-color-scheme").strip()
        color_scheme = color_scheme.split("\n")

        settings = {}
        for property in color_scheme:
            # property is of the type key: value
            property = property.split(": ")
            settings[property[0]] = property[1]

        self.tooltip_fg_color = gtk.gdk.color_parse(settings["tooltip_fg_color"])
        self.selected_bg_color = gtk.gdk.color_parse(settings["selected_bg_color"])
        self.tooltip_bg_color = gtk.gdk.color_parse(settings["tooltip_bg_color"])
        self.base_color = gtk.gdk.color_parse(settings["base_color"])
        self.fg_color = gtk.gdk.color_parse(settings["fg_color"])
        self.text_color = gtk.gdk.color_parse(settings["text_color"])
        self.selected_fg_color = gtk.gdk.color_parse(settings["selected_fg_color"])
        self.bg_color = gtk.gdk.color_parse(settings["bg_color"])

Básicamente, todos los componentes que se configuran con los temas de GNOME llegan a nuestras aplicaciones a través de gtk.gdk.Screen. Con "settings_get_default" obtenemos distintos aspectos de la configuración del tema: colores, tamaños de iconos, sonidos, etc.

Para lo que nos incumbe ahora, obtenemos "gtk-color-scheme" el cual es un str con los distintos colores. En MCM mi solución fue la de crear una clase DefaultColorSettings y luego utilizar DefaultColorSettings.base_color para redibujar los campos a su estado original cada vez que cambiaba los colores de los mismos.

MCM en Varias Distros

2010-04-27T15:52:00.001+01:00

Ubuntu Lucid Lynx 10.04 RC
Funciona, aunque da problemas el nuevo tema "Ambience" http://bugs.launchpad.net/mcm/+bug/570600 y la verdad es que el tema de los colores y los nuevos botones no me gusta nada.

Fedora 12
Hay un pequeño problema en el script de instalación ya que el directorio /usr/share/apps no existe. Sólo fue añadir la opción "-p" al mkdir y todo perfecto.

OpenSUSE 11
Destacar que el LiveCD de OpenSUSE es el único con soporte para ratón integrado de VirtualBox y que además, arranca con una buena resolución. Sólo hará falta instalar el paquete "python-xdg" o algo por el estilo. Buscad xdg y os aparece.

Kubuntu Karmic Koala 9.10
No había usado Kubuntu en mucho tiempo y sólo puedo decir: WOW! Es un espectaculo, pero demasiado cargado para mi gusto. Ha sido el más complicado ya que hay que instalar dos paquetes: python-glade2 y python-vte. Ya estan añadidas esas dependencias al paquete .deb

Linux Mint 8
Ha sido la más sencilla ya que viene con todos los repositorios añadidos al apt. La verdad, me ha encantado la tematica y el cuidado que se le da a los diferentes aspectos estéticos.

No he podido probar con las siguientes distros con las que lo he intentado: Arch (hay que instalar), Slax (no parece tener un buen soporte para PyGTK ya que no encontre los "modulos").

Estructura de la memoria de Objetos Java

2010-04-20T00:54:00.000+01:00

Un poco de teoría bajo nivel sobre el funcionamiento de Java y como maneja la memoria. Esto es un repaso sencillo de cómo Java maneja la memoria, cuanta memoria utiliza un objeto y como mejorar la utilización de memoria de nuestros objetos.

Shallow Copy Size vs Deep Size

Shallow Copy Size es la cantidad de memoria ocupada por un sólo POJO al crearlo. Deep Size por otra lado, es la cantidad de memoria que ocupa un POJO sumado a la memoria utilizada por todos los POJOs que referencia.

Los 8 bytes

Todos los objetos en Java deben tener un tamaño que sea múltiplo de 8 bytes, es decir, una granularidad de 8 bytes. La razón de esto es la facilidad de los distintos sistemas operativos y procesadores de convertir direcciones de memoria a registros de cuatro en cuatro (o de ocho en ocho para sistemas de 64bits). Esto es así para todas las plataformas a diferencia de C o C++ que utilizan distintos tamaños de memoria para tipos primitivos.

Todos los objetos -menos los arreglos ( String [] array )- tienen una cabecera de dos direcciones, donde la primera es un código Hash de identificación y la segunda contiene una referencia a la clase del objeto. De esta forma, al instanciar un nuevo objeto Object() se utilizarán 8 bytes de la memoria heap (no entremos en las demás posibilidades ahora) para mantener el uid y la referencia ya que Object() no tiene ningún campo o variable.

Despues de estos 8 bytes de la cabecera, siguen los bytes necesarios para los atributos de la clase, los cuales siempre son alineados en la memoria según su tamaño:

- double y long
- float e int
- char y short
- boolean y byte

Reestructuración de nuestras clases.

La JVM es capaz de ordenar los atributos de nuestras clases de tal manera que los nuevos objetos no ocupen más memoria de la que necesitan.

Class DespilfarradorDeMemoria {
    byte a;
    int b;
    boolean c,
    long d;
    Object e;
}

Si la JVM no fuera capaz de reordenar los atributos de esta clase al instanciarla, nuestro nuevo objeto desperdiciaría unos 14 bytes de memoria:

Se puede ver en la imagen como se va reservando memoria para mantener al objeto dentro de un múltiplo de 8 bytes por lo que se desperdicia mucha memoria. Para esto la JVM es capaz de ordenar los atributos de tal manera que sólo se utilice la cantidad de memoria necesaria y se reduzca al mínimo la consumida para relleno. La imagen del objeto instanciado sería la siguiente:

Gracias a esto, se reduce el consumo innecesario a 6 bytes y en total 32 para dicho objeto.

Calcular el consumo de memoria

Ahora podemos calcular el consumo de memoria de cualquier objeto que extiende de Object() directamente. Probemos con un boolean:

Por increíble que parezca, una instancia de un objeto boolean consume ¡16 bytes! De estos 16, 7 son usados como relleno para mantener la granularidad. Este es el coste de que todo en Java sea un objeto.

Las mezclas son malas

Whisky, cerveza y tequila: malo. Mezclar atributos entre clases de la hierarquía: muy malo. La primera regla es: primero los atributos de las clases padres seguidas por los atributos de las clases instanciadas.

La imagen describe la asignación de memoria para los objetos "Hija":

class Padre{
    long a;
    int b;
    int c;
}

class Hija extends Padre{
    long d;
}

La segunda regla es que se utilizará un relleno entre las asignaciones de dos objetos para separarlos y lograr la granuralidad de 4 bytes:

class Padre{
    byte a;
}

class Hija extends Padre{
    byte c;
}

Como se puede ver, se utiliza un relleno de 3 bytes para obtener 12 bytes, los cuales no pueden ser utilizados para los atributos del objeto siguiente.

La tercera y ultima regla viene a establecerse para casos concretos en los que la segunda regla no puede ser aplicada, como cuando el primer elemento de la clase hija es un "long" o un "double" y la clase padre no termina con un limite de 8 bytes.

class Padre{
    byte a;
}

class Hija extends Padre{
    long b;
    short c;
    byte d;
}

Cuando el primer campo de una sub-clase es un double o un long y la super-clase no se alinea a los 8 bytes, la JVM romperá la segunda regla e intentará colocar los campos int, short, byte y referencias al principio del espacio reservado para la sub-clase hasta que se rellene por completo.

En la imagen se puede ver que en el byte 12 cuando la clase Padre ha terminado, se comienza con un short de 2 bytes y un byte de 1 byte antes del long para ahorrar 3 o 4 bytes que de otra forma se habrían desperdiciado:

Como siempre tenemos otro caso especial con las clases internas no estáticas, la cuales tienen un campo escondido que mantiene la referencia a la clase a la que pertenece. Esta es una referencia regular que sigue los mismos principios anteriores. Por esto, las clases interntas tienen un coste extra de 4 bytes.

Monocaffe Connections Manager 0.9.2

2010-04-09T17:21:00.000+01:00

Nueva versión de Monocaffe Connections Manager 0.9.2

Esta es una revisión menor sobre el código de 0.9.1. Se arreglan algunos fallos menores y se han añadido y quitado cosas.

Una de las cosas que me ha gustado es la posibilidad de ejecutar comandos SSH si los incluimos dentro de las opciones de la conexión. Por ejemplo, he creado un grupo llamado "MyJBoss" donde tengo una serie de conexiones SSH llamadas: myjboss-server.log, myjboss-access.log, etc. En las opciones de myjboss-server.log he añadido lo siguiente: "tail -f /opt/jboss/server/default/log/server.log". De esta forma, al utilizar esta conexión, veo directamente este log.

Podéis descargarlo del lugar habitual:

http://launchpad.net/mcm/+download

MCM en Lubuntu 10.04

2010-04-08T09:46:00.000+01:00

Hoy he instalado Lubuntu 10.04 en una máquina virtual para comprobar la instalación de MCM y mis primeras impresiones con esta primera iteración de LXDE para Ubuntu son muy positivas.
La instalación de MCM ha funcionado igual que en Ubuntu y no he detectado ningún problema despues de realizar las pruebas pertinentes.
Lo que más me ha llamado la atención de Lubuntu es que el navegador que viene por defecto instalado es Chromium que además, con su temática de tonos azules, se asemeja más al de LXDE.

Esta es la ventaja más importante de desarrollar con PyGTK: no estas limitado a GNOME, ya que muchos de los otros Desktop Managers como LXDE y XCDE utilizan GTK. Espero algún día ver un Desktop Manager ligero basado en Qt.

Reparar conflictos en Bazaar

2010-03-17T16:52:00.000Z

Bazaar es el sistema de control de versiones utilizado por Launchpad para sus proyectos, por lo tanto Monocaffe Connections Manager utiliza Bazaar. Al igual que CVS, SVN y GIT, bazaar (bzr) tiene sus raíces en la línea de comandos, pero además aporta una herramienta GTK muy fácil de utilizar llamada Olive

Una de las cosas más llamativas de Bazaar es la resolución de conflictos. Cuando intentamos realizar un commit contra una rama que está en conflicto con nuestra rama local, Bazaar creará tres ficheros: .OTHER, .THIS y .BASE. Para resolver el conflicto podemos utilizar vimdiff, emacs o meld. Por defecto, Olive intentará utilizar meld, por lo que recomiendo tenerlo instalado y porque además es muy útil la herramienta.

Estos tres ficheros serán abiertos por Meld, por lo que sólo tenemos que integrar los cambios que deseamos tal que los tres ficheros sean iguales (no entremos en detalles sobre cada uno de los ficheros y las posibilidades, esto es lo más sencillo y rápido para resolver el conflicto). Guardamos los ficheros y cerramos Meld. Aquí nos encontramos con un pequeño detalle del que adolece Olive, no tiene ninguna opción para resolver el conflicto, por lo que tendremos que tirar de línea de comandos y ejecutar lo siguiente:

bzr resolve file.txt

De esta forma, los tres ficheros desaparecerán y podremos realizar nuestro commit.

NACAR

2010-03-16T15:44:00.000Z

Finalmente puedo decir que sé lo que es NACAR. Después de mi entrada volví a ver una mención sobre NACAR y decidí comentarlo con la gente del curro. Uno de ellos se encontró con éste documento de Accenture.

NACAR (Nueva Arquitectura de Canales de Acceso Remoto) o como lo solemos llamar comúnmente: SOAP. Con lo de canales se refiere a nivel bancario: telecajeros, oficinas, banca por Internet, etc. Así que ¿es un SOAP bancario?

En fin, el documento no explica mucho a nivel técnico, por lo que no se pueden sacar más conclusiones. De todas formas suena demasiado "enterprisy".

Glade3 y GtkBuilder

2010-03-16T11:39:00.000Z

Glade es una herramienta que permite realizar RAD (Rapid Application Development) con una interfaz muy sencilla de utilizar para aplicaciones GTK+. Glade genera unos ficheros .glade que son xml y pueden ser leidos por las muchas implementaciones de GTK+ para Java, C, C++, Python, Perl y un largo etcétera.

Con Karmic Koala viene la nueva versión 3.6.7 de Glade que incluye un muy buen soporte para GtkBuilder.

GtkBuilder y Libglade

GtkBuilder va a reemplazar a Libglade en el futuro no muy lejano y GtkBuilder forma parte integral de GTK, por lo que no hace falta añadir más dependencias a nuestros proyectos. Además, al utilizar GtkBuilder, podemos crear nuevos objetos y acciones que antes se tenian que crear en el código. Por ejemplo, los ListStore para añadir a los Views facilitan mucho la creación de este tipo de widgets.

La razón por la cual se cambia de Libglade a GtkBuilder es que se ha convertido en algo muy común desarrollar la UI de forma dinámica en Glade por lo que no tenía sentido que el propio core de GTK no lo soportara. Aquí es donde entra GtkBuilder para además, añadir nuevas funcionalidades. La verdad es que no hay nada malo con Libglade, sólo que GtkBuilder extiende sobre Libglade y se añade directamente a GTK, haciendo el funcionamiento más sencillo y rápido.

PyGTK

Para utilizar GtkBuilder en Python, seguimos las mismas pautas que con libglade, es decir, cargar el fichero, conectar las señales y obtener los widgets para actuar sobre estos.

import gtk

x = gtk.Builder()

x.add_from_file("/tmp/test.glade")

y = x.get_object("window1")

y.show()

Cabe recalcar que MCM está desarrollada con Libglade y que poco a poco iré migrando a GtkBuilder viendo las posibilidades.

Domingos de trabajos I

2010-03-07T21:54:00.001Z

Los domingos por la noche me llegan al correo electrónico un resumen de ofertas de trabajo de InfoJobs desde hace años y las risas que me echo me indignan y creo que es hora de compartir esto. Empecemos con ésta:

Ni de coña

Precisamos de la incorporación de Desarrolladores en C embebido, drivers (microprocesadores a bajo nivel). Al menos 2 años de experiencia. Experiencia en C embebido. 18.000 € - 21.000 € Bruto/año

Programar en C y bien es muy jodido en x86, ahora imaginamos quitar el 90% de la memoria, un hardware con arquitecturas especiales y empezamos a ver lo complicado que es esto. ¿glibc?¿Qué es eso? Da suerte que puedes compilar y no bajar a ensamblador. Este tipo de labor conlleva conocer el lenguaje de programación tan bien que no existan fallos ya que es un poco difícil flashear una ROM vía Internet. Ambienta se deben conocer las distintas arquitecturas, APIs, librerías (si es que las tiene) y fallos de una gran variedad de chips. Muchas veces tendrá que además bajar a desarrollar en ensamblador (aunque no lo pone en la oferta, esto es casí seguro) por lo que una persona con éste nivel y vocación dudo que vaya a reducirse a cobrar 1.200€ al mes. Bueno, aunque por el momento hay dos inscritos en la oferta.

Generalista de cárnica

Estas son las ofertas de "vamos a hacerle perder el tiempo a la peña" ya que no se especifican proyectos, sólo te hacen la entrevista y cuando le cuelen el cuchillo a algún ministerio, ahí que vas... 6 meses después y con el CV hinchado.

Lo peor de ésta oferta es que ni siquiera se dignan a gastarse el dinero en sacar ofertas específicas para cada entorno. Quizás me equivoco y busquen a un tío que sepa de las dos (jeje). Lastima que no indiquen el rango de sueldos. En lo que me compete: "Entornos de desarrollo: Netbeans, Eclipse, UML." Claro signo de que vas a perder tu tiempo haciendo una entrevista con ellos.

Me aburro con leerte

No es que trabajar deba ser un deleite y pocas personas tienen la suerte de trabajar en lo que les gusta y en temas interesantes que sacan a relucir su ingenio, pero por lo general a los programadores nos gusta nuestro trabajo, aunque dudo que los candidatos a ésta oferta lleguen a casa para continuar con éste:

Quizás me equivoque y es probable que la persona elegida vaya a ganar una pasta, pero no se puede negar que suena a trabajo en cubículo gris, en edificio sin ventanas y de traje con corbata.

Nacar

Hace más de un año un colega me preguntó si sabía que era eso de Nacar ya que por lo visto tenía algo que ver con Java. Yo le pedí que me mostrase la oferta para ver si estaba diciendo alguna burrada, pero no, buscaban desarrolladores de Nacar para la zona norte de Madrid. Dicha oferta la volví a ver muchas veces y sinceramente creía que hoy la volvería a ver, pero no, es otra:

Después de toda la synergia que se utiliza para motivar a posibles candidatos viene el tema de NACAR que sigo sin conocer de qué va, así que si algún lector se digna a explicármelo. Por supuesto que una búsqueda en Google resulta infructuosa. NAKAR habría facilitado mucho el trabajo. He llegado a plantearme que sea una oferta trampa para pillar a alguno.

No sé qué quiero, pero lo quiero todo

Ejemplo perfecto de una oferta de trabajo que no saben ni lo que quieren:

Es decir, quieren un tío, no tía (lo dice la oferta) con 10 años de experiencia en ir dando botes sin saber qué hacer con su vida: 2 de C++ Linux (¿GTK?, ¿Qt?, ¿Tc?) 2 de C++ Windows, 2 .Net Windows, 2 .Net Linux (¿Mono?) y 2 en BB.DD. Fantástico lo específico de la oferta, seguro que llegas y el trabajo es de PHP + ActionScript + iPhone.

Si la anterior sufre de ser poco específica, la siguiente es un despilfarro de ancho de banda:

Leyendo la lista no puedo dejar de preguntarme si realmente existe alguien que... ¿Symbian? Vale, ésta gente está flipando en colores. Lo que me llamo la atención fue el título "Programador Web Python". Mira que chulo - pensé. Pero luego meten JSF y Struts y tiran RoR, un poco de jQuery por aquí y por allá, mezclamos con WebOS y Maemo, una pizca de iPhone y de Android, unas cucharaditas de MySQL y de PostgreSQL, untamos una salsa de CMS's más rica que la salsa rosada (Drupal, Joomla y WordPress) y para finalizar gratinamos con Visio y Office. Resultado, 1.300€/mes y 6 inscritos que no deben haber leído bien la oferta. LMAO!!!

No todo es tan malo

Claro que no todas pueden ser malas o peores, alguna decente tiene que haber... estoy buscando... todavía... digo yo que alguna habrá... por fin, aunque de dicha empresa no haya escuchado cosas buenas:

Posibilidades de irte de paseo por Europa, ganar más dinero y utilizar Flex, que es de lo mejorcito que se ha creado en los últimos años. Se ve que conocen del tema al no pedir 3 años de experiencia en Flex. Lo malo es que no especifican el rango salarial y que poca gente se quiere ir a Luxemburgo con dicha empresa sin saber por cuanto: una.

Bash debug/failure

2010-03-01T14:42:00.002Z

Cuando realizo scripts en Bash que son bastante complicados y deseo ver muy bien lo que estan haciendo, suelo crear una funciona llamada debug tal que:

debug () {
    if [ ${DEBUG} -eq 0 ]; then
        echo "[DEBUG] ${1}" 
        return 0
    else
        eval "${1}" > /dev/null 2>&1
        return $?
    fi
}

Por lo que en lugar de hacer las llamadas directamente, se utiliza esto:

debug "mv ${old} ${new}"

Si ejecutamos el script con la variable DEBUG=0 entonces, en lugar de ejecutar el comando, aparecerá el mensaje de debug con el comando. El mayor problema de esto y que se tiene que tener muy en cuenta, es que con esta función tambien podemos incluir comentarios como:

debug "Vamos a mover el directorio"

Estos comentarios no nos traen problemas ya que eval intentará ejecutar Vamos como si fuera un comando y fallaría sin problemas, pero cuidado con estos comentarios.

Otra función que está en mi "Toolbox" es failure:

failure () {

    if [ ${1} -ne 0 ]; then

        echo "[FAIL] (${1}): ${2}"

        exit ${1}

fi

}

La utilizamos después de ejecutar cualquier comando:

failure $? "Failed to mkdir ${archive_dir}${2}"

La función recibe el código de salida del comando anterior y muestra el mensaje que deseamos en caso de haber fallado. En caso de fallar, devuelve el código de error del comando como el código de error de nuestro script. Tambien podemos utilizarla para resolver algún otro test:

if [ -z "${1}" ] ; then
failure 1 "No existe el directorio ${1}"
fi

Las dos funciones pueden ser utilizadas en conjunto:

debug "mkdir ${archive_dir}${2}"

failure $? "Failed to mkdir ${archive_dir}${2}"

Además, las ventajas de estas dos funciones es que podemos escribir en un log sin modificar todas nuestras lineas, podemos añadir colores y modificar el formato de salida en un solo lugar y funcionan bastante bien.

Código fuente en Blogger con code2blog

2010-02-25T12:24:00.000Z

Hoy he descubierto una herramienta llamada code2blog:

Es una herramienta muy sencilla que funciona como GUI para source-highlight, excelente herramienta de Lorenzo Bettini. Es una herramienta muy sencilla que utiliza PyGTK y Glade y es sólo un fichero de 34K. Para utilizarla primero la descargamos:

wget http://code2blog.googlecode.com/svn/trunk/code2blog

Si tenemos instalado source-highlight ejecutamos con python y listo. Un ejemplo del HTML generado:

def scan_tree(pathname, calls=['_']):
    """Scans a tree for translatable strings."""
    out = StringCollection(pathname)
    for folder, _, files in os.walk(pathname):
        for filename in files:
            filename = os.path.join(folder, filename)
            if filename.endswith('.py'):
                result = scan_python_file(filename, calls)
                if result is not None:
                    for lineno, string in result:
                        out.feed(filename, lineno, string)
            elif filename.endswith('.glade'):
                result = scan_glade_file(filename)
                if result is not None:
                    for string in result:
                        out.feed(filename, None, string)
    for line in out:
        yield line

Monocaffe Connections Manager 0.9.1

2010-02-22T12:06:00.000Z

He sacado un revisión de la versión 0.9 de MCM para arreglar algunos fallos que pueden ser molestos para algunos usuarios y añadido características que no deben influenciar en su uso.

Podeis descargar la nueva versión aquí.

PuTTY Opciones

2010-02-14T21:37:00.000Z

Buscando en la red información para importar ficheros de registro de PuTTY a MCM, he encontrado una aplicación que se parece bastante a MCM y que tienen muy buena pinta.

PuTTY Connection Manager

Es muy parecido a MCM, por lo que permite conectar a diferentes sesiones de SSH y utiliza pestañas para navegar. De igual forma tiene un árbol que muestra las conexiones del usuario.

Diferencias con MCM:

Sólo para SSH, Telnet ¿y FTP?
Sólo para Windows
No permite enviar comandos a varias terminales (cluster mode).
No tiene una barra de referencia.
No es OSS.
Tiene una opción que me gusta por la cual permite el Autologon y se la voy a copiar :)

Es una solución para usuarios de Windows que deseen algo parecido a MCM, pero claro, sin toda la funcionalidad que podrían tener si usarán Linux.

Indagando un poco más he encontrado incluso más soluciones para Windows:

mRemote

Es GPL y solo funciona sobre Windows pero soporta todo tipo de conexiones (incluso ICA).

Poderosa

Es parecido a PuTTYCM aunque no han lanzado ninguna nueva versión desde el 2006.

Así que para Windows existen soluciones muy buenas y estables (con cosas muy interesantes para copiar), por lo que ni me molesto :)

Tanslations in Monocaffe

2010-02-13T21:48:00.000Z

I've uploaded the necessary changes to Monocaffe so it can be easily translated to different idioms. Any one can help on translations to their respective idioms.

我已经上传到Monocaffe必要的变化，可以很容易地转换为不同的成语。任何人能够帮助到他们各自的成语翻译。

He pujat els canvis necessaris per Monocaffe per la qual cosa es pot traduir fàcilment a diferents idiomes. Qualsevol pot ajudar en les traduccions als seus idiomes respectius.

Olen ladannut tarvittavat muutokset Monocaffe joten se on helppo kääntää eri sanontojen. Tahansa voi auttaa käännöksiä omille idioms.

Ich habe die notwendigen Änderungen an Monocaffe hochgeladen wurde, so kann es leicht auf verschiedene Idiome übersetzt. Jeder kann helfen, auf Übersetzungen in ihre jeweiligen Redewendungen.

Ho caricato le modifiche necessarie per Monocaffe in modo che possa essere facilmente tradotto in idiomi diversi. Nessuno può aiutare il traduzioni alle proprie rispettivi idiomi.

Я загрузил необходимые изменения в Monocaffe поэтому она может быть легко переведена на различные идиомы. Любой может помочь на переводы в свои соответствующие идиомы.

Jag har lagt upp de nödvändiga ändringarna Monocaffe så det kan lätt översättas till olika idiom. Någon kan hjälpa på översättningar till sina respektive idiom.

He subido los cambios necesarios para Monocaffe por lo que se puede traducir fácilmente a diferentes idiomas. Cualquiera puede ayudar en las traducciones a sus idiomas respectivos.

Fiz upload as mudanças necessárias para Monocaffe para que possa ser facilmente traduzidas para idiomas diferentes. Qualquer um pode ajudar em traduções de seus respectivos idiomas.

http://translations.launchpad.net/mcm/trunk

Desarrollo de Monocaffe Connections Manager

2010-02-07T17:17:00.000Z

Varias personas ya me han preguntado cómo he desarrollado MCM y ésta entrada va de ello, sobre las herramientas y tecnologías utilizadas y la justificación detrás de cada una de las razones y consecuencias. Aunque parezca una aplicación sencilla, utiliza muchas tecnologias creadas por muchas otras personas y que sin alguna de estas, quizás MCM no existiria.

Resumen

Python

PyGTK
VteTerminal
minidom
json
csv
urllib
optpars

exuberant-ctags

Glade
Bazaar
Dialog

Desarrollo

En su totalidad, MCM está escrito en Python y utilizando sólo las herramientas propias de Python y PyGTK. Esto me permite distribuir MCM sin que dependa de instalaciones complicadas o de cientos de paquetes ya que estos vienen por defecto con cualquier instalación de GNOME.

mcm + vim + exuberant-tags

Para escribir MCM, ninguna herramienta mejor que VIM. Exuberant-ctags permite mostrar una ventana dentro de VIM para navegar las clases y métodos de un fichero.

GUI

Para crear el GUI, se crea la mayoria de ventanas y dialogos utilizando Glade. Es un GUI para crear GUI's. Con una interfaz sencilla podemos crear todos estos widgets y configurar sus propiedades y señales. Para efectos dinamicos o widgets más complicados (como el breadcrumb) utilizamos PyGTK directamente. Despues de crear los widgets y sus señales, para manejarlas en código debemos leer el fichero que genera Glade (un XML):

gtk.glade.XML(glade_file)

Para interactuar desde el código con los objetos creados por libglade, debemos referenciarlos:

self.main_window = self.xml.get_widget("main_mcm")

Glade permite ahorrar una cantidad de trabajo y código gigante. Al ser XML los ficheros que genera, no es necesario utilizar Glade para realizar modificaciones sencillas (nombres de objetos, señales, etc.) y creo que cualquier lenguaje serio tiene una librería para leer estos ficheros y generar interfaces.

Con Glade hay que ir con cuidado porque de vez en cuando le da por no funcionar como debe, pero nada que no se arregle guardando a menudo y reiniciando.

Launchpad

En launchpad.net se nos ofrece para nuestro proyectos OSS todo lo necesario y a la ultima, como el gestor Bazaar que viene con una GUI muy sencilla. Bazaar es un sistema de versiones distribuido, lo que significa que no hace falta un repositorio central para utilizarle. Los merge se hacen de forma muy sencilla al igual que crear ramas. El sistema de gestión de bugs de Launchpad es muy sencillo y me gusta mucho la relación real que existe entre los fallos, los milestones y los releases. Tambien ofrecen una herramienta para ayudar en la traducción de proyectos, pero hace falta algo de trabajo para hacerla funcionar correctamente y espero conseguir tiempo en el futuro para esto.

¿Microsoft Windows?

Dado que GTK y Python funcionan perfectamente sobre Windows, me imagino que MCM también. No he llegado a probarlo por lo que si alguien se anima, que me comente sus resultados y si hay interés, se puede hacer una rama aparte para su desarrollo. El único problema que veo ahora mismo sería el modo en el que se generan las terminales utilizando VteTerminal y no estoy seguro de que estas funcionen correctamente en Windows.

Wooops... Fallo en MCM 0.9

2010-02-07T14:53:00.000Z

Gracias a mis beta testers :) he arreglado un par de fallos en la nueva versión de MCM 0.9. Por una parte, el script de instalación no copia el fichero "tips.json" al directorio del usuario, el script de arranque no añadía una nueva linea de configuración "buffer.size" al fichero mcm.conf y finalmente, por alguna razón mágica, Glade dejo de escribir las señales de los eventos para las acciones de importar y exportar. Todos estos fallos has sido resueltos, así que si habéis tenido estos problemas, descargad los ficheros nuevamente y todo debería funcionar sin problemas.

Monocaffe Connections Manager 0.9

2010-02-04T00:43:00.000Z

Nueva versión de Monocaffe Connections Manager con una gran adición de la que estoy muy contento. Un widget al estilo breadcrumb para acceder a referencias a comandos, tal que el usuario no tenga que recordar cada opción, comando o conjunto de teclas de cada aplicación que usa.

Este widget además permite añadir nuevos "Tips" y compartirlos con el mundo. Aun hay que desarrollar un poco más éste widget, pero es 95% funcional y espero os guste la idea.

Tambien se han resulto algunos fallos y molestias que mis compañeros de trabajo han ido encontrando al utilizar mcm y es que tengo un equipo de beta-testers de elite.

Screenshot!

Descargad desde aquí:
http://launchpad.net/mcm/+download

Venga Yahoo!

2010-01-03T01:00:00.001Z

Mi cuenta de correo personal durante mucho tiempo (diciembre de 1997) ha sido bajo el dominio Yahoo.com. Entonces, tengo una cuenta de correo con 12 años de historia a sus espaldas y a la que he entrado día tras día. Poco a poco ha sido semana tras semana y últimamente, cuando me acuerdo.
¿Qué demonios le ha pasado a Yahoo para que no evolucione o se adapte a las nuevas tecnologías? ¿Cómo pierden a un usuario después de 12 años?
Por gilipoces como estas:

Sólo os falta "Yahoo! Recommends Windows 7" en el mensaje ese.
Ya llevo un tiempo con éste mensaje: ¡desde el 2007! ¿En dos años no habéis podido montar un Ubuntu, Fedora o Debian y probarlo? ¿Qué clase de mensaje enviáis a vuestros usuarios al respecto? Os lo digo yo: que sois patéticos. Además me recomendáis a "actualizar mi sistema" ¡lo he actualizado 5 veces desde que lanzasteis la nueva versión de Yahoo! Mail! Hasta KDE ha sacado una nueva versión en todo éste tiempo y vosotros con el mismo mensaje.
Más patético aun es que estáis mostrando un mensaje sobre un sistema operativo, lo cual es ridículo para una plataforma independiente, ya que para vuestro gran asombro, funciona sobre un navegador o como vosotros seguro lo llamáis: el internet o la "E" azul.
Si no sois capaces de comprender ésta diferencia, que esteis tan desfasados en comparación a Google y Microsoft no me asombra nada. Sólo con utilizar otros de vuestros "servicios" se puede ver que sois un ente moribundo de la red. El "Bloc de Notas" y vuestro calendario son lo mismo de hace 10 años y las únicas diferencias son que los banners de publicidad son más grandes para acomodar las nuevas resoluciones de los monitores.

Este es otro tema que me enerva de Yahoo! Mail, es imposible de utilizar a 1024x768. ¿Quién usa esas resoluciones hoy en día? ¡Despertad! ¡Los netbooks! (Bueno, y la gente mayor que tiene problemas de vista) Así que ¿en qué demonios estáis trabajando? ¿En añadir más publicidad basura a vuestros banners? Porque esto es lo que ha derramado el vaso, que un sitio que llevas utilizando durante doce años, muestre un banner con audio que casi me deja sordo.
Ciertas cosas sí he de reconocer y es que las nuevas aplicaciones para teléfonos móvil son realmente espectaculares y el L&F de la versión web es también muy llamativo (aunque no se pueda cambiar) y las librerías JS son realmente útiles y no demasiado pesadas, pero se pueden mejorar, mucho.

Yahoo! Go en el N95

Sólo eso es lo que me gustaría, que mejoréis para que un día no me encuentre mi vieja dirección de correo (mi primera) bloqueada porque llevaba seis meses sin acceder a ella.
Una ultima cosa, desde que lanzasteis la versión Beta de Yahoo! Mail al público, funciona bastante bien en Ubuntu, Fedora y CentOS... perdón ¡en Firefox, en Chromium y en Opera!

Yahoo! Mail en Ubuntu 9.10 64... digo, en Firefox.

Java7 Closures

2009-12-24T00:56:00.001Z

Al votar hoy en la encuesta de JavaHispano.org acerca de los closures en Java 7 pude ver que los resultados reflejaban que una gran cantidad de personas registradas en este sitio no conocen los closures. La verdad es que cualquier programador que haya trabajado con otros lenguajes como Lisp, JavaScript o Ruby conocerá los closures decerca. Incluso Groovy, tiene closures.

Funciones-objeto y closures

Lo primero que hay que entender es la diferencia entre funciones como objetos y closures. Una función puede ser anónima o definida, pero también pueden ser objetos en si mismas. Esto nos permite utilizar funciones como argumentos, ser devueltas por otras funciones o ser almacenadas en estructuras de datos. Vamos, son objetos de primera clase o de primer orden.
Un closure es una función más su entorno y estos pueden ser de igual forma tratados como objetos de primera clase, pero al contener un entorno, podemos acceder a variables (o funciones) de este entorno incluso cuando el mismo no este activo. Existen lenguajes que soportan funciones-objetos o closures o ambos, y muchos de los lenguajes funcionales en su mayoria utilizan funciones y funciones-closure.
Entonces, un closure, por ejemplo, nos permite definir una función que tiene acceso a una variable, así que podemos almacenar esta funcion en un objeto y acceder a ella. El contexto de la función no se limita sólo a los objetos a los que tiene acceso directo, pero también a las variables que obtiene vía el entorno.

¿Cómo encaja esto dentro de Java?

Veamos un ejemplo clásico de sort con un método anónimo:

anArray.sort(new Comparator() {
public int compare(MyClass a, MyClass b) {
return a.myProperty().compareTo(b.myProperty();
}
});

Con closures haríamos esto:

anArray.sort( (a, b) => a.myProperty().compareTo(b.myProperty() );

Es algo muy usual realizar operaciones sobre cada objeto de una lista, por ejemplo:

public List squareIntegers( List iList) {
List result = new ArrayList(iList.size());
for (Integer i : iList){
result.add(i*i);
}
return result;
}
iList = squareIntegers(iList);

Con un closure:

iList = iList.map( { Integer i => i*i } );

Pero estas son realmente funciones-objetos que son pasadas como argumentos a otras funciones. Así que una
definición teórica de closure, es decir, un método que puede obtener o hacer "close over" sobre el contexto del código al que pertenece sería:

public Collection getSpanishDvd( Collection dvds ){
return select( dvds, { Dvd aDvd => dvd.isSpanish() } );
}
public static Collection select(Collection source, {T=>Boolean} predicate) {
Collection result = new ArrayList();
for (T o : source) {
if (predicate.invoke(o)) result.add(o);
}
}

¿Son utiles los closures?

En lenguajes como Python llevan mucho tiempo discutiendo sobre la necesidad de lambda y la verdad es que IMO no son algo necesario, pero que es bueno tener a mano para cuando las circunstancias lo precisen. Este tema es parecido al de los for-each con Java6 donde muchas personas desconfiaban de la implementación de estos y de su utilidad. Como sucede con cualquier herramienta, es mejor entenderla antes de utilizarla para no terminar con código spaghetti que dificulte la lectura y el mantenimiento.

Os recomiendo leer el libro SICP para comprender los closures en su totalidad y además un poco de Lisp.

DVD Rip en Ubuntu 9.10

2009-12-20T23:30:00.000Z

Estos dias me he puesto a hacer copias de seguridad de toda la filmoteca de DVDs que tenemos para los niños y es un arduo trabajo. Por suerte he empezado a utilizar una herramienta que viene con Ubuntu Karmic Koala llamada Thoggen que hace un gran trabajo al simplificar todo el proceso.
Lo primero que me gusto fue lo sencillo de su interfaz y que automaticamente selecciona los capitulos que piensa pueden ser los importantes, por lo que no hace falta adivinar cuales son. Dado que sólo codifica en OGG Vorbis, sólo tenemos que seleccionar el tamaño y el idioma.

Que sólo permita utilizar OGG tambien puede ser un problema si vamos a reproducir estos videos en black-box-appliances como lo son los reproductores de DIVx de toda la vida. Es muy raro encontrar alguno con soporte para OGG Vorbis, pero esto tampoco es un problema gracias a mencoder.

Con el siguiente comando, podreis convertir vuestros videos a MPEG-4 que cualquier reproductor en el mercado será capaz de reproducir. Además, junta todos nuestros capitulos en un único fichero:

$mencoder -oac mp3lame -ovc xvid -xvidencopts vhq=1:bitrate=2200:nopacked:nogmc:noqpel:nocartoon:bvhq=0:max_bframes=2:quant_type=mpeg ficheros_entrada.* -o fichero_salida.avi

Espero os sea util.

Monocaffe Connections Manager 0.8

2009-12-18T19:22:00.000Z

Ya está disponible la nueva versión de MCM para ser descargada desde el sitio habitual.

http://launchpad.net/mcm/

Para esta nueva versión se han arreglado gran variedad de fallos y se han añadido algunos cambios que mejoran la interfaz.

Ubuntu Karmic Koala 9.10 amd64

2009-12-07T00:43:00.000Z

Bah! Esto no es una review, sólo quiero dejar claro los cambios más importantes que he encontrado en ésta nueva versión de Ubuntu. La verdad, no había actualizado porque me sentía bastante cómodo con 8.10 Intrepid Ibex, que es una de las mejores versiones que he utilizado.
Empathy
El nuevo cliente de mensajería está muy logrado aunque algunas cosillas faltan por arreglar, sólo espero que no empiecen con las mismas luchas internas que hicierón que Pidgin se separase.
Centro de Software de Ubuntu
Me gusta su facilidad y que vaya instalando las aplicaciones y puedas continuar añadiéndolas a una cola que va instalando según va terminando.
Firefox 3.5
Aunque llevo mucho tiempo utilizando Shiretoko, se nota la diferencia con la versión estable de FF3.5.
Temas
Me gusta el nuevo tema por defecto con tonos marrones y grises. Muy sobrio y sencillos, que no molestan.
Ubuntu One
Solía utilizar Dropbox, pero Ubuntu One se muestra como un gran competidor, espero que no me de los problemas de sincronía que me dio Dropbox.
General
Como siempre la re-instalación del sistema ha sido cuestión de una hora, como mucho, sin hacer un respaldo de mis datos en /home. Al terminar GNOME ha cogido la configuración de 8.10 sin problemas y ha cargado los widgets, fondo de pantalla y tema sin quejarse. Los nuevos "globos de aviso" o como se llamen, parecen un poco desfasados ya que aparecen en un sitio extraño, pero tengo entendido que esto es a propósito (Not a Bug, a feature), así que a probarlo. Tampoco es que como si aparecieran cada 5 minutos como en otros OS's.
Conclusión
Estoy muy contento con la nueva versión que no me ha dado ningún problema y veo que Canonical está siguiendo un buen camino.

Monocaffe Connections Manage 0.7.5

2009-12-07T00:28:00.000Z

Nueva versión de Monocaffe Connections Manager puede ser descargada desde el sitio habitual:
mcm-0.7.5.tar.gz

Esta nueva version arregla algunos fallos y añade ciertas mejoras como:

Menu auxiliar de las consolas para:

Copiar/Pegar desde/a una consola.
Buscar en google a partir de la selección.
Cambiar el titulo de las pestañas.

Eso es todo por ahora, aun queda algo de trabajo pero en curso para la release 0.8.

Screenshot!!!

Karmic 64

2009-12-03T09:32:00.000Z

Hace unos días recibimos en la oficina PC's nuevos que son unos monstruos. El problema fue al intentar instalar las versión amd64 de Ubuntu o de Fedora 12. Ninguna de las versiones Live o Desktop llegaban a arrancar del todo. La solución es tan sencilla como utilizar la versión alternate de Ubuntu. Aunque no nos ofrezca una instalación gráfica y tarde un poco más, funciona.

Manifiesto: En defensa de los derechos fundamentales en Internet

2009-12-02T13:31:00.000Z

Ante la inclusión en el Anteproyecto de Ley de Economía sostenible de modificaciones legislativas que afectan al libre ejercicio de las libertades de expresión, información y el derecho de acceso a la cultura a través de Internet, los periodistas, bloggers, usuarios, profesionales y creadores de internet manifestamos nuestra firme oposición al proyecto, y declaramos que…

1.- Los derechos de autor no pueden situarse por encima de los derechos fundamentales de los ciudadanos, como el derecho a la privacidad, a la seguridad, a la presunción de inocencia, a la tutela judicial efectiva y a la libertad de expresión.

2.- La suspensión de derechos fundamentales es y debe seguir siendo competencia exclusiva del poder judicial. Ni un cierre sin sentencia. Este anteproyecto, en contra de lo establecido en el artículo 20.5 de la Constitución, pone en manos de un órgano no judicial -un organismo dependiente del ministerio de Cultura-, la potestad de impedir a los ciudadanos españoles el acceso a cualquier página web.

3.- La nueva legislación creará inseguridad jurídica en todo el sector tecnológico español, perjudicando uno de los pocos campos de desarrollo y futuro de nuestra economía, entorpeciendo la creación de empresas, introduciendo trabas a la libre competencia y ralentizando su proyección internacional.

4.- La nueva legislación propuesta amenaza a los nuevos creadores y entorpece la creación cultural. Con Internet y los sucesivos avances tecnológicos se ha democratizado extraordinariamente la creación y emisión de contenidos de todo tipo, que ya no provienen prevalentemente de las industrias culturales tradicionales, sino de multitud de fuentes diferentes.

5.- Los autores, como todos los trabajadores, tienen derecho a vivir de su trabajo con nuevas ideas creativas, modelos de negocio y actividades asociadas a sus creaciones. Intentar sostener con cambios legislativos a una industria obsoleta que no sabe adaptarse a este nuevo entorno no es ni justo ni realista. Si su modelo de negocio se basaba en el control de las copias de las obras y en Internet no es posible sin vulnerar derechos fundamentales, deberían buscar otro modelo.

6.- Consideramos que las industrias culturales necesitan para sobrevivir alternativas modernas, eficaces, creíbles y asequibles y que se adecuen a los nuevos usos sociales, en lugar de limitaciones tan desproporcionadas como ineficaces para el fin que dicen perseguir.

7.- Internet debe funcionar de forma libre y sin interferencias políticas auspiciadas por sectores que pretenden perpetuar obsoletos modelos de negocio e imposibilitar que el saber humano siga siendo libre.

8.- Exigimos que el Gobierno garantice por ley la neutralidad de la Red en España, ante cualquier presión que pueda producirse, como marco para el desarrollo de una economía sostenible y realista de cara al futuro.

9.- Proponemos una verdadera reforma del derecho de propiedad intelectual orientada a su fin: devolver a la sociedad el conocimiento, promover el dominio público y limitar los abusos de las entidades gestoras.

10.- En democracia las leyes y sus modificaciones deben aprobarse tras el oportuno debate público y habiendo consultado previamente a todas las partes implicadas. No es de recibo que se realicen cambios legislativos que afectan a derechos fundamentales en una ley no orgánica y que versa sobre otra materia.

Este manifiesto, elaborado de forma conjunta por varios autores, es de todos y de ninguno. Si quieres sumarte a él, difúndelo por Internet.

#Manifiesto
@iescolar

Monocaffe Connections Manager 0.7

2009-11-25T10:13:00.000Z

Monocaffe Connections Manager 0.7 está lista para ser descargada. Esta nueva versión contiene:

Configuración visual de las consolas (transparencia, fuente, colores)
Configuración de los clientes (binario y opciones por defecto)
Permite modificar fácilmente las conexiones.
Reordenado de las pestañas
Ayuda en linea
Instalación automatizada
Paquete .deb para Ubuntu

Monocaffe Connections Manager 0.7 is ready for download. This new version adds:

Visual configuration of consoles.
Clients configurations (binary and default options).
Easily modify connections data.
Tabs rearrangement
Online Help
Automatic instalation by distutils
Ubuntu package

ScreenShots!!!

Monocaffe Connections Manager 0.6

2009-11-20T17:42:00.000Z

Monocaffe Connections Manager 0.6 está lista para ser descargada. Además de arreglar algunos fallos he añadido una caracteristica genial, un línea de comandos en cluster. Marcando diferentes pestañas y luego escribiendo en la parte inferior, se verá reflejado en todas las pestañas marcadas. De ésta forma podemos trabajar en varias maquinas a la vez.

Tambien he arreglado algunos bugs y añadido otros :-) los podeis ver en el launchpad de mcm en http://launchpad.net/mcm

Finalmente, me gustaria añadir una version hecha en Qt para KDE, pero prefiero continuar afinando las versiones de consola y de GTK, por lo que si alguien está interesado, que me deje un comentario aquí o en launchpad.

Pronto haré una entrada sobre todo el proceso para poder montar un paquete en launchpad para Ubuntu, siempre que me acuerde de todos los pasos, porque es lioso de cojones.

Monocaffe Connections Manager 0.5.3

2009-11-16T00:21:00.000Z

La primera versión de mcm con el GUI GTK ya está listo para descargarse. La versión en terminal no conlleva cambios importantes. La nueva versión en GTK está evolucionando incluso para convertirse en un reemplazo de las tipicas terminales, con distintas opciones para abrir pestañas en local y hacia las distintas conexiones. Se agradecen comentarios.

New version of mcm with a GTK GUI. The terminal version hasn't changed since all changes apply to the new front-end. The new GTK version is evolving into a full replacement for a typical terminal application, with different options to open tabs on localhost and to the different connections. Comments are welcome.

Screenshots!

Main Window

Add a new connection

My Tools of the Trade

2009-11-15T23:22:00.000Z

Como todo buen artesano, todos tenemos nuestras herramientas preferidas a las hora de trabajar, siguiendo el ejemplo de éste blog que me ha dado la idea y ya habiendo terminado por hoy con la versión GTK de mcm, voy a continuar éste meme:
Hardware:

En casa prefiero utilizar mi portátil Thinkpad T42 que ya tiene sus años pero sigue funcionando de maravilla gracias a Ubuntu 8.10
En el trabajo, un HP Pentium IV algo antiguo pero gracias a Ubuntu, funciona muy bien. Con una pantalla de 17''. En unos dias nos los van a cambiar por unos mejores con pantallas de 22''. Que ganas!!!

Software:

Ubuntu Linux Intrepid Ibex.
Gnome Terminal siempre está abierto, deberia añadirlo al inicio de sesión de GNOME.
Firefox tambien deberia iniciarse con la sesión.

Echofon (Twitter)
Download Status Bar
GMarks
NoScripts

VIM para todo lo que no sea Java.
Eclipse para todo lo que sea Java.
SQuirreL SQL Client para todo lo que sea BBDD.
DIA para cuando necesito abordar un problema de forma gráfica.
Evolution para mis correos.
Gaim
Sin SSH el mundo no sería lo que es :)
Finalmente, y no por echarme flores, cada vez utilizo más y más mcm, que además si falla en algo, sé arreglarlo. De hecho he añadido la opción de abrir una consola local.

Utilizo muchas otras, pero diariamente, estas son las herramientas que siempre se encuentran abiertas en mis escritorios virtuales.

Maldito iPod Touch

2009-11-13T00:33:00.002Z

Necesito desfogarme para paliar un poco el odio que me merece Apple y todos sus productos. Hace unos dias, la empresa nos regalo a todos un iPod Touch de 8GB que realmente se agradece, es un dispositivo realmente hermoso, pero ya.
Es increible lo complicado que es utilizar el cacharro si tienes Linux cuando el mismo iPod utiliza Darwin, MacOS es un maldito Darwin con colorines y los anormales de Apple son incapaces de sacar un maldito iTunes multiplataforma.
¿Por qué? Sencillamente porque no les sale de los cojones al igual que a mi no me sale comprar un jodido Mac aunque me venga la vida en ello, seguiré repudiando todo lo que venga con la manzana.
Desde el mismo primer maldito momento que lo enciendes ya te está tocando los cojones ¿tengo que soltar más de 100€ para poder utilizar el elemento electrónico éste? Va a ser que no Mr. Jobs. Luego también espera que descargue música de su iTunes Store o como cojones se llame ¿para qué? ¿para que el día que el cacharro se quede sin pila y no quiera pasar por caja pierda todas estas? Otra vez, no.
Es irónico, mi primera computadora fue un Macintosh y sigo pensando que era un gran equipo con una excelente tecnología para su época.
Mis desprecios a Apple.
P.S. He hecho el jailbreak, instalado el mplayer y metido pelis via scp, por lo que al menos mi hija lo podrá utilizar para ver pelis... todo muy legal, sí señor.

Last Update: Al final se lo regalé a mi hermana que si tiene un MacBookPro y le gustan las chorradas de Apple. Que lo disfrute.

Estructura aplicaciones PyGTK

2009-11-08T13:28:00.000Z

Quiero explicaros una de las cosas que veo menos en los tutoriales y es sobre las estructuras de directorios para aplicaciones Python. Sigue una estructura parecida a las de Unix (¿POSIX?). Esta es la que he seguido para mcm y estoy bastante satisfecho con ella, por lo que voy a utilizarla como ejemplo:

INSTALL
CHANGELOG
BUGS
manpage

conf
logs
bin

mcm.sh

__init__.py
terminal

__init__.py

common

__init__.py
utils.py
models.py
controllers.py
exceptions.py

__init__.py
mcm-gtk.py
mcm.glade
mcm_icon.png

__init__.py
mcm-qt.gtk

Una aplicación no es sólo el código fuente, por lo que el orden en la documentación, ficheros de configuración y otros, merecen un lugar donde desarrollarse de forma independiente al desarrollo de la aplicación misma.
Cada páquete o modulo de Python es definido por el fichero __ini__.py y serán estos los que podremos importar dentro de nuestros modulos y conseguir un empaquetado bien definido que nos permitira cumplir con facilidad el principio DRY.
De igual forma podemos ver que la misma estrúctura de directorios define un modelo MVC lo que facilita mucho el desarrollo para diferentes presentaciones. En mcm, reutilizamos las clases y métodos definidos para la aplicación CLI en las aplicaciones gráficas para GTK y Qt. Esto lo logramos, en el caso de GTK definiendo distintos eventos que utilizan a los controladores para crear y modificar nuestros modelos. Por ejemplo veamos como añadimos una conexión desde la vista GTK:

def add_event(self, widget):
# Obtenemos de distintas formas los datos necesarios
connection = connections.connections_factory(x, y, z, a, b, c, d)
connections.append(connection)
def save_and_quit(self):
dao = Dao()
dao.save(connections)

Lo mejor es que esto mismo lo hacemos en la parte Qt y cualquier otra vista que se nos ocurra.

Diferentes configuraciones para vim y vimdiff

2009-11-06T11:56:00.000Z

Vimdiff es una utilidad muy importante de vim. Nos muestra en colores las diferencias entre dos o más ficheros o directorios y además podemos utilizarla como herramienta de "merge".
Dado que vimdiff es sencillamente vim en modo diff, se carga el mismo fichero .vimrc. Asi que si deseamos definir distintas opciones según el modo que utilicemos os propongo ésta solución:

Crear una función como:
function Vimdiff()
    nmap <F7> [czz
    nmap <F8> ]czz
    nmap <F2> do
    nmap <F3> dp
endfunction

Y a continuación la magia, añadimos al final de nuestro .vimrc lo siguiente:
au FilterWritePre * if &diff | call Vimdiff() | endif

He definido que las teclas F7 y F8 vayan a la anterior y posterior diferencia y centren la pantalla en estas. Las teclas F2 y F3 mueven los cambios de un lado del buffer al otro.

Espero os sea útil.

Monocaffe Connections Manager 0.4

2009-11-06T11:16:00.000Z

Nueva versión de mcm para lo cual he creado un nuevo sitio para mantener toda la información al respecto.

Monocaffe Connections Manager

Esta nueva versión añade la posibilidad de importar un fichero CSV generado a partir de una hoja de cálculo y de exportar a un fichero HTML. Tambien he añadido conexiones HTTP para consolas de Jboss. Además he iniciado la creación de la aplicación en GTK, por lo cual he añadido la opción de grupos para facilitar la ordenación. Finalmente he mejorado la introducción de opciones para los distintos clientes, por lo que ahora se pueden definir incluso túneles SSH.

Descargad desde el sitio del proyecto.

Xbox Live Bridge

2009-10-28T18:49:00.000Z

El siguiente es un sencillo script para crear un bridge y poder conectar una Xbox utilizando la wifi de un portátil. Si tienes la WiFi de la Xbox esto no hace falta.

Lo que hace es crear un bridge utilizando IPTables que enruta el tráfico entre las dos interfaces. Solo hay que cambiar en el script el nombre de las interfaces de red.

Descargad

Monocaffe Connections Manager 0.3

2009-10-28T17:05:00.001Z

He terminado la versión 0.3 de MCM. Si tenemos "dialog" instalado, al ejecutar sin ningún argumento, nos mostrará un menú con los servidores y con pulsar ENTER sobre alguno, abrirá la conexión. También he cambiado el fichero .mcm donde se guardan los datos de las conexiones para utilizar XML y eliminar un pequeño bug que había. También he añadido conexiones FTP.

Podéis descargarlo desde aqui

This software is designed to ease the management of connections to several types of servers. Since I couldn't find any solution to handle all types of connections from a console, mcm was born. The idea is to avoid having to maintain a separate spreadsheet or wiki page with all the servers I usually connect to and keep that monster open during my work sessions.
There are other solutions, but each handled either ssh only connections, or graphical connections (like vnc). Also, this graphical connections managers were designed to have a GUI and a single command from the console is what I wanted.
My main objective is to provide a fast and reliable mean to store the information of this connections and be able to reach them fast and easily.

Click here to download version 0.3

Screenshot!

Monocaffe Connections Manager 0.2

2009-10-22T17:48:00.003+01:00

En un par de horas y ya lanzo la versión 0.2, esto es desarrollo ágil. Gracias a bob_f en el canal de #python en FreeNode he mejorado la presentación de las listas. Además de ello he arreglado un fallo con el RDP y bueno, me he acordado que Dropbox permite publicar cosas. Así que aquí os dejo la última versión.

Descargar Monocaffe Connections Manager 0.2

Unas capturas

Monocaffe Connections Manager 0.1

2009-10-22T15:11:00.004+01:00

Llevaba algún tiempo con esta idea rondandome la cabeza. Odio tener que abrir una hoja de cálculo o un página en una Wiki cada vez que necesito recordar los datos para conectarme a cierta máquina. Dado que todo esto lo hago desde una consola, otras soluciones que de todas formas no me convencían, funcionan sólo sobre el entorno gráfico (p.e. PuTTy).
Así que, utilizando Python he creado una pequeña aplicación para mantener una lista con todos los servidores a los que me conecto y almacenar nombre, contraseña, conexión, etc. Está listo para funcionar sobre Ubuntu, pero es fácil de modificar para otras distribuciones en caso de ser necesario. Quizás algún día lo añadan a los repositorios de Debian.
Para el futuro me gustaría añadir una interfaz ncurses, GTK y Qt, sólo por hobbie.
Para instalarla:

$tar -xvzf monocaffe_connections_manager-0.1.tar.gz
$cd mcm
$chmod 766 mcm

Si queréis instalarla como es debido:

$tar -xvzf monocaffe_connections_manager-0.1.tar.gz
$sudo mv mcm /usr/share
$sudo chown -R root.root /usr/share/mcm
$sudo chmod 777 /usr/share/mcm/mcm
$cd /usr/bin/
$sudo ln -s /usr/share/mcm/mcm mcm

Supongo que tocara hacer un MakeFile para esto o incluso un .deb
Para descargar

$wget http://rapidshare.com/files/296414487/monocaffe_connections_manager-0.1.tar.gz.html

O pulsando aquí
Espero le encontréis utilidad.
El enlace de RapidShare es temporal, por lo que si veo que mucha gente se lo descarga (dejadme un comentario aquí si no funciona y lo arreglo)

Paquetes con Yast e imagenes ISO

2009-10-14T12:26:00.003+01:00

Cuando intentamos instalar unos paquetes utilizando Yast2 y se pone algo tonto con el tema de no tener los CD's ya que es más cómodo mantener las ISO's de los mismos, podemos utilizar la siguiente linea para indicarlo:

iso:///?iso=SLES-9-i386-RC5-CD1.iso&url=dir:////opt/imagenes/

Con esto no hace falta montar las imagenes, ni grabar CD's ni hostias.

Favoritos en BASH

2009-09-11T12:49:00.002+01:00

Día a día, podemos pasar horas cambiando de directorios con 'cd' por lo que estaría bien que tuvieramos ciertos favoritos definidos para navegar entre los directorios que más usamos.

Por ejemplo, /opt/jboss/server/default/ suele ser un directorio al que vuelvo muchas veces durante el día, así que voy a definir un favorito utilizando 'alias':

$ alias jb="cd /opt/jboss/server/default/"

De esta forma, la próxima vez, con ejecutar 'jb' me llevará a ese directorio.

Ahora vayamos un poco más lejos e intentemos hacer de esto algo un poco más genérico. Abrimos nuestro fichero ~/.bashrc y añadimos las siguientes lineas

# Favoritos
alias m1='alias g1="cd `pwd`"'
alias m2='alias g2="cd `pwd`"'
alias m3='alias g3="cd `pwd`"'
alias m4='alias g4="cd `pwd`"'
alias m5='alias g5="cd `pwd`"'
alias m6='alias g6="cd `pwd`"'
alias m7='alias g7="cd `pwd`"'
alias m8='alias g8="cd `pwd`"'
alias m9='alias g9="cd `pwd`"'
alias favs='alias|grep -e "alias g[0-9]"|grep -v "alias m"'
alias favsave='alias|grep -e "alias g[0-9]"|grep -v "alias m" > ~/.favs'
alias favload='alias | grep -e "alias g[0-9]"|grep -v "alias m"|sed "s/alias //"'
touch ~/.favs
source ~/.favs

Las primeras nueve lineas definen los aliases que vamos a utilizar para crear y utilizar nuestros favoritos. Si deseamos marcar un directorio, utilizamos 'm1' y para volver a éste, ejecutamos 'g1'

El alias 'favs' nos muestra la lista de favoritos cargados en el entorno. El alias 'favsave' almacena nuestros favoritos en el fichero .favs y los volvemos a cargar con 'favload'. Esto es así, porque al terminar una sesión, todos los aliases que teníamos definidos se perderán sino los almacenamos. El alias 'favsave' podemos añadirlo al fichero 'bash_logout' para que cada vez que termine la sesión, se guarden automáticamente.

Outlets

2009-09-08T09:03:00.003+01:00

Como comenté en la entrada anterior, una de las cuentas que sigo en Twitter es la del outlet de Dell UK (@DellOutletUK) y siempre estoy observando muy buenas ofertas que tienen. Si conectas al sitio web, resulta que tienen muchas más ofertas de refurbished. Esta palabreja es muy importante para la economía (para la mía al menos), y viene a definir aquellos equipos que luego de ser devueltos al fabricante, ya sea por fallos o por otras razones, vuelven a ser vendidos a un menor precio y con una garantía de menor duración. Algunas ofertas superan el 50% del valor del equipo nuevo y otras son configuraciones especificas que no se encuentran en los equipos del catalogo. Por ejemplo, mirad este Lenovo X61 con un precio de venta de US$2.152 y un precio de outlet de US$692.
Esto es así en UK y en EE.UU. aun más, ya que casi todos los fabricantes tienen un "outlet" y las ofertas de Dell, Lenovo y Apple son ciertamente alucinantes para el bolsillo. El problema está cuando empiezas a utilizar el TLD .es y te das cuenta de que la palabra outlet ni siquiera existe para los mismos fabricantes con tan jugosas ofertas. Ni Apple, Lenovo o Dell, ofrecen (no al menos de manera tan clara como los anglosajones) un outlet donde comprar con tan ventajosas ofertas. Y esto me hace dudar sobre sus productos que todos suponemos como "nuevos" ya que me intriga saber qué es lo que hacen con todos los ordenadores que por cualquier razón les son devueltos por los consumidores. ¿Les cambian el teclado y los venden en outlet extranjeros? Puede, aunque resulta una solución costosa. ¿Nos venden como nuevo un portátil refurbished? Es muy probable, y no tienes forma segura de saberlo. ¿Los tiran a la basura porque al cliente no le gusto el color de los píxeles? Lo dudo mucho, a alguna parte han de ir, pero a un outlet .es no.
Voy a indagar un poco más sobre éste asunto y si algún lector conoce la respuesta a estas dudas, que deje un comentario.

Life's a Tweet

2009-08-13T09:00:00.003+01:00

Hoy, finalmente, después de meses utilizando Twitter y con 7 seguidores (qué patético) y siguiendo a unas 12 he descubierto tres cosas para las que twitter sirve:

Enterarte de ofertas de fabricantes como Dell @delloutletuk
Seguir a gente con cosas interesantes que decir sobre temas que puedan interesarte como @fourzerotwo quien siempre tiene temas frescos sobre el desarrollo de CoD:MW2
La más interesante, ver cómo dos personas se montan una twitt-novela y se tiran puntas entre ellos, como ahora mismo sucede entre @timoreilly (de O'Reilly) y @TheRealDvorak (John Dvorak).

Bueno, si tenéis algo interesante que contar, añadir @ubersoldat y os seguire.

El té está listo

2009-07-17T11:45:00.004+01:00

Después de pasar una semana de fuertes dolores gracias a una gastritis producida por tomar Ibuprofeno, me he aficionado a las infusiones. Esta línea muestra un mensaje de aviso para recordarnos que nuestra bebida está lista:

$sleep 3m && xmessage -center "Su Te esta listo"

Podemos añadir una función al bashrc

function te
{
$sleep 3m && xmessage -center "Su Te esta listo"
}

Fácil y rápido

Muerte a Tomboy, Larga Vida Gnote

2009-06-18T12:44:00.003+01:00

Desde hace ya algún tiempo llevo utilizando Tomboy para mantener notas a mano. Es una excelente aplicación por su sencillez y velocidad. Si además, lo hacemos funcionar con Dropbox, pues tendremos nuestras notas en donde las necesitemos.

Pero siempre he tenido un noséque con Mono que no me gusta. Todo se reduce al tema de ver binarios .EXE en mis sistemas, lo que me da bastante grima

Aparte de esto, y de otros temas sobre licencias y patentes, las aplicaciones hechas con Mono son excelentes: Monodevelop, F-Spot y Tomboy las más conocidas. De hecho, MonoCaffe se inicio como un proyecto sobre Mono pero que al final decidí reiniciar en un entorno más "limpio" y estable, pero eso es otra historia. La verdad es que Mono no trae nada nuevo a GNU/Linux y dudo que haya algo que sólo se pueda hacer en Mono que no se pueda en ningún otro lenguaje de los ya existentes y sin preocupaciones.

Dada las noticias sobre Fedora eliminando Mono de su distribución (no completamente, se puede instalar, pero de forma opcional) me he enterado de Gnote el cual es igual a Tomboy, excepto por alguna funcionalidad. De hecho, según el sitio de Gnote, éste es un port a C++ lo cual lo hace más rápido que Tomboy.

El primer problema que encontraremos con las versiones del momento (Junio 2009) es que no existe una funcionalidad para sincronizar notas. La verdad es que con Tomboy esto tampoco funcionaba (de hecho perdí algunas notas por su culpa) pero la formula que utilizaba Tomboy + Dropbox, también funciona con Gnote.

Adiós Tomboy

Gnote trabaja con unos ficheros XML con la extensión ".note" que son los mismos que utiliza Tomboy, por lo que para utilizar nuestras notas de Tomboy en Gnote, sólo tendremos que copiarlas de un directorio a otro:

$cp ~/.tomboy/*.note ~/.gnote/

Gnote + Dropbox

Dropbox debería ser una herramienta disponible en el "multiverse" de Ubuntu y de todas las distribuciones. La verdad es que es muy útil y sencilla de utilizar. Instalarla es muy sencillo, sólo es necesario ir al sitio Get Dropbox y descargar el DEB para Ubuntu. A continuación creamos la cuenta de dropbox que nos dará 2GB de forma gratuita y repetimos estos pasos en cada uno de nuestros entornos.
Lo siguiente será añadir Gnote a nuestra barra de herramientas. Dado que no existe dentro del los repositorios de Ubuntu todavía (para Karmic Koala sí) habrá que añadirlo siguiendo las instrucciones aquí detalladas.
Una vez que tenemos el icono de Gnote, abrimos una consola y ejecutamos el siguiente comando:
$killall gnote
GNOME mostrará una ventana advirtiendo que la aplicación ha dejado de funcionar y si deseamos recargarla. Contestad que no y abrid una instancia de Nautilus y navegad hasta el directorio compartido de Dropbox (~/Dropbox) donde creamos una carpeta llamada "gnote" o "notes" o como queráis.
Lo siguiente será copiar todo el contenido de la carpeta de Gnote (~/.gnote) a esta nueva carpeta que hemos creado y eliminarla.
Finalmente creamos un enlace simbolico llamado ".gnote" al nuevo directorio. En una consola sería algo así:

$killall gnote
$mkdir ~/Dropbox/gnote
$cp ~/.gnote/* ~/Dropbox/gnote/
$mv ~/.gnote /tmp
$ln -s ~/Dropbox/gnote/ ~/.gnote

Ahora volver a añadir a Gnote a la barra de herramientas y listo. Repetid esto en todos vuestros entornos -menos el paso en el que se copia el directorio ".gnote" ya que borrareis las notas que tengáis- y siempre tendréis las notas a manos. El mayor inconveniente de esto es que, aunque podremos ver nuestras notas desde el sitio de Dropbox, al estas ser XMLs, no podremos verlas en línea. Habrá que descargarlas y abrirlas en local.

Adiós Mono

Dado que ya podía eliminar Tomboy de mi sistema y no utilizo ninguna otra herramienta basada en Mono, pues podemos hacer algo de limpieza. Para eliminar Mono y todo lo que tenga que ver con éste en Ubuntu, ejecutamos el siguiente comando:

$sudo aptitude purge mono-common libmono0

Aceptad el calculo de dependencias y esto removerá todo.

Porque Windows no esta listo para el escritorio

2009-06-08T15:08:00.003+01:00

No me paso el día diciéndole a la gente cual sistema operativo deben o no utilizar en sus computadoras y por lo visto hay mucha gente que sí, para traerlos a sus blogs, supongo.

El problema con estas críticas es siempre que el autor tiene ideas preconcebidas sobre que su sistema operativo preferido personifica la única forma de organizar el ecosistema del software y todos los demás son inferiores. Peor aun, dado que solo buscan la manera de justificar sus justificaciones, están totalmente desinformados acerca de sus quejas, las cuales son subjetivas o simplemente erróneas.

Así que, a forma de parodia de todos los posts, artículos, etc. Acerca de "Porque Linux no está listo para el escritorio" os traigo esta entrega.

Sólo vamos a discutir las deficiencias de Windows mientras todos debemos tener en mente que existen áreas en las que ha logrado superar a los demás (¿marketing?).

En un mundo donde GNU/Linux y sus primos BSD (incluido MacOSX) comparten el 99% de un mercado que se inicio bajo las premisas del OSS y Windows sólo el 1% con Microsoft a la saga, la blogoesfera estaría repleta de artículos como el siguiente:

Los mayores fallos y problemas de Windows

Premisa

El software libre está para quedarse indefinidamente. A lo largo de los años, se ha comprobado la eficacia de los métodos colaborativos de las comunidades para producir aplicaciones para las masas y donde poco a poco, los métodos de desarrollo cerrados van ganando avances en sectores de gran especialización.

Seguridad

1. El mayor patio de juegos para software malicioso. Con maquinas desactualizadas siendo infectadas en cuestión de minutos al ser conectadas a Internet, para convertirse en esclavas de botnets y formar parte en operaciones ilegales de spam masivo y demás. Windows es una plaga en las infraestructura de Internet.
2.Incontables aplicaciones para Windows, son creadas cada año con fallos de seguridad obvios lo que hace que los programadores de estas, los peores.
3. Microsoft ha evitado tomar las medidas necesarias para hacer su sistema más seguro y limitar el daño potencial que binarios comprometidos, pueden causar. Consistentemente ha añadido medidas a medias por el miedo a confundir más a la gente con un "disco duro de 1.3GHz" en su escritorio.
4. Cada aplicación intenta hacer malabares con el registro, instala ficheros, iconos que nunca limpia o peor aun, instala spyware o adware.
5. Cualquier SO que deba ser limpiado y reinstalado para ser reparado cada 6 meses, está más allá de la tolerancia de cualquier persona en sus cabales.
6. Una cantidad impresionante de fallos en todas las aplicaciones. Sólo hay que mirar Vista o llamar al Soporte de MS, pagar exorbitantes sumas y preguntarnos por que después de diez años aun existen los mismos "bugs" con otra docena de duplicados y nadie esté trabajando para resolverlos.

Interfaz

1. No existe una API consistente: Win32, MFC, WinForms, WPF. ¿Cuál escoger?
2. No existen conectores sencillos para lenguajes como Python, Perl, Ruby, Java, etc.
3. Todo el sistema es un chiste monolítico, cerrado y rígido sin acceso para los desarrolladores externos. Cambios no-triviales en el aspecto de una ventana o cualquier widget, requiere de añadir herramientas de terceros o de chapas. Peor aún, muchas cosas están hardcodeadas por los diseñadores de Microsoft, de manera que no se pueden cambiar.
4. Falta de una linea de comandos en condiciones, lo que hace que las aplicaciones visuales, no puedan ser utilizadas fuera de un entorno visual. ¿Por qué mostrar un mensaje luminoso de advertencia o de error a un usuario, cuando éste debería ser almacenado en un fichero a la espera de que un técnico cualificado pueda revisarlo?

Interoperabilidad

1. Windows no soporta trabajar con otros sistemas que no sean Windows. Al instalar Windows, este destruye de forma autoritaria y arrogante, cualquier otro sistema de arranque que tengamos anteriormente. Peor aun, si no se tiene cuidado, eliminará todo vestigio de otros sistemas y ficheros del usuario que puedan estar almacenados en el disco duro.
2. No soporta de forma nativa, otros sistemas de ficheros que no sean los anticuados FAT o NTFS.
3. Debería ser posible configurar todo desde la linea de comandos. ¿Por qué tengo que causarme una enfermedad crónica por tener que mover el ratón a todas partes y haciendo click de forma frenética para realizar un cambio que con solo modificar dos lineas de texto habría sido suficiente?

Drivers

1. El soporte de drivers en Windows está totalmente roto y de chiste. Cada fabricante de dispositivos debe incluir sus drivers junto al mismo dispositivo. Si se tiene que reinstalar Windows, ninguno de los dispositivos funcionara hasta que se vuelvan a reinstalar todos los drivers de forma individual, y Dios no lo quiera, teniendo todos los CD's a mano, porque en caso de tener que buscarlos en Internet, nos hará falta un master en ingenieria y toneladas de paciencia.
2. Muchas veces estos necesitan ser instalados, modificados o configurados antes de ser utilizados, ya que la mayoría de las veces, estos no funcionan como deberían. Incluso peor, no suelen ser solo drivers, sino todo un conjunto de aplicaciones de cuestionable valor que consumen recursos y reducen la velocidad del sistema.
3. Estos son los causantes de la gran mayoría de problemas de inestabilidad -después de los virus y malware- y su mala calidad hace que la experiencia con Windows sea frustrante.
4. Windows no posee ninguna forma efectiva y segura de actualizar estos drivers cuando fallos críticos son encontrados y arreglados por el fabricante.

Aplicaciones

1. Muy pocas aplicaciones para Windows, por volumen, son gratuitas o libre, lo que significa que se está totalmente a la merced de los fabricantes de software de formas que la ley nunca admitiría para fabricantes de productos físicos. ¿Tiene todos sus datos en un formato propietario cerrado cuando la licencia a caducado? ¿Ha perdido su USB antes de una presentación? ¿Ha tenido que transferir su aplicación a otro portátil porque se lo han robado? Lamentamos oír que se haya ido a la quiebra.
2. Windows no tiene un ciclo regular de lanzamientos. Pagas una cantidad importante de dinero por algunas mejoras y muchos bugs. Puede que pasen algunos años antes de que estos sean arreglados, pero no cuente con ello. En cualquier caso, deberá volver a pagar por ello.
3. Windows no tiene un sistema central de descargas que le permita descargar software nuevo, junto a sus dependencias y actualizaciones. Cada nueva aplicación debe ser adquirida desde un punto de venta autorizado -tienda física- o desde el sitio web del fabricante. No existe un registro de las dependencias -o peor, no existen librerías compartidas- y actualizar para resolver fallos de seguridad, nuevas características es en si mismo un proceso totalmente dependiente de las necesidades del fabricante. Es muy posible que algún fabricante utilice algún medio de actualización remota, para esconder actualizaciones ilegitimas y sin previo conocimiento ni aceptación.
4. Una instalación fresca de Windows es totalmente inútil, por lo que antes de poder hacer algo útil, tendrá que pasar varias horas recordando las aplicaciones que tenía instaladas, buscarlas, descargarlas e instalarlas de forma individual, una a una y reiniciando el sistema después de cada nueva instalación.
5. Las aplicaciones y librerías de Windows hacen que después de cada instalación u actualización, el sistema deba ser reiniciado. 1991 fue hace mucho, pero parece que no hayamos avanzado.
6. Falta de gran cantidad de aplicaciones como grep, awk, gdb, valgrind, systap o SELinux. Así que los programadores ni se molestan en instalar un SO hasta que puedan trabajar en serio.

Vale, esto llega hasta aquí. Recordad que esto es sólo un ejercicio para reflejar la cantidad de tonterias y falsas afirmaciones que se hacen en gran cantidad de críticas contra Linux, Mac y BSD. Muchas pueden ser verdad, otras no, pero reflejan de forma clara que todos estos articulos y fanboys -sean de la esquina que sean- sólo sirven para llamar la atención y que realmente no ofrecen nada nuevo para la mejora. So shut up!

Vilmente copiado, editado y traducido de aquí

monocaffe

Sharing Apache Tomcat and Apache Web Server

Python and Jongo

Jongo Beta 0.1

Jongo as a JavaScript Application Server

Jongo and ExtJS

Un gobierno en funciones no puede aprobar la ley Sinde

Java's Ghost JVMs

RESTing with Jongo

My Logback.xml template

Grails and Tomcat 7 Datasource

Ubuntu Black Screen over VNC

Monitor Tomcat/JBoss served connections

Java Daemon

Groovy Conflicts with Grails

Grails hasMany Delete

CoffeScript and Canvas

CoffeeScript in 1, 2, 3...

Central GNU Screen/SSH Server

Use some screen magic

Adding Tags to your Tags

Grails debug logging

Video Streaming Linux/iPad

Grails Enum

GUI vs CLI

No más Facebook

PermGen Out of Memory

No más JavaScript!

Bienvenido CoffeScript

Sistemas de control de versiones (VCS)

Atomic Commits

Renombrar o mover ficheros o directorios

Merge inteligente

Copia de ficheros

Clonado del repositorio

Propagación de cambios

Permisos del repositorio

Conjuntos de cambios

Historial de ficheros linea a linea (annotate, blame)

Trabajo en un directorio

Mensajes de commit por fichero

Integración con Eclipse

Estado de desarrollo

Quienes usan cada uno

CVS

Subversion

Git

Bazaar

Mercurial

Eclipse Helios for Linux Developers

Java Template Engines, fight!

J2EE Templates

Freemarker

Velocity Engine

StringTemplate

MVEL2

Conclusion

Ubuntu Baja Resolución

Botones en un TreeView

Monocaffe Connections Manager 0.9.3

PyGTK Colores por defecto

MCM en Varias Distros

Estructura de la memoria de Objetos Java

Monocaffe Connections Manager 0.9.2

MCM en Lubuntu 10.04

Reparar conflictos en Bazaar

NACAR

Glade3 y GtkBuilder

Domingos de trabajos I

Bash debug/failure

Código fuente en Blogger con code2blog

Monocaffe Connections Manager 0.9.1

PuTTY Opciones

Tanslations in Monocaffe

Desarrollo de Monocaffe Connections Manager

Wooops... Fallo en MCM 0.9

Monocaffe Connections Manager 0.9

Venga Yahoo!

Java7 Closures

Funciones-objeto y closures

Use some `screen` magic