Blog de javiyu

Plantillas javascript

2011-12-10T09:52:00.001+01:00

Las aplicaciones web que usan AJAX suelen seguir un patrón similar:
1) Se lanza un evento javascript
2) Se genera una petición al servidor
3) El servidor produce código javascript de vuelta con el objetivo de añadir/eliminar HTML de la página.

Cuando hay que insertar gran cantidad de HTML el código javascript producido suele ser poco mantenible, el primer planteamiento es crear una gran cadena de marcado HTML para insertarla en algún lugar de la página.

Por suerte, existe un plugin para la librería jQuery llamado jQuery Templates que elimina este problema.

Para usar este plugin, podemos definir una plantilla javascript de la siguiente forma:

<script id="templateId" type="text/x-jquery-tmpl">
${templateText}
</script>

Siguiendo este ejemplo, con el id 'templateId' recuperaremos posteriormente la plantilla y podremos hacer la sustitución de 'templateText' con la siguiente llamada.

$("#templateId").tmpl({templateText:"Hello world"})

Como se puede ver, es similar a cualquier sistema de plantillas, se puede interpolar marcado HTML, crear condicionales:

<script id="templateId" type="text/x-jquery-tmpl">
{{if error}}
<h2>Error!</h2>
{{else}}
<h1>OK</h1>
{{/if}}
</script>

$("#templateId").tmpl({error:false})

O incluso bucles:

<script id="templateId" type="text/x-jquery-tmpl">
<h1>${title}</h1>
{{each items}}
<li>${$value}</li>
{{/each}}
</script>

$("#templateId").tmpl({title:"Titulo", items:["uno", "dos", "tres"]})

Batch processing en rails

2011-09-18T12:39:00.001+02:00

En aplicaciones web con cierta complejidad, es común que aparte de responder a las peticiones de los clientes, se necesite realizar trabajos batch o simplemente migrar la base de datos a una nueva estructura.

Cuando la base de datos crece, aparecen nuevos problemas, uno de ellos es que las tablas de la base de datos pueden no caber en memoria. En hostings baratos este problema se acentúa ya que no se suele contar con demasiada RAM. Con ruby on rails es muy fácil solventar esta dificultad.

Tomando como ejemplo una tabla muy grande de usuarios en la que hay que recalcular un campo para cada usuario.

User.find_each{|u| u.karma = calculate_karma(:user => u)}

find_each toma bloques de 1000 usuarios y va devolviendo de uno en uno de forma transparente, se utilizan 1000 entradas por defecto pero se puede cambiar mediante el parámetro batch_size.

User.find_each(:batch_size => 200){|u| u.karma = calculate_karma(:user => u)}

find_each se implementa usando find_in_batches, se puede llegar a mayor nivel de control usando esta función que devuelve directamente los grupos de entradas.

User.find_in_batches(:batch_size => 2000){|group| group.each{|u| u.karma = calculate_karma(:user => u)}}

Puede que este último ejemplo parezca más complejo sin ningún tipo de beneficio, pero sería muy útil en caso de querer paralelizar el proceso.

User.find_in_batches(:batch_size => 2000){|group| Process.fork{calculate_karma(:group => group)}}

Temporizadores en javascript: PollJS

2011-09-04T12:41:00.000+02:00

Realizar tareas regulares en el tiempo en una web con javascript es una tarea algo pesada. PollJS es una librería muy pequeña y sencilla que facilita algo esta tarea.

Un ejemplo de una tarea regular con PollJS.

Poll.start({
    name: "refresh_list",
    interval: 1000,
    action: function(){}
});

Esa es la sintaxis básica para crear una tarea con PollJS, evidentemente nos deja establecer un intervalo de espera entre repeticiones y definir la acción que queremos ejecutar. Además se puede dar nombre a cada tarea para referenciarla posteriormente, por ejemplo, para detenerla.

Poll.stop("refresh_list");

Existe otra forma de detener una tarea, devolviendo false en la función que se pasa como acción se detiene el temporizador.

Con esta librería podemos además definir un número de reintentos máximo y una función de fallback si en ninguno de los intentos se ha detenido el temporizador.

Poll.start({
    name: "refresh_list",
    action: function(){},
    interval: 1000, 
    attempts: 5,
    fallback: function(){}
});

Visor de PDF en HTML5

2011-08-24T11:27:00.005+02:00

Andreas Gal (investigador de Mozilla Corporation) ha publicado la librería javascript PDF.js

Con esta librería se pueden visualizar ficheros PDF en el navegador sin plugins externos, las ventajas son claras, no hay necesidad de un programa externo, es multiplataforma, más seguro y provee de mayor interacción con el navegador.

PDF.js está todavía en proceso de desarrollo y pero el autor pretende lanzar una extensión de firefox para abrir los ficheros PDF directamente en el navegador.
Por ahora para visualizar un fichero PDF se crea dinámicamente un elemento canvas en el que se muestra la información, sin embargo, se planea migrar a SVG para permitir selección de texto, búsquedas y mayor interacción con el fichero.

Es un paso importante hacer que este tipo de ficheros se integren completamente en la web, ya algunos buscadores indexan su texto y lo incluyen en las búsquedas.

Por contra, tanto canvas como SVG están disponibles solo en los navegadores que soportan HTML5 y aún no hay un porcentaje aceptable de usuarios que usen este tipo de navegadores para aceptar esta solución como medida única.

Extensión de clases en Scala

2011-06-03T19:53:00.003+02:00

En algunos lenguajes de programación dinámicos como ruby se permite añadir funcionalidad a clases ya existentes. Cuando esto ocurre, se dice que las clases en ese lenguaje son 'abiertas'.

Un lenguaje de programación con clases abiertas añade mucha flexibilidad para el programador, sin embargo, esta flexibilidad hace que sea más difícil auditar el código.

La principal ventaja de esta técnica es poder aumentar la funcionalidad de las clases que proporciona en lenguaje. Al tener unos tipos básicos con una interfaz más rica, el código comienza a ser más sencillo y se reduce el número de líneas de código para desarrollar una funcionalidad.

En Scala, las clases no son abiertas, sin embargo, tiene un mecanismo similar con el que se pueden llegar a resultados no muy distintos.

Ejemplo:


class RomanNumber(val number:Int){
 def toRoman:String = {
  if(number == 1) return "I";
  else if(number == 2) return "II";
  else if(number == 3) return "III";
  else if(number == 4) return "IV";
  else if(number == 5) return "V";  
  else return "Unknown";
 } 
}

object Main extends Application{
 implicit def intRomanNumber(x:Int) = new RomanNumber(x);

 override def main(args: Array[String]){
  println(1.toRoman);
  println(3.toRoman);
  println(5.toRoman);
  println(6.toRoman);
 }
}

En este ejemplo se crea una clase 'RomanNumber' que contiene la funcionalidad que necesitamos añadir a los enteros 'toRoman'.

El código resultaría muy redundante si cada vez que queremos usar el método 'toRoman' necesitamos crear una instancia de la clase y pasarle como argumento el entero. Algo como: new RomanNumber(4).toRoman.

Para este tipo de casos, Scala provee del mecanismo de conversión implícita, en el ejemplo el método 'intRomanNumber'.
Al definir un método como 'implicit' se llamará para hacer el correspondiente cambio de tipos como se le indique, en este caso creando una instancia de 'RomanNumber'.

El resultado final es el que aparece en el ejemplo, parece que los métodos añadidos mediante conversión implícita pertenezcan a la clase original, muy similar al caso de los lenguajes dinámicos y las clases abiertas.

attr_accessor_with_default

2011-04-16T10:28:00.002+02:00

Un pequeño tip sobre los atributos en ruby on rails, normalmente en cualquier clase se pueden declarar atributos con attr_accessor, pero, si lo que se necesita es un atributo que tenga un valor por defecto, existe una función menos conocida attr_accessor_with_default.

Un ejemplo


class Example
  attr_accessor_with_default :attr, 'default message'
end

e = Example.new
e.attr
=> 'default message'

Propagación de eventos en jQuery

2011-03-20T11:35:00.003+01:00

La primera aproximación de asignación de eventos a los elementos del DOM es la más sencilla, simplemente se establece el callback a ejecutar en el elemento que posee el evento.


$('#element').click(function(){alert('hello');})

Usando este método se disparará el evento del elemento con id 'element', después su padre, y así sucesivamente.

La segunda posibilidad es usar 'live', de esta forma todos los elementos futuros que cumplan con el selector dispararán el evento.


$('#element').live('click', function(){alert('hello');})

Esta aproximación asigna el callback a la raíz del DOM (document) de tal forma que cada vez que se dispara un evento si coincide tanto en tipo como en su selector, se dispara el callback.
Esta implementación, aún siendo muy útil puede dar lugar a comportamientos inesperados, el callback establecido con 'live' se ejecutará el último en la jerarquía de propagación del evento.

'live' no es más que una particularización de 'delegate'. 'delegate' se puede usar para hilar más fino en el establecimiento de la respuesta a eventos.


$('#parent').delegate('#element', 'click', function() { alert("hello") });

En este caso, establecemos el callback en 'parent' en lugar de en document, por lo demás el funcionamiento es similar a 'live'.
Cada vez que el evento llegue a 'parent' se comprobará si coincide tanto en tipo como en el selector, de ser cierto se dispara el callback.

'delegate' es mucho más eficiente que 'live' puesto que solo comprueba los eventos tomando como raíz el elemento que le indicamos en lugar de todo el documento como es el caso de 'live'. Aún así el problema en el orden de propagación aparece al igual que en 'live'.

Generar proyectos ruby on rails con versiones anteriores

2011-02-03T22:04:00.004+01:00

Después del cambio de versión de ruby on rails de la rama 2 a la 3, surge un caso muy típico, tener instalado rails 3 y querer generar un proyecto con la versión 2.

Para generar un proyecto de ruby on rails con una versión anterior que tengamos instalada tan solo hay que ejecutar lo siguiente:


rails _VERSION_ proyecto

Donde VERSION es la numeración específica de la versión de rails, por ejemplo, para crear un proyecto con la versión 2.3.8 (actualmente la última de la rama 2).


rails _2.3.8_ proyecto

Depuración android por red

2011-01-20T20:56:00.003+01:00

Hay dispositivos android que no permiten la depuración a través del conector USB, aún así, es posible usarlos para desarrollo usando la conectividad por Wi-Fi.

Simplemente hay que conectar el dispositivo a la misma red Wi-Fi que el PC desde el que estamos desarrollando y ejecutar el comando:


adb connect ip:5555

Donde ip es la dirección IP del dispositivo en la interfaz Wi-Fi.
A partir de ahí se puede usar adb igual que cuando está conectada la depuración USB, se puede usar la shell, la transferencia de ficheros, etc, incluso el android SDK sin necesidad de cables.

Conocer el método desde el que una función es llamada en Java

2011-01-07T19:17:00.003+01:00

El lenguaje de programación Java en sus últimas versiones tiene algunas construcciones que permiten introspección.

Como ejemplo en el siguiente trozo de código la función 'print' tiene un comportamiento u otro dependiendo de que método le llama. En general esto no es una buena práctica de programación pero sirve como ejemplo ilustrativo.


public class Ejemplo{ 
 public static void print(){
  StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
  StackTraceElement e;
  String str = stackTraceElements[2].getMethodName();
    
  if(str.equals("other")){
   System.out.println("Other message!");
  } 
  else{
   System.out.println("Hello world!");   
  }  
 }
 
 public static void other(){
  print();
 }
 
 public static void main(String[] args){
  print();
  other();
 }
}

La llamada 'Thread.currentThread().getStackTrace()' devuelve un array de elementos 'StackTraceElement', cada uno de estos elementos representa una llamada de la pila de llamadas a funciones.

En el ejemplo anterior se consulta el nombre del método, pero se pueden extraer más datos, más información en el javadoc de StackTraceElement.

Javascript orientado a objetos

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

Debido al gran auge de la web, últimamente han surgido numerosas librerías y tutoriales acerca de como programar javascript orientado a objetos.

No es difícil encapsular código javascript simulando que se está trabajando con clases.


function Article(title, body){
    this.title = title;
    this.body = body;
}

var a = new Article('titulo', 'noticia')

Incluso se puede conseguir visibilidad privada para los atributos de la 'clase' que elijamos.


function Article(title, body){
    this.body = body;
    var _title = title;
    this.getTitle = function(){
        return _title;
    }
    this.setTitle = function(title){
        _title = title;
    }     
}

Sin embargo, en mi opinión todas estas aproximaciones conducen a escribir código javascript poco natural. Javascript fue pensado como un lenguaje de programación basado en prototipos y su flujo principal de ejecución es orientado a eventos.

Está basado en prototipos, la encapsulación, las 'clases' se obtienen a partir de la clonación de objetos y no de una estructura tan rígida como la orientación a objetos. Esto hace al lenguaje mucho más propicio para las tareas que fue pensado.

De la orientación a eventos del lenguaje han surgido proyectos muy interesantes como node.js, hay que tratar de aprovechar las bondades del lenguaje, no cambiarlas a través de capas de abstracción.

Logger en ruby

2010-12-15T23:37:00.002+01:00

Similar al proyecto log4j existe para ruby una librería de logging para el depurado de aplicaciones, gestión de mensajes de error, etc.

El nombre de la librería es log4r, se distribuye como gema y es fácilmente personalizable.

Para usarla tan solo hay que instancia un objeto de la clase Logger. Para dicho objeto se pueden seleccionar distintos outputters (medio de salida), en el ejemplo se muestran los mensajes tanto por salida estándar como por UDP.

Posteriormente, para cada outputter se puede elegir un formatter (formato de la salida). En el ejemplo la salida por UDP será en el formato por defecto mientras que la salida estándar será en XML.

El ejemplo de uso de la librería.


require 'rubygems'
require 'log4r'
require 'log4r/formatter/log4jxmlformatter'
require 'log4r/outputter/udpoutputter'

include Log4r

logger = Logger.new 'mylog'

#Formatters
xmlformat = Log4jXmlFormatter.new

#Ouputters
stdout = Outputter.stdout
udpout = UDPOutputter.new 'udp', :hostname => "localhost", :port => 8888

stdout.formatter = xmlformat

logger.outputters = [stdout, udpout]


def debug(logger, txt)
  logger.debug txt
end

def error(logger, txt)
  logger.error txt
end


debug(logger, 'Mensaje de DEBUG')
error(logger, 'Mensaje de error')

Para más información se puede consultar la web oficial de log4r.

Lectura de memoria entre procesos Windows

2010-11-20T20:10:00.003+01:00

En todos los sistemas operativos modernos la memoria está protegida entre procesos.
Si un proceso accede o escribe en una posición de memoria no esperada no debe afectar a los demás procesos.

A pesar de este planteamiento, en Windows es posible leer o escribir zonas de memoria entre procesos, para ello están las funciones del API ReadProcessMemory y WriteProcessMemory.

El primer paso es encontrar el PID del proceso en el que estamos interesados y después debe obtenerse un handle con la función OpenProcess.

Para buscar el proceso destino hay varias formas, en este ejemplo se usa el nombre de la ventana visible del proceso.


#include <QtCore/QCoreApplication>
#include <windows.h>

DWORD getPIDByWindowName(WCHAR* name);

int main(int argc, char *argv[]){
    QCoreApplication a(argc, argv);
    BYTE buffer[300];
    DWORD readed;
    DWORD processID = getPIDByWindowName(TEXT("Calculadora"));
    HANDLE procHandle = OpenProcess(0x0010, 0, processID);
    ReadProcessMemory(procHandle, (void*)0x00951558, buffer, 50, &readed);
    return a.exec();
}

DWORD getPIDByWindowName(WCHAR* name){
    DWORD processID;
    HWND windowHandle = FindWindowW(NULL, name);
    GetWindowThreadProcessId(windowHandle, &processID);
    return processID;
}

Gracias al uso de estas funciones del API se abre una nueva posibilidad de comunicación entre procesos, sin embargo, abre también un grave riesgo de seguridad. Entre otros usos, modificando la memoria de los procesos de antivirus o cortafuegos se pueden inutilizar dando una falsa sensación se seguridad.

Ejecución de tareas asíncronas en C++ con QT

2010-11-16T20:34:00.004+01:00

En los programas con interfaz gráfica no deben ejecutarse tareas que puedan demorarse en el mismo hilo de la interfaz.
Esto ocurre muy a menudo si en el evento 'click' de un botón se hace una lectura/escritura de un fichero o una base de datos.

Con las librerías QT se puede solucionar de varias formas, una es creando un hilo (una clase que herede de QThread). Una forma aún más sencilla es crear un objeto QRunnable y hacer que el pool de QT lo ejecute en segundo plano.

Un ejemplo de lo segundo.


class AsynchrounousTask : public QRunnable{
    protected:
        QLabel *label;
    public:
        AsynchrounousTask(QLabel *label){
            this->label = label;
        }

        void run(){
            sleep(5); //long task;
            label->setText("Done!");
        }
};

Y para usarlo tan solo hay que hacer.


    AsynchrounousTask *aTask = new AsynchrounousTask(ui->label);
    QThreadPool::globalInstance()->start(aTask);

Aunque creamos un objeto con new no hay que preocuparse por su destrucción, al terminar su ejecución a través del pool se liberará de forma automática. Si preferimos que no se libere de forma automática tan solo hay que llamar al método 'setAutoDelete(false)'.

Ejecutando las tareas más pesadas de la aplicación de esta forma no se bloqueará la aplicación en ningún momento y siempre responderá a las nuevas peticiones que el usuario haga.

Compilación de ejecutable con Qt Creator

2010-11-10T20:38:00.004+01:00

Cuando creamos una aplicación con Qt Creator en Windows es necesario incluir los ficheros dll de Qt para que la aplicación funcione correctamente.

En ocasiones este no es el comportamiento deseado, se puede generar un fichero ejecutable autónomo (sin necesidad de ninguna librería dll externa) ejecutando el siguiente comando:


qmake -nodepend -o Makefile project.pro

Si no se encuentra el programa qmake hay que añadirlo al PATH, la instalación por defecto de QT Creator no lo hace.
Una vez ejecutado el comando anterior, al compilar obtendremos un ejecutable con toda la funcionalidad incluida, sin necesidad de incluir ningún fichero dll.

Anidamiento de módulos en ruby

2010-10-17T10:48:00.004+02:00

Tal y como ocurre en python con los decoradores, cuando se programa un módulo en ruby debería dejarse la puerta abierta a que no fuera el único.

En el siguiente ejemplo tenemos dos módulos (Printable y Serializable), ambos métodos se deben poder combinar en cualquier orden y pudiendo aparecer uno, ninguno o ambos.

La clave para que un mismo método se ejecute en la clase y en cada uno de sus módulos, es la llamada a super.

En otros lenguajes esto no sería correcto, puesto que los módulos Printable y Serializable no son superclase de la clase Test, pero en ruby, super no llama exactamente a la superclase, sino que repite el mismo método que se está ejecutando obviando la definición actual.


module Printable
 def print_method
  super
  puts "I'm printable"
 end
end

module Serializable
 def print_method
  super
  puts "I'm serializable"
 end
end


class Test    
 include Printable
 include Serializable

 def method_missing(method, *args, &block)
  super if method.to_s != 'print_method'
 end

 def print_method
  super
  puts "I'm object of Test class"
 end
 
end

t = Test.new
t.print_method

Con este planteamiento hay un problema añadido, al final de la cadena de llamadas a print_method estará la clase de la que hereda Test, y esta clase no tiene porqué tener implementado print_method.

Para solucionarlo en este caso se redefine el method_missing, cuando llegue el momento de ejecutar el método en alguna clase/módulo que no lo entienda, se corta la cadena de ejecuciones.


I'm printable
I'm serializable
I'm object of Test class

Conversión implícita de tipos

2010-09-17T19:35:00.002+02:00

Es común escribir nuevas clases que expandan a las básicas del lenguaje.

Uno de los problemas que nos podemos encontrar cuando hacemos esto es la conversión de tipos.

Si por ejemplo creamos una nueva clase para manejar cadenas, el código se llenará rápidamente de castings para convertir las cadenas nativas del lenguaje a nuestra implementación. Esto ocurre sobre todo en lenguajes fuertemente tipados.

C# provee una solución bastante elegante, la conversión implícita de tipos.

Para mostrar el uso de esta característica se muestra una clase con dos tipos, una cadena y un entero y sus declaraciones de conversiones implícitas.


public class MyClass
{
    private string str { get; set; }
    private int number { get; set; }

    public static implicit operator MyClass(string s)
    {
        MyClass ms = new MyClass();
        ms.str = s;
        return ms;
    }

    public static implicit operator MyClass(int i)
    {
        MyClass ms = new MyClass();
        ms.number = i;
        return ms;
    }

    public string getStr()
    {
        return str;
    }

    public int getNumber()
    {
        return number;
    }
}

Declarando un operador estático, implícito y público se consigue la sintaxis siguiente para la conversión de tipos.


MyClass ms1 = "hello";
MyClass ms2 = 2;

Console.WriteLine(ms1.getStr());
Console.WriteLine(ms2.getNumber());

En el ejemplo se puede ver que no es necesaria ninguna conversión, y se pasan tanto la cadena "hello" como el entero 2 a tipo MyClass.

Extension methods en c#

2010-09-12T10:32:00.004+02:00

En algunos lenguajes dinámicos como ruby las clases se denominan "abiertas".
Esto significa que a cualquier clase se le puede añadir nuevos métodos o funcionalidades en tiempo de ejecución.

Los lenguajes fuertemente tipados no suelen ofrecer tanta libertad, pero se disponen de otras herramientas.

En C#, se pueden definir clases parciales, lo que significa que se puede definir el comportamiento de la clase en varias etapas.


public partial class PartialClass
{
    public static void method1()
    {
        Console.WriteLine("method1"); 
    }
}
...
public partial class PartialClass
{
    public static void method2()
    {
        Console.WriteLine("method2");
    }
}

Manteniendo las clases como parciales en cualquier momento se puede añadir funcionalidad a una clase existente fuera de su definición original.

Este método es útil tan solo para las clases que programamos, pero si queremos extender una librería externa o las clases del propio lenguaje las clases parciales no son de gran ayuda.

C# tiene en cambio una posibilidad más interesante, los "extension methods".


public static class ExtensionMethods
{
    public static string withDot(this string str)
    {
        return str + ".";
    }
}
...
string str = "text ";
str.withDot();

Con el código anterior se le añade a la clase string el nuevo método (withDot).
Para hacer lo mismo sin "extension methods" habría sido necesario crear una nueva clase que heredara de string y añadirle el método withDot.

Gracias a los "extension methods" se puede evitar crear clases intermedias para extender funcionalidades de las ya existentes.

Implementación explícita de interfaces en C#

2010-08-28T17:09:00.003+02:00

Por diversas razones como la colisión de nombres o simplemente por diseño, puede que necesitemos mayor granularidad para distinguir que método de que interfaz estamos definiendo.

Supongamos que tenemos el caso de una clase que implementa dos interfaces tal y como sigue:


public interface IInterface1
{
    int method();
    int method1();
}

public interface IInterface2
{
    int method();
    int method2();
}

public class ExampleClass : IInterface1, IInterface2
{
    public int method() { return 1; }
    public int method1() { return 1; }
    public int method2() { return 2; }

}

En este caso, el método method está presente en las dos interfaces y lo definimos en la clase.

Si necesitáramos distinguir alguno de los casos se podría usar la implementación explícita de interfaces.


public class ExampleClass : IInterface1, IInterface2
{
    public int method() { return 1; }
    public int method1() { return 1; }
    public int method2() { return 2; }

    int IInterface1.method() { return 1; }
    int IInterface2.method() { return 2; }

}


public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();

        ExampleClass example = new ExampleClass();
        IInterface1 i1 = (IInterface1)example;
        IInterface2 i2 = (IInterface2)example;

        MessageBox.Show("Interface 1: " + i1.method());
        MessageBox.Show("Interface 2: " + i2.method());
    }
}

Esto devolvería como resultados 1 y 2 respectivamente. Como vemos, a pesar de realizar la implementación explícita de ambas interfaces se sigue pudiendo implementar de la forma tradicional como caso base.

Internacionalización con QT

2010-07-21T22:30:00.001+02:00

La librería QT está desarrollada de tal forma que las aplicaciones
que estén hechas usando su API pueden internacionalizarse de forma bastante
fácil.

En primer lugar todas las cadenas de la aplicación deben sustituirse por llamadas
a la función tr.


QObject::tr("cadena");

La cadena que pasemos a la función tr servirá de índice para las cadenas
definitivas en los distintos idiomas.

Después se debe añadir una entrada en el fichero de proyecto (.pro) con los ficheros
que se deben generar para cada idioma de las traducciones, con extensión .ts.


TRANSLATIONS = en.ts es.ts

Los ficheros se generarán al ejecutar el comando:


lupdate proyecto.pro

Estos ficheros .ts se pueden editar con QT Linguist, una vez introducidas todas las
traducciones, se pueden exportar mediante la opción Release, esto generaráa
unos ficheros .qm.

Posteriormente hay que crear un fichero de recursos que contenga los ficheros .qm
de traducciones.

Para obtener el idioma del equipo en el que se está ejecutándo la aplicación se puede
hacer lo siguiente


QString locale = QLocale::system().name();

Para que las traducciones se carguen hay que instanciar la clase QTranslator y pasársela
a la aplicación.


QTranslator translator;
translator.load(locale, ":/");
a.installTranslator(&translator);

La ruta ":/" se refiere al prefijo introducido en el fichero de recursos.

Tras estos pasos las cadenas de la aplicación aparecerán traducidas dependiendo del idioma
del equipo en el que se esté ejecutándo.

Como implementar interfaces en C++

2010-07-15T22:18:00.002+02:00

C++ por si solo no trata las interfaces como un concepto diferenciado. Sin embargo se puede trabajar con interfaces tipo Java o C# aprovechándose de la heréncia múltiple creando clases abstractas.

En el siguiente ejemplo las clases ClassA y ClassB implementan la interfaz Interface, para ello tan solo tienen que redefinir el método method.


class Interface{
    public:
        virtual int method(int param) = 0;
        virtual ~Interface(){};
};

class ClassA : public Interface{
    public:
        int method(int param){return param+1;}
};

class ClassB : public Interface{
    public:
        int method(int param){return param+2;}
};

Todos los usos que se le dan normalmente a las interfaces siguen siendo válidos con esta aproximación, con una salvedad, si queremos pasar la interfaz como parámetro a una función normalmente se haría como sigue.


std::string function(Interface i){
    std::string str;

    int number = i.method(1);
    if(number==2){str = "ClassA";}
    else if(number==3){str = "ClassB";}

    return str;
}

Sin embargo, si hacemos esos el compilador protestará con un error similar a: "cannot declare parameter 'i' to be of abstract type 'interface'".

¿Por qué?
Esto ocurre porque por defecto en C++ los parámetros se pasan por valor, el objeto 'i' es imposible de crear ya que es de un tipo abstracto, el compilador no puede instanciarlo.

¿Qué solución hay?
Pasarlo como referencia, con una definición como la siguiente.


std::string function(Interface &i)

Si queremos asegurarnos que el parámetro no se modifica, habría que pasarlo como referencia constante.


std::string function(const Interface &i)

Esto plantea un nuevo problema, generando un error de compilación similar a: "passing 'const Interface' as 'this' argument of 'virtual int Interface::method(int)' discards qualifiers".

No se puede llamar a una función no constante desde un objeto constante. Para solucionarlo los métodos de la interfaz deberían ser constantes, quedando como sigue.


class Interface{
    public:
        virtual int method(int param) const = 0;
        virtual ~Interface(){};
};

class ClassA : public Interface{
    public:
        int method(int param) const{return param+1;};
};

class ClassB : public Interface{
    public:
        int method(int param) const{return param+2;};
};

Definición de funciones parciales

2010-07-05T21:06:00.003+02:00

La definición de funciones parciales (currificación) es una técnica de la programación funcional poco extendida.

A una función parcial con dos parámetros, se le puede pasar tan solo una variable, obteniendo como resultado de la ejecución otra función con una variable a la que ya se le a aplicado el primer parámetro. Por ejemplo, scala tiene una sintaxis muy simple para llevar a cabo esta técnica.


def function(x:Int)(y:Int) = x+y

val partial = function(3)_

partial(4)

Como resultado de la evaluación parcial (es obligatorio en scala acabarla con '_') se obtiene una función que solo necesita el segundo parámetro para ser evaluada.

Esta técnica puede servir para ahorrar código, modelar inyección de dependencia o reducir interfaces de un conjunto de funciones haciéndolas más sencillas.

Creación de servidores en javascript

2010-06-30T22:26:00.002+02:00

Aunque javascript está diseñado para ejecutarse en el cliente al cargar páginas web, no está limitado a este ámbito.
Existe un proyecto llamado CommonJS que amplia la funcionalidad del lenguaje haciéndole poder interactuar con el sistema como un lenguaje más.

node.js es un framework para la creación de servidores que se apoya en la librería CommonJS.
Está construido completamente siguiendo la filosofía "event-loop" y todas las operaciones I/O se realizan de manera asíncrona para una buen aprovechamiento de la concurrencia del sistema.

Así pues, node.js permite crear servidores optimizados de forma sencilla desde un lenguaje dinámico como javascript, un ejemplo muy simple de un servidor creado con node.js es el siguiente:


var sys = require('sys');
var net = require('net');

var acc = 0;

net.createServer(function (socket) {
 socket.setEncoding("utf8");
 socket.addListener("connect", function () {
  socket.write("Accumulator server\r\n");
  socket.write("Accumulator value: " + acc + '\n');
 });
 socket.addListener("data", function (data) {
  var input = parseInt(data);
  if(!isNaN(input)){acc += parseInt(data);}
  socket.write("Accumulator value: " + acc + '\n');
 });
 socket.addListener("end", function () {
     socket.end();
   });
}).listen(8888, "127.0.0.1");

Se puede consultar en mayor profundidad el API oficial.

Nuevos tipos de formularios en html5

2010-06-16T22:25:00.004+02:00

Con el salto a la nueva versión de html se van añadir nuevos tipos de entradas posibles a los formularios.
Por ejemplo, crear un 'slider' para seleccionar un rango se limitará a dar el tipo range a un input.


<input type="range" min="0" max="100" step="2">

Este componente enriquece la interfaz de usuario, hay otros aún más útiles, por ejemplo el siguiente indica que la entrada debe ser de tipo numérico, esto puede ayudar a dispositivos móviles con pantallas reducidas a desplegar tan solo un teclado con números, aprovechando mejor el espacio.


<input required type="number" min="0" step="1" >

También sirve el tipo email para idénticos propósitos. Además de esta forma los navegadores pueden añadir mayor integración (si conocen que el tipo de entrada es email pueden sugerir los de nuestra libreta de direcciones).

Otro tipo de entradas muy comunes son las de fecha, en buscadores de reservas de hoteles, vuelos, etc. La mayoría de webmaster solucionan el problema de mostrar un calendario con javascript.
En html5 se deja este la responsabilidad de representar estos tipos de entradas a los navegadores, habiendo inputs de tipo date, month, week, time...

Para más información.

Hot swapping en erlang

2010-06-13T11:03:00.004+02:00

Hot swapping en un entorno con múltiples procesos distribuidos se refiere a la actualización de uno de esos procesos sin parar en ningún momento el sistema.

Si se encuentra algún error en el software, o se necesita añadir nueva funcionalidad, el proceso afectado encola las peticiones nuevas que van llegando, actualiza su código y con el nuevo código sigue atendiendo a las peticiones que tenía encoladas. Los demás procesos del sistema no notan nada de este cambio.

En muchas de las tecnologías usadas hoy en día, todo este proceso es bastante complejo, sin embargo, en erlang es trivial ya que lo soporta de forma nativa el lenguaje.

Supongamos dos procesos, uno que sirve datos.


-module(data).
-export([get/0, version/0]).

get() -> 42.

version() -> 1.

Y otro que los consume.


-module(consumer).
-compile(export_all).

start() -> spawn(fun() -> loop() end).

loop() ->
 sleep(),
 io:format("Value: ~p at version: ~p~n", [data:get(), data:version()]),
 loop().


sleep() ->
 receive
  after 1000 -> true
 end.

El proceso consumidor irá mostrando cada segundo los datos que le manda el otro proceso. En el momento que se necesite cambiar la funcionalidad del proceso creador de datos, simplemente se recompila y el consumidor el único cambio que notará es el valor que tienen los nuevos datos.


1> c(data).
{ok,data}
2> c(consumer).
{ok,consumer}
3> consumer:start().
<0.53.0>
Value: 42 at version: 1
Value: 42 at version: 1
Value: 42 at version: 1
Value: 42 at version: 1
Value: 42 at version: 1
...
c(data).
{ok,data}
Value: 43 at version: 2
Value: 43 at version: 2
Value: 43 at version: 2
Value: 43 at version: 2
...

En entornos críticos o en los que el sistema completo tarda mucho tiempo en arrancar, esto permite actualizar código sin que haya que mantener el servicio parado mientras se actualilza.

Código Thread-Safe vs Código reentrante

2010-06-10T22:46:00.003+02:00

Estos dos conceptos son habitualmente confundidos y, aunque están relacionados se corresponden a propiedades distintas.

Una función es thread-safe cuando se le puede llamar desde múltiples hilos concurrentemente, la ejecución terminará correctamente sin que unos hilos interfieran con otros.

Una función reentrante es aquella a la que se le pasa como parámetro todos los valores que usa, no utiliza ningún objeto global (variable global, singleton), no tiene efectos secundarios y no llama a ninguna función no reentrante.

Una función reentrante será siempre thread-safe, si no hace ningún cambio en el estado global de un programa no hay posibilidad que interceda con el código de otra hebra.

¿Y al contrario? Una función thread-safe no tiene porqué ser reentrante, ya que puede modificar el estado global del programa siempre que lo haga ordenadamente mediante exclusión mutua.

Una función reentrante cumplirá además con la transparencia referencial. Transparencia referencial es una propiedad que se cumple cuando, al cambiar una función con sus parámetros por el valor que devuelve, el programa se comporta de la misma forma.

Este tipo de funciones (reentrantes) tienen la ventaja de que se puede seguir su funcionamiento matemáticamente y que admiten memoization como optimización. Un ejemplo aquí.

Ejecución de código remoto con ruby

2010-06-06T10:03:00.004+02:00

Existe una librería llamada msgpack que permite la ejecución remota de código ruby (entre otros lenguajes), lo que más destaca de esta librería es su sencillez y la poca configuración necesaria para funcionar.

En un ejemplo cliente/servidor, el servidor es una instancia de una clase que contiene los métodos que queremos ejecutar de forma remota. Además de eso tan solo tenemos que elegir a qué clientes escuchamos y en qué puerto.


require 'rubygems'
require 'msgpack/rpc'

class RemoteServer
 def printer(arg)
  puts "Printing: #{arg}..."
  return true
 end
end

server = MessagePack::RPC::Server.new
server.listen('0.0.0.0', 8888, RemoteServer.new)
server.run

Un cliente que se conecte al servidor anterior sería el siguiente.


require 'rubygems'
require 'msgpack/rpc'
  
client = MessagePack::RPC::Client.new('127.0.0.1', 8888)  
called = client.call_async(:printer, 'message')
result = called.get

La llamada call_async hace que se ejecute el método de forma asíncrona, si necesitamos el valor devuelto por la función será necesario llamar a get que se asegura de la terminación del método y de recoger el resultado.
También se puede ejecutar código de forma síncrona con call.

Además, la librería permite crear sesiones para reaprovechar las conexiones con el servidor.


require 'rubygems'
require 'msgpack/rpc'
  
session_pool = MessagePack::RPC::SessionPool.new
client = session_pool.get_session('127.0.0.1', 8888)
result = client.call(:printer, 'message')

Solución al problema de la inclusión cíclica en C++

2010-06-03T22:25:00.002+02:00

En aplicaciones complejas se puede dar el caso de que una clase(Class1) haga uso de otra(Class2), pero a su vez esta última haga uso de la primera.

En este caso estamos ante un problema de definición cíclica, para definir una clase se necesita la otra y viceversa. Se ejemplifica en el siguiente código.


#ifndef CLASS1_H
#define CLASS1_H

#include "class2.h"

class Class1{
 void method(Class2* param);
};

#endif


#ifndef CLASS2_H
#define CLASS2_H

#include "class1.h"

class Class2{
 void method(Class1* param);
};

#endif

Para solucionar este problema, podemos indicarle al compilador que la clase existe y será definida más adelante, así, aún teniendo dependencia cíclica se puede generar el código correctamente.
Para indicarselo al compilador tan solo hay que definir class Clase antes de usarla.


#ifndef CLASS1_H
#define CLASS1_H

#include "class2.h"

class Class2;

class Class1{
 void method(Class2* param);
};

#endif


#ifndef CLASS2_H
#define CLASS2_H

#include "class1.h"

class Class1;

class Class2{
 void method(Class1* param);
};

#endif

Web SQL en html 5

2010-06-02T22:51:00.002+02:00

Con la llegada de html 5 los navegadores pondrán a disposición de los programadores web la tecnología web SQL.

Esta tecnología consiste básicamente en una base de datos local a los navegadores accesible desde javascript. Permitirá que las aplicaciones web puedan hacer mayor trabajo offline y sincronizarse cada cierto tiempo con el servidor.

El acceso a estas bases de datos se hace mediante SQL.
Para abrir una base de datos se necesita ejecutar lo siguiente.


function openDB(dbName){
 var version = 1;
 var db = window.openDatabase(dbName, version, dbName, 2*1024);
 return db;
}

Una vez abierta la base de datos para ejecutar SQL podemos disponer de las siguientes funciones.


function executeSQL(db, sqlString, args){
  db.transaction(function(t){
    t.executeSql(sqlString, args);
  }); 
}

function executeSQL(db, sqlString, args, callback){
  db.transaction(function(t){
    t.executeSql(sqlString, args, callback);
  }); 
}

Se puede pasar opcionalmente un callback a la función executeSQL, es especialmente útil en las consultas para tratar el resultado. Un ejemplo de callback para consultas es showEntries definida más adelante.
Este es un ejemplo típico de uso de web SQL.


function insertEntry(db, name){
 executeSQL(db, "INSERT INTO entries(name) VALUES (?)", [name]);
}

function selectAllEntries(db, callback){
 executeSQL(db, "SELECT * FROM entries", [], callback);
}

function showEntries(t, rs){
 var entry;
 
 for(var i=0; i<rs.rows.length; i++){
  entry = rs.rows.item(i);
  alert(entry['name']);
    } 
}


var db = openDB("example");
executeSQL(db, "CREATE TABLE IF NOT EXISTS entries(id INTEGER PRIMARY KEY, name TEXT)", []);

for(var i=0; i<10; i++){
 insertEntry(db, "test"+i);
}

selectAllEntries(db, showEntries);

Modificar bases de datos en android

2010-05-25T22:23:00.003+02:00

Casi todas las apliaciones android guardan información en bases de datos, el propio teléfono soporta nativamente SQLite3.

Las bases de datos se guardan en el directorio /data/data/nombre.paquete.programa/databases/
Para copiar una base de datos del teléfono al ordenador tan solo hay que hacer (tras tener el android SDK instalado).


adb pull /data/data/nombre.paquete.programa/databases/example_database.db .

Una vez en el ordenador se pueden hacer las comprobaciones que se necesiten con cualquier cliente sqlite3.

Para pasar de nuevo la base de datos modificada al móvil se puede hacer con el siguiente comando.


adb push example_database.db /data/data/nombre.paquete.programa/databases/

Functors en C++

2010-05-22T17:50:00.004+02:00

Los functors se definen como 'objetos función'.
Son la evolución natural de los punteros a función de C, un ejemplo de la sintaxis para definir un functor es el siguiente.


#include <iostream>
#include <string>
#include <cmath>

using namespace std;

class PrinterFunctor{
    private:
     string msg;

    public:
     PrinterFunctor(string _msg){
         msg = _msg;
    }
  
     void operator()(){
        cout << msg << endl; 
    }
};


int main() {
    PrinterFunctor pf("Printing from printer functor");
    pf();

}

Para crear un functor simplemente hay que redefinir el operador (), tras eso podremos llamar al functor como si fuera una función más.

Con un functor podemos implementar una función 'resumible', es decir, una función que recuerde el estado anterior para producir el siguiente. Por ejemplo.


class PrimeGenerator{
 private:
  int currentPrime;

 public:
  PrimeGenerator(int _prime){
   currentPrime = _prime;
  }
  
  bool isPrime(int n){
   int root = (int) sqrt(n);
   
   for(int i=2; i<root+1; i++){
    if(n%i==0) return false;
   }
   
   return true;
  }
  
  int operator()(){
   int n = currentPrime;
   
   while(1){
    n++;    
    if(isPrime(n)){
     currentPrime = n;
     return currentPrime;
    }
   }
  }
};

Esta clase devolverá el siguiente número primo cada vez que la llamemos, si hacemos lo siguiente generará los 100 primeros números primos empezando por 5.


int main() {
    PrimeGenerator primeGenerator(5);
    for(int i=0; i<100; i++){
         cout << primeGenerator() << endl;
    }
}

Wingedbox

2010-05-16T16:45:00.004+02:00

Este post es para anunciar la salida de un nuevo proyecto, wingedbox.

Es un proyecto lanzado por kikorb y por mí (javiyu). El concepto detrás de esta nueva web es compartir ficheros de una forma más ágil con tus amigos, no encontramos nada que encajara con nuestras necesidades así que decidimos hacerlo nosotros mismos.

Se le ha llamado "twitter de ficheros" de forma bastante acertada, ya que describe bastante bien la funcionalidad básica. Aún está en fase alpha pero realmente está teniendo muy buena acogida.

Pronto saldrá tanto el API público entre otras novedades, ya están disponible la visualización online de imágenes y fotos y el streaming de música.

Aún no tenemos buzón de sugerencias en la web, así que si tenéis algún tipo de duda o sugerencia podéis escribir un email tanto a kikorb como a mí.

Bloques with de python

2010-05-15T11:26:00.003+02:00

En Java es muy común la combinación de bloques try catch finally para obtener/liberar recursos de forma segura.

En python hay otra forma más elegante de hacerlo.


class database_connection:
        def __enter__(self):
                print("Open database connection")
                return 1
        def __exit__(self, type, value, traceback):
                print("Close database connection")

with database_connection() as db:
 print(db)

Al definirnos una clase con los métodos __enter__ y __exit__ y ejecutarla en un bloque with se nos asegura que:

1) Al entrar al bloque se ha ejecutado el método __enter__.
2) Tanto si hay un error en el bloque with como si termina correctamente, los recursos serán liberados (llamada a la función __exit__).
3) Opcionalemente se puede devolver un valor para usarlo dentro del bloque (en este caso db), aunque no es obligatorio.

Web Storage, sessionStorage y localStorage en html 5

2010-05-03T23:15:00.002+02:00

Con el nuevo estándar html 5 se ha introducido el concepto de web storage.

Mediante el objeto sessionStorage se puede guardar información relativa solo a la ventana actual, es decir, a diferencia de las cookies, aunque tengamos dos ventanas del navegador abiertas en una pagina del mismo dominio, la variable sessionStorage será única para cada ventana.
La sintaxis es muy sencilla, para guardar el email del usuario se puede hacer algo como lo siguiente.


sessionStorage.email='mail@sever.com'

Para recuperarlo después tan solo hay que ejecutar:


sessionStorage.email

Con el objeto localStorage se guarda información en local de forma permanente, entre ventanas del navegador, de forma global y por dominio. La sintaxis para utilizarlo es similar a la de sessionStorage.

Compilar a código ensamblador en formato intel con gcc

2010-05-01T16:19:00.003+02:00

Aunque por defecto gcc produce código ensamblador con sintaxis AT&T al pasar la opción -S también es posible hacer que la salida sea con formato Intel.

Tan solo hay que ejecutar el siguiente comando.


gcc -S -masm=intel proc.c

Realizar las modificaciones que sean necesarias y después para hacer el enlazado.


gcc prog.s -o prog

Ensamblador inline en código C

2010-04-24T23:29:00.002+02:00

Para incluir código ensamblador en un programa escrito en C la sintaxis es la siguiente.


#include <stdio.h>

int main(){
 int var1 = 1;
 int var2;
 int var3;
 
 __asm__(
  "inc %%eax \n\t"
  "movl %%eax, %%ecx \n\t"
  "inc %%ecx \n\t"
  :"=a" (var2), "=c" (var3)
  :"a" (var1)
 );

 printf("Value1: %d\n", var1);
 printf("Value2: %d\n", var2);
 printf("Value3: %d\n", var3);


 return 0;
}

Los paréntesis se escriben dobles para escapar el carácter '%' ya que en C es un modificador de cadena.

Todas las líneas acaban en '\n\t' para que el código en ensamblador quede formateado igual que el resto.

Los registros no se usan con el nombre como tal para las entrada/salida, se usan alias del tipo "a=eax, b=ebx, c=ecx...".

En el primer apartado "=a" (var2), "=c" (var3) se les está diciendo que el contenido final de eax lo lleve a var2 y el contenido de ecx lo lleve a var3.

En el segundo apartado "a" (var1) se le dice que se comience el bloque copiando el valor de var1 a eax, actuará como entrada.

El compilador da por hecho que los registros usados para entrada/salida del bloque en ensamblador no los puede reutilizar, pero si se utilizan más registros se pueden poner en un tercer apartado de forma opcional.

El bloque ensamblador escrito antes, hará lo siguiente:

1. Copia el valor de var1 a eax.
2. Incrementa el valor de eax en 1.
3. Copia el contenido de eax a ecx.
4. Aumenta el valor de ecx en 1.
5. Copia el valor de eax a var2.
6. Copia el valor de ecx a var3.

Position Independent Code

2010-04-20T22:28:00.005+02:00

El position independent code o código no dependiente de posición es aquel que se puede reubicar en memoria y aún así seguirá funcionando correctamente.

Por defecto, en Mac el código producido por gcc es PIC, pero se puede forzar a que produzca código no PIC con la opción -fno-pic.
Si tomamos por ejemplo el siguiente código en C.


#include<stdio.h>

void func(){
 printf("Hello again\n");
}

int main(){
 printf("Hello world\n");
 func();
 
 return 0;
}

Y lo compilamos como no PIC con la siguiente instrucción.


gcc -fno-pic -S program.c -o nopic.asm

Se obtiene.


 .cstring
LC0:
 .ascii "Hello again\0"
 .text
.globl _func
_func:
 pushl %ebp
 movl %esp, %ebp
 subl $24, %esp
 movl $LC0, (%esp)
 call _puts
 leave
 ret
 .cstring
LC1:
 .ascii "Hello world\0"
 .text
.globl _main
_main:
 pushl %ebp
 movl %esp, %ebp
 subl $24, %esp
 movl $LC1, (%esp)
 call _puts
 call _func
 movl $0, %eax
 leave
 ret
 .subsections_via_symbols

Se puede ver que la cadena almacenada en la línea 3 se referencia en la línea 10 de forma absoluta. Si cambia la ubicación del programa en memoria LC0 seguirá referenciando a la misma posición, pero allí ya no estará la cadena que se esperaba.

Por el contrario, si dejamos al compilador con las opciones por defecto, producirá código PIC, quedando de la siguiente forma.


 .cstring
LC0:
 .ascii "Hello again\0"
 .text
.globl _func
_func:
 pushl %ebp
 movl %esp, %ebp
 pushl %ebx
 subl $20, %esp
 call L3
"L00000000001$pb":
L3:
 popl %ebx
 leal LC0-"L00000000001$pb"(%ebx), %eax
 movl %eax, (%esp)
 call L_puts$stub
 addl $20, %esp
 popl %ebx
 leave
 ret
 .cstring
LC1:
 .ascii "Hello world\0"
 .text
.globl _main
_main:
 pushl %ebp
 movl %esp, %ebp
 pushl %ebx
 subl $20, %esp
 call L6
"L00000000002$pb":
L6:
 popl %ebx
 leal LC1-"L00000000002$pb"(%ebx), %eax
 movl %eax, (%esp)
 call L_puts$stub
 call _func
 movl $0, %eax
 addl $20, %esp
 popl %ebx
 leave
 ret
 .section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
L_puts$stub:
 .indirect_symbol _puts
 hlt ; hlt ; hlt ; hlt ; hlt
 .subsections_via_symbols

En esta ocasión se puede ver que en la línea 15 se carga la cadena, pero de forma relativa, usando la diferencia entre la posición actual y la de la cadena. Además, se puede ver que hay unas nuevas directivas al incluir la función puts.

¿Por qué puede preferirse la generación de código no PIC? Pues observando los ejemplos se puede ver que generar código no dependiente de la posición del programa requiere más instrucciones en ensamblador y por tanto mayor tiempo a la hora de ejecutarse.

Paso de mensajes entre procesos en windows

2010-04-19T22:34:00.003+02:00

En la plataforma Windows tanto para la comunicación entre procesos como para el manejo de eventos se usa un sistema de mensajes.

Una de las características del sistema de mensajes de Windows es no disponer de autentificación, se puede aprovechar este hecho para simular eventos en los programas que se están ejecutando y de esta forma controlarlos desde el API de mensajes.

Se puede por tanto manejar un programa de forma automática desde otro, con las posibilidades que ello ofrece. Orientándolo a la ingeniería inversa se puede hacer fuzzing a programas que tan solo admiten entradas desde la interfaz gráfica.

Supongamos que tenemos un programa cuya ventana principal se llama "Form1" y un botón con el texto "Boton" en el cual al hacer click en un botón muestra un mensaje.


...
private void button_Click(object sender, EventArgs e){
    MessageBox.Show("Wow!", "Clicked", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
...

Podemos simular que hacemos click en ese botón si desde otro programa hacemos lo siguiente.


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace WFuzzing{
    public partial class Form2 : Form{
        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr FindWindow(string strClassName, string strWindowName);

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        public static extern int SendMessage(int hWnd, uint Msg, long wParam, long lParam);

        [DllImport("user32.dll", CharSet = CharSet.Auto)]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool EnumChildWindows(IntPtr hwndParent, EnumWindowsProc lpEnumFunc, IntPtr lParam);
        public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr parameter);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

        public const int WM_LBUTTONDOWN = 0x0201;
        public const int WM_LBUTTONUP = 0x0202;

        public Form2(){
            InitializeComponent();
        }

        private void fuzzbutton_Click(object sender, EventArgs e){
            IntPtr wHandle = FindWindow(null, "Form1");
            List<IntPtr> result = new List<IntPtr>();
            GCHandle listHandle = GCHandle.Alloc(result);
            EnumWindowsProc childProc = new EnumWindowsProc(EnumWindow);
            EnumChildWindows(wHandle, childProc, GCHandle.ToIntPtr(listHandle));
        }

        private static bool EnumWindow(IntPtr handle, IntPtr pointer){
            StringBuilder text = new StringBuilder(256); ;
            GetWindowText(handle, text, text.Capacity);
            
            if(text.ToString() == "Boton"){
                long lngResult = SendMessage(handle.ToInt32(), WM_LBUTTONDOWN, 0, 0);
                long lngResult2 = SendMessage(handle.ToInt32(), WM_LBUTTONUP, 0, 0);
            }
            return true;
        }

    }
}

Se le mandan dos mensajes, el primero el de hacer click con el ratón y el segúndo el de levantar el dedo del ratón.

Al ejecutar ese código el primer programa debería mostrar el mismo mensaje que si hacemos click en el botón.

De forma similar, se puede automatizar la búsqueda de fallos en programas de los cuales no disponemos del código fuente, tan solo manipulando la interfaz, rellenando campos de texto, activando y desactivando controles, todo de forma automática.

Metaprogramación en c#

2010-04-07T22:30:00.004+02:00

Aunque c# no proporcione demasiadas ayudas sintácticas a la metaprogramación si que se pueden aprovechar sus estructuras y tipos de datos para generar métodos de fórma dinámica.

En el siguiente código hay un ejemplo.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Collections;
using System.Runtime.InteropServices;


namespace example1{
    class Program{
        [DllImport("msvcrt.dll")]
        static extern bool system(string str);

        static void Main(string[] args){
            Dictionary<string, Action<string>> method = new Dictionary<string, Action<string>>();
            Expression<Action<string>> exp;

            for (int i = 0; i < 100; i++)
            {
                var number = i;
                exp = (p => Console.WriteLine("Parametro: " +p+"\nMetodo numero: "+number));
                method["print_" + i] = exp.Compile();

                exp = (p => Console.WriteLine(p + number));
                method["concat_" + i] = exp.Compile();
            }

            method["print_17"]("test");
            method["concat_35"]("Concatenando el numero -> ");
            

            system("pause");
        }
    }
}

En primer lugar se crea un diccionario llamado method para contener todas las funciones generadas automáticamente.

Luego, en el bucle se crean 200 métodos, tanto dependientes de parámetro como de su posición en el bucle, sin embargo, para esto es necesario un pequeño hack.
Se le asigna a number el valor del contador, creando un objeto en cada iteración, en caso contrario todos los métodos creados tendrán como valor de i el último que ha tomado en el bucle, es decir, 100.

Expresiones regular en C++ con boost

2010-04-06T23:50:00.003+02:00

La mayoría lenguajes de programación modernos proporcionan la posibilidad de usar expresiones regulares de forma nativa desde el propio lenguaje, sin embargo, en C++ es necesario recurrir a alguna librería como Boost.Regex.

Boost.Regex ofrece la mayoría de funciones comunes de las expresiones regulares.


#include <iostream>
#include <string>
#include <boost/regex.hpp>

int main(){ 
 std::string s = "BEGIN->Cadena_entre_delimitadores<-END"; 
 std::string s2 = "Cadena de texto con 3 numeros para sustituir 1, 4 por incognitas"; 
 boost::regex r("BEGIN->(\\w+)<-END"); 
 boost::regex r2("\\d"); 
 boost::smatch result; 

 if (boost::regex_search(s, result, r)){ 
  for(int i=0; i<result.size(); i++){
   std::cout << "Ocurrencia n " << i+1 << ": "<< result[i] << std::endl; 
  }  
 }
 else{
  std::cout << "Ninguna coincidencia" << std::endl;
 }

 std::cout << "---" << std::endl;
 std::string number("X"); 
 std::cout << "Cadena modificada con una expresion regular: ";
 std::cout << boost::regex_replace(s2, r2, number) << std::endl; 
 
}

Con regex_search se pueden encontrar coincidencias de una expresión regular r dentro de una cadena s. Como resultado también tendrá en cuenta los grupos de captura.

Con regex_replace se pueden hacer sustituciones, cambiando las ocurrencias encontradas en la cadena s2 según el patrón r2, sustituyéndolas por number.

Papra compilar es necesario incluir tanto los headers como la librería correspondiente, en mi caso.


g++ -lboost_regex-mt -I/opt/local/include/ -L/opt/local/lib/ regex.cpp -o regex

Programación de callbacks con Boost

2010-03-19T12:15:00.005+01:00

Usando las librerías Boost.Function y Boost.Bind se pueden crear fácilmente callbacks en c++ sin necesidad de usar punteros a función.

Un ejemplo.


#include <boost/function.hpp>
#include <boost/bind.hpp>

#include <iostream>


using namespace boost;

class Example{
 private:
  int a;
 public:
  function<void(std::string)> callback; 
  
  void setA(int value){
   a = value;
   changeA();
   if(callback){callback("setA");}
  }

  void changeA(){
   a++;
   if(callback){callback("changeA");}   
  }  
};


void debug(std::string s){
 std::cout << "Method called: " << s << std::endl;
}

int main(){
 Example e;
 e.callback = bind(&debug, _1); 
 e.setA(123);   
}

Siguiendo el planteamiento anterior obtendríamos la cadena de llamadas a las funciones de la clase Example.

Si no establecemos el callback (en este caso se hace en la segunda línea de main) el comportamiento será el normal, sin embargo, en caso de necesidad se le puede hacer un bind al objeto que queramos con una función de debug.

La programación usando callbacks es especialmente útil en programación concurrente, para más información en la página de Boost.Function.

Usar OpenGL desde ruby

2010-03-14T13:02:00.002+01:00

Es interesante poder crear demos o escenarios en 3D desde un lenguaje dinámico como ruby (cuando el rendimiento no sea un problema).

Hay unos bindings para opengl llamados ruby-opengl que nos permiten acceder directamente a la API de OpenGL desde ruby.

Os dejo un ejemplo (inspirado en los tutoriales de NeHe) para que os hagáis una idea de la sintaxis.


require 'rubygems'
require 'opengl'

require "gl"
require "glu"
require "glut"
require "mathn"

include Gl, Glu, Glut

window = ""

def init_gl_window(width = 640, height = 480)
    glClearColor(0.0, 0.0, 0.0, 0)
    glClearDepth(1.0)
    glDepthFunc(GL_LEQUAL)
    glEnable(GL_DEPTH_TEST)
    glShadeModel(GL_SMOOTH)

    glMatrixMode(GL_PROJECTION)
    glLoadIdentity
    gluPerspective(45.0, width / height, 0.1, 100.0)

    glMatrixMode(GL_MODELVIEW)

    draw_gl_scene
end

def reshape(width, height)
    height = 1 if height == 0

    glViewport(0, 0, width, height)

    glMatrixMode(GL_PROJECTION)
    glLoadIdentity

    gluPerspective(45.0, width / height, 0.1, 100.0)
end

$color1_intensity = 0
$color2_intensity = 0
$color3_intensity = 0

$rotation = 0

def draw_gl_scene
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    glMatrixMode(GL_MODELVIEW)
    glLoadIdentity
    glTranslatef(0, 0, -6)
    
    # Draw a triangle
    glBegin(GL_POLYGON)
        glColor3f($color1_intensity, $color2_intensity, $color3_intensity)
        glVertex3f( 0.0,  1.0, 0.0)
        glColor3f($color3_intensity, $color1_intensity, $color2_intensity)        
        glVertex3f( 1.0, -1.0, 0.0)
        glColor3f($color2_intensity, $color3_intensity, $colo1r_intensity)
        glVertex3f(-1.0, -1.0, 0.0)
    glEnd

    $color1_intensity += 0.0005 if($color1_intensity %gt; 0.5)
    $color2_intensity += 0.0005 if($color2_intensity %gt; 0.5)
    $color3_intensity += 0.0010 if($color3_intensity %gt; 1)

    glutSwapBuffers
end

def idle
    glutPostRedisplay
end

# Keyboard handler to exit when ESC is typed
keyboard = lambda do |key, x, y|
  if(key == 27) then
    GLUT.DestroyWindow($window)
    exit(0)  
  end
end


glutInit
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH)
glutInitWindowSize(640, 480)
glutInitWindowPosition(0, 0)
window = glutCreateWindow("Example")
glutDisplayFunc(method(:draw_gl_scene).to_proc)
glutReshapeFunc(method(:reshape).to_proc)
glutIdleFunc(method(:idle).to_proc)
glutKeyboardFunc(keyboard)
init_gl_window(640, 480)
glutMainLoop()

Quizá sería interesante aportar un grado más de abstracción para hacer aún más sencillo la elaboración de gráficos desde este tipo de lenguajes.

Unit Testing en C++ con Igloo

2010-03-03T23:53:00.005+01:00

La realización de test unitarios aún siendo una buena práctica de programación puede ser muy tediosa si no se utiliza alguna librería que nos descargue de trabajo.

Igloo para C++ nos provee de una API muy sencilla, además tiene la ventaja de que no necesita instalación ya que Igloo es simplemente un conjunto de ficheros de cabecera.

Lo único que necesitamos para usar Igloo es bajarnos la última versión y compilar nuestro test incluyendo sus cabeceras:


g++ tests.cpp -o tests -I/path/de/igloo/

Dejo un ejemplo de como quedaría un conjunto de test unitarios a una clase.


#include <igloo/igloo.h>
#include <stdio.h>
#include <stdlib.h>

using namespace igloo;

class Example{
 private:
  int atrib1;
  int atrib2;
  
 public:
  Example(int a1, int a2){
   atrib1 = a1;
   atrib2 = a2;
  }
  
  int getAtrib1(){return atrib1;}
  int getAtrib2(){return atrib2;}

  static int sum(int n){
   int result = 0;
   for(int i=1; i<=n; i++){result+=i;}
   return result;
  } 
};

TestFixture(Assertions){
 TestMethod(ShouldHandleIntegerEquality){
  Assert::That(Example::sum(5), Is().EqualTo(15));  
 }
  
 TestMethod(ShouldHandleStrings){
  Example e(5,6);
  char c1[100];

  sprintf(c1, "%d", e.getAtrib1());
  std::string a1(c1);
  sprintf(c1, "%d", e.getAtrib2());  
  std::string a2(c1);  
  
  Assert::That(a1, Is().Not().EqualTo(a2));
 }
};

int main(){
  return TestRunner::RunAllTests();
}

Al ejecutar el programa anterior obtendríamos la salida: Test run complete. 2 tests run, 2 succeeded, 0 failed

Smart pointers de la librería Boost

2010-02-19T00:15:00.005+01:00

Una de las ventajas que tiene la programación en Java sobre C++ es la recolección de basura.

Cuando escribimos un programa en Java no nos tenemos que preocupar de liberar la memoria que vamos usando, hay un recolector de la máquina virtual que lo hace por nosotros. De esta forma se reduce el número de memory leaks y se facilita la programación.

En C++ sin embargo la gestión de memoria debe realizarla el desarrollador, proporcionando más potencia pero también dificultando el desarrollo.

Para facilitar la programación en este apartado, la librería Boost cuenta con un concepto llamado smart pointers que liberan de complejidad a la hora de gestionar la memoria al programador.

Por ejemplo, usando el tipo scoped_ptr.


#include <boost/smart_ptr.hpp>

class Example{
 public:
  int a;
};

void scoped_pointer(){
 boost::scoped_ptr<Example> ptr(new Example);
}

void pointer(){
 Example *ptr = new Example;
}


int main(){
 while(1){
  pointer();
 }
}

Al ejecutar este programa se irá reservando memoria constantemente hasta agotar la memoria total del sistema, puesto que en ningún momento se libera.

Sin embargo, si se modifica la llamada pointer por scoped_pointer el programa se ejecutará de forma estable, dado que al terminar el método, el scoped pointer libera la memoria utilizada de forma automática.

Hay smart pointers con otras políticas de gestión de memoria, para elegir cual nos conviene en la documentación de boost se detalla cada uno.

Profiling de peticiones en ruby on rails

2010-01-24T10:23:00.003+01:00

Ruby es un lenguaje dinámico muy potente pero por ello también muy díficil de depurar en ocasiones. En ruby on rails con los named_scope, before_filter, plugins, gems, etc puede ser todavía peor.

Sin embargo, en los sistemas operativos que soportan DTrace tenemos una ayuda para encontrar los cuellos de botella de la aplicación, por ejemplo, usando el script que hay en: http://dl.getdropbox.com/u/478290/blog/dtrace/rb_linetime.d.

Simulo un before_filter muy lento que se ejecute para todas las request como éste:


22  def takes_too_long
23    i = 0
24    100.times{
25      100000.times{i+=1}
26      100000.times{i-=1}
27    }
28  end

Después arrancamos el servidor de ruby on rails y obtenemos su PID (vía passenger-status, ps, top...)

Ejecutamos:


sudo dtrace -s rb_linetime.d -p pid_del_servidor > request.log

Hacemos una petición a la aplicación ruby on rails, después paramos DTrace con Ctrl+C y en request.log podemos ver los ficheros ruby que se van cargando y cuanto tarda cada uno, en concreto, nos fijamos en las líneas:


FILE                                                                                                                      LINE  COUNT    AVG(us)      SUM(us)
...

/Users/javiyu/projects/rails/prueba/vendor/rails/activesupport/lib/active_support/core_ext/module/introspection.rb          86    849        188       160330
/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8/gems/mongrel-1.1.4/lib/mongrel/configurator 285     83      30374      2521066
/Users/javiyu/projects/rails/prueba/app/controllers/application.rb 26 600000         16      9690835
/Users/javiyu/projects/rails/prueba/app/controllers/application.rb   25 681051         16     11087871
/Users/javiyu/projects/rails/prueba/vendor/rails/railties/lib/commands/servers/base.rb 14     69     974199     67219750
....

Vemos que application.rb tarda mucho más de lo normal, e incluso detecta el número de línea en el que está el cuello de botella, en este caso la 25 y la 26.

Obtención de información relativa al procesador

2010-01-11T22:51:00.003+01:00

Para la generación de código optimizado puede ser necesario conocer sobre que tipo de procesador se está ejecutando nuestro programa y que instrucciones soporta.

La instrucción cpuid proporciona información relativa al procesador.
Por ejemplo.


#include <stdio.h>

typedef unsigned int uint;

void print_register_str(reg){
 int i;
 
 for(i=0; i<4; i++){
  printf("%c", reg >> (i*8) );
 } 
}

void cpuid(uint *eax, uint *ebx, uint *ecx, uint *edx, uint service){
 __asm__ (
  "pushl %%ebx \n\t"
  "cpuid \n\t"
  "movl %%ebx, %1 \n\t"
  "popl %%ebx \n\t"
  : "=a" (*eax),
  "=S" (*ebx),
  "=c" (*ecx),
  "=d" (*edx)
  :"a" (service)
 );
}

int main(){
 uint eax, ebx, ecx, edx;
 
 printf("VendorString: ");
 cpuid(&eax, &ebx, &ecx, &edx, 0);
 print_register_str(ebx);
 print_register_str(edx);
 print_register_str(ecx);
 printf("\n");

 
 cpuid(&eax, &ebx, &ecx, &edx, 1);
 printf("MMX support: %d\n", (edx >> 23) & 1); 
 printf("SSE support: %d\n", (edx >> 25) & 1);
 printf("SSE2 support: %d\n", (edx >> 26) & 1);
 printf("HyperTransport: %d\n", (edx >> 28) & 1);
 printf("SSE3 support: %d\n", (ecx) & 1);

 return 0;
}

Este programa tiene como resultado para mi cpu.


VendorString: GenuineIntel
MMX support: 1
SSE support: 1
SSE2 support: 1
HyperTransport: 1
SSE3 support: 1

Se puede obtener más información específica, aquí vienen algunos ejemplos más: http://softpixel.com/~cwright/programming/simd/cpuid.php.

Implementación de malloc en glibc

2009-12-28T23:27:00.002+01:00

malloc es una función de C que sirve para reservar n bytes consecutivos en memoria y devuelve un puntero a ese array.

¿Qué pasa cuando se agota la memoria? En teoría la función malloc debería devolver un puntero nulo y establecer la variable errno a ENOMEM.

¿Qué ocurre en realidad? En la librería de C de Linux (glibc) se usa un algoritmo de reserva de memoria optimista, no contempla el caso de haber agotado la memoria y siempre se devuelve un puntero válido. Según la manpage "uno o varios procesos pueden morir en estas situaciones llegándoles el mensaje 'out of memory'".

Hay una forma de solucionar esto, cambiar el comportamiento del algoritmo estableciendo a 2 la variable overcommit_memory con el comando:

echo 2 > /proc/sys/vm/overcommit_memory

Fuentes:
manpagez.com
linux.die.net

Ejecución asíncrona de javascript con web workers

2009-11-01T16:46:00.006+01:00

Tal y como anunciaba Google en la Google IO de este año han estado trabajando junto a la fundación Mozilla en la definición e implementación de los llamados web workers.

Los web workers permiten carga y ejecución asíncrona de javascript, tienen algunas limitaciones ya que no se puede acceder al DOM entre otras funciones, usa threads a nivel de sistema operativo y usa como método de sincronización paso de mensajes.

Un ejemplo de sincronización sencillo.

long_work.js


var j=1;
for(var i=0; i<999999999; i++){j=j*7+2;j=1}
this.postMessage('Done');

index.html


<script type="text/javascript">
     var worker = new Worker("/javascripts/long_work.js");
     worker.onmessage = function(event){
       alert(event.data);
     };
</script>

Ejemplo de uso en la web de la fundación Mozilla.

Como hacer copias de seguridad de tu agenda en symbian

2009-08-15T22:50:00.002+02:00

Ya que tenemos acceso al API de symbian desde python (gracias al proyecto pys60) podemos aprovecharnos para hacer algunas cosas útiles con unos scripts simples en python.

Por ejemplo, para hacer una copia de seguridad de la agenda serviría el siguiente script.


from contacts import ContactsDb

contacts = ContactsDb().values()

filename = 'e:\\agenda.txt'
f = open(filename, "w")

for c in contacts:
 f.write(c.as_vcard())

f.close()

Este programa exporta a un fichero toda la agenda en formato VCard para posteriormente transferirlo a otro dispositivo.

Conectar una aplicación rails a varias bases de datos simultáneamente

2009-07-18T16:54:00.003+02:00

Se puede conectar una aplicación rails a varias bases de datos a la vez, eso sí, hay que tener un especial cuidado con el rendimiento de la aplicación, aunque ActiveRecord nos provee una interfaz transparente a la hora de acceder a los modelos.

Suponiendo como ejemplo que tenemos dos modelos (Post y Comment) y este último está localizado en una base de datos externa, se puede configurar rails de la siguiente forma:

1) Primero, creamos un fichero de configuración para la conexión a la nueva base de datos (config/external_database.yml).


development:
    adapter: mysql
    database: test
    username: root
    password:

production:
    adapter: mysql
    database: test
    username: root
    password:

2) Después, creamos un módulo para encapsular la lectura del fichero y la nueva conexión.


module ExternalDatabase
  def self.included(base)
    config = YAML.load(File.open('config/external_database.yml'))    
    
    if config and ENV['RAILS_ENV']
      base.establish_connection(config[ENV['RAILS_ENV']])
    else
      raise 'External Database not configured'
    end
  end
end

3) Por último, incluimos en los modelos que van a la base de datos externa el módulo que hemos creado.


class Comment < ActiveRecord::Base
  include ExternalDatabase
  
  belongs_to :post
end

Con esto ya podemos utilizar los modelos aunque cada uno esté en una base de datos diferente.


Comment.find(:all, :include => :post)

Diferencias de rendimiento entre eval y send

2009-07-11T15:55:00.002+02:00

La metaprogramación en ruby permite mucha expresividad y flexibilidad, aún así hace caer bastante el rendimiento.

A pesar de eso, lo más importante es evitar en la medida de lo posible eval ya que es bastante más lento.

Al hacer una llamada a send la máquina virtual de ruby tiene que buscar el nombre del método que se le pasa como parámetro y ejecutarlo.

En cambio, al hacer un eval además de lo anterior la máquina virtual necesita parsear la cadena y después ejecutar el código.


Benchmark.bm{|x| x.report{100000.times{eval('Post.scopes')}}}
    user     system      total        real
0.410000   0.000000   0.410000 (  0.410306)

Benchmark.bm{|x| x.report{100000.times{Post.send('scopes')}}}
    user     system      total        real
0.140000   0.000000   0.140000 (  0.144820)

Optimización de consultas en rails

2009-06-26T18:39:00.005+02:00

Cuando en rails se hace una consulta a la base de datos sobre una tabla que contiene mucha información, no todo el tiempo se pierde en la consulta. Una parte importante del tiempo se pierde en la creación de cada objeto ActiveRecord.

Usando directamente el método select_all de la conexión ActiveRecord devolverá un array de hash, ahorrando el tiempo de construcción de objetos.


Benchmark.bm{|x| x.report{100.times{BigTable.find(:all)}}}
    user     system      total        real
10.090000   2.090000  12.180000 ( 19.199150)

Benchmark.bmbm{|x| x.report{100.times{BigTable.connection.select_all('select * from big_table')}}}
    user     system      total        real
7.350000   2.080000   9.430000 ( 16.646406)

En general, no es buena idea guardar todos los elementos de una tabla grande en un array, pero aún seleccionando tan solo el índice se obtiene una mejora sustancial.


Benchmark.bm{|x| x.report{100.times{BigTable.find(:all, :select => :id)}}}
    user     system      total        real
0.610000   0.010000   0.620000 (  0.707702)

Benchmark.bmbm{|x| x.report{100.times{BigTable.connection.select_all('select id from big_table')}}}
    user     system      total        real
0.080000   0.000000   0.080000 (  0.161878)

Crear extensiones de ruby en c

2009-06-20T23:19:00.006+02:00

Crear extensiones en C del lenguaje ruby es bastante sencillo.

En primer lugar hay que crear un fichero para extconf, este nos generará el fichero makefile de forma automática.

En el fichero extconf.rb debería haber algo como:


#!/usr/bin/env ruby

require 'mkmf'
create_makefile("ruby1")

Donde ruby1 es el nombre de la extensión.

En segundo lugar hay que crear la extensión en código C, simplemente hay que incluir la cabecera ruby.h.

La función Init_ruby1 es la que se ejecutará al importar la extensión desde código ruby.


#include "ruby.h"

static VALUE c_printf(VALUE self, VALUE anObject){
 printf("%s\n", STR2CSTR(anObject));
 return Qnil;
}

static VALUE c_init(VALUE self){
  return self;
}


VALUE FromC;

void Init_ruby1() {
 rb_define_global_function("printfc", c_printf, 1);
 FromC = rb_define_class("FromC", rb_cObject);
 rb_define_method(FromC, "initialize", c_init, 0);
 rb_define_method(FromC, "printfc", c_printf, 1);
}

En este ejemplo se define una función global printfc, se define la clase FromC, el método de instancia printfc de esa clase.

Para compilar e instalar este código hay que ejecutar ruby extconf.rb, make y make install.

Ya deberíamos tener disponible la librería ruby1, al ejecutar require 'ruby1' podremos ejecutar las funciones de nuestro código en C.

Hay una gran cantidad de funciones disponibles para crear extensiones en la siguiente dirección: http://www.rubycentral.com/book/ext_ruby.html

Definición de named_scopes dependientes del tiempo actual

2009-06-03T23:42:00.005+02:00

Si tenemos una clase ActiveRecord como la siguiente:


class Post < ActiveRecord::Base
  named_scope :test, :conditions => ['updated_at < ?', Time.now]
end

En modo development funciona sin problemas, sin embargo en modo production la consulta que se genera no es la esperada.

Al arrancar rails en modo production se cachean las clases, al cargar este modelo en concreto se evalúa Time.now haciendo que para todas las consultas se coja como fecha la hora en la que se ha cargado el modelo.

El descrito anteriormente no es el comportamiento que esperaríamos al definir el named_scope, sino que debería obtener la fecha y hora actual para cada consulta, no en la definición.

Revisando la definición de los named_scopes nos encontramos lo siguiente:


      def named_scope(name, options = {}, &block)
        name = name.to_sym
        scopes[name] = lambda do |parent_scope, *args|
          Scope.new(parent_scope, case options
            when Hash
              options
            when Proc
              options.call(*args)
          end, &block)
        end
        (class << self; self end).instance_eval do
          define_method name do |*args|
            scopes[name].call(self, *args)
          end
        end
      end

En nuestro caso pasamos un hash como opciones, por lo que efectivamente se evaluará el Time.now solo en la definición de dicho hash.

Si en lugar de eso definimos un objeto de tipo Proc se evaluará cada vez.

Por lo tanto para arreglar el comportamiento del primer ejemplo deberíamos escribirlo como:


class Post < ActiveRecord::Base
  named_scope :test, lambda{{:conditions => ['updated_at < ?', Time.now]}}
end

Aplicación de consola para twitter

2009-05-10T23:20:00.004+02:00

Acabo de lanzar un proyecto en github para interaccionar con twitter desde consola.

Por ahora incluye la funcionalidad básica: cambio de estado, consulta de estado de amigos, login y mensajería.

La interfaz de comandos es muy similar al clásico IRC.

La url del proyecto es la siguiente: twit

Añadiendo estado a los elementos del DOM

2009-05-01T13:32:00.003+02:00

En aplicaciones complejas con javascript para guardar el estado de cada elemento se suele modificar alguna propiedad del elemento que queramos manipular.

Sin embargo esta práctica es poco adecuada y no demasiado flexible, ya que no podemos guardar tipos de datos complejos.

jQuery ya prevee que podemos necesitar esta funcionalidad y nos proporciona la función data para guardar información de cada elemento.

Por ejemplo:


$('a').data('activated_links', false);
....
var footer_links = $('.footer_links');
if(!footer_links.data('activated_links')){
  footer_links.data('activated_links', true);
  ...
}
...

Combinación de named_scopes en rails

2009-03-28T12:30:00.002+01:00

Cuando hay que realizar un filtrado de resultados en una web con muchas posibles combinaciones podemos acabar con muchas líneas de código para obtener una funcionalidad no demasiado compleja.

En rails, la mayoría de los filtrados se hacen con named_scopes, queda parcialmente resuelto el problema, aún así quedan resolver como aplicar cada combinación de named_scopes según el filtrado que necesite el usuario.

Suponiendo que tenemos un modelo Post como el siguiente:


class Post < ActiveRecord::Base
  named_scope :all
  named_scope :published, :conditions => {:published => true}
  named_scope :from_user, :conditions => {:kind => 'user'}
  named_scope :from_admin, :conditions => {:kind => 'admin'}
end

Podemos resolver el problema de aplicar filtros combinados de la siguiente forma usando inject:


class PostsController < ApplicationController
  def index
    filter = (params[:filter] or String.new)
    filter = filter.split(',').map(&:to_sym).select{|f| Post.scopes.include?(f)}
    filter << :all

    @posts = filter.inject(Post){|model, nscope| model.send(nscope)}
  end
end

En primer lugar obtenemos la lista de named_scopes a aplicar y filtramos los no válidos, en segundo con inject se los aplicamos al modelo.

Con ese código tan simple podemos usar rutas del tipo:

http://server/posts
http://server/posts?filter=published
http://server/posts?filter=published,from_user

Optimización del tiempo de carga de webs

2009-03-01T14:58:00.003+01:00

Dentro del tiempo total desde que se hace una petición a una página web hasta que se termina de dibujar en el navegador, gran parte corresponde a los distintos recursos externos que hay que recuperar: javascript, css e imágenes.

Los ficheros javascript y css tienen una propiedad interesante, si se concatenan varios y se envían en un solo fichero no debe influir en el resultado final.
Sin embargo, si se concatenan, se pueden cargar con una sola petición, con el consiguiente aumento de rendimiento.

El método que rails proporciona para hacer esto de forma automática es el siguiente (solo en modo producción):


<%= javascript_include_tag 'first.js', 'second.js', :cache => '1_2' %>

Sin embargo esto tiene un problema, normalmente en una aplicación según la página se carga unos ficheros u otros, no es muy práctico ir dándole claves a todas las combinaciones.

Se pueden programar dos helpers para dar las claves de forma automática:


<%= cached_javascript_include_tag 'first.js', 'second.js' %>
<%= cached_stylesheet_link_tag 'first.css', 'second.css' %>

Es importante que las versiones cacheadas tanto de css como de javascript no estén en el svn, a la hora de hacer un despliegue se regenerarán usando la nueva versión de los ficheros.

Aún así, si se quiere que se genere de nuevo la versión cacheada para una página sin desplegar la aplicación ni borrar los ficheros antiguos, se puede usar un sistema de versiones.


<%= cached_javascript_include_tag 'first.js?v=1', 'second.js?v=3' %>

El código de los helpers es el siguiente:


module ApplicationHelper
  def cached_javascript_include_tag(*args)
    cached_args!(*args)
    javascript_include_tag(*args)
  end

  def cached_stylesheet_link_tag(*args)
    cached_args!(*args)
    stylesheet_link_tag(*args)
  end

  def cached_args!(*args)
    options = args.extract_options!.stringify_keys

    cache_entry = args.map(&:to_s).sort.join('_').gsub!('?', '_')
    options[:cache] = cache_entry

    args << options
  end
end

Observadores personalizables en rails

2009-01-11T11:43:00.002+01:00

En rails hay unas clases llamadas observadores que sirven para redefinir los métodos que necesitemos en el ciclo de vida de los objetos (after_update, before_create, etc...).

El problema es que en ocasiones con los métodos del ciclo de vida no es suficiente, una situación muy común es redefinir el método after_save, y cada vez que se guarde un objeto comprobar una condición y actuar si es necesario.

Afortunadamente existe un método en ActiveRecord para notificar a los observadores exactamente cuando queramos y de lo que queramos, de la siguiente forma.

En el modelo:


class Post < ActiveRecord::Base
 def just_created
  notify :manage_task
 end
end

En el observador:


class GlobalObserver < ActiveRecord::Observer
 observe Post
 
 def manage_task(object)
  #do something
 end
end

Carga de css dinámica

2009-01-02T18:33:00.002+01:00

Es habitual en webs en las que cada usuario tiene una página personal permitirle cambiar la apariencia mediante temas (skins).

Para cargar un css nuevo de forma dinámica se puede usar la siguiente función javascript o algún variante.


function loadCSS(cssFile){
 var cssLink=document.createElement("link");
 cssLink.setAttribute("rel", "stylesheet");
 cssLink.setAttribute("type", "text/css");
 cssLink.setAttribute("href", cssFile);
 document.getElementsByTagName("head")[0].appendChild(cssLink);
}

Lo que hace esta función es crear un elemento link que apunta a un css y lo inserta en el head de la página.

Crear demonios en ruby

2008-12-28T00:03:00.003+01:00

Para crear un demonio hay que duplicar el proceso actual (hacer un fork) y distinguir a cada una de las instancias para la que instancia hija se encargue del trabajo en background que queremos realizar.

En ruby todo este proceso se puede realizar automáticamente utilizando el módulo ruby daemon de la siguiente forma.


require 'daemons'

class Demonio
 def initialize
  Daemons.daemonize
  loop do
   f = File.new('/tmp/timestamp', 'a')
   f.write("#{Time.now}\n")
   f.close
   sleep(3)
  end
 end
end

Demonio.new

Redefinir el método de comparación con expresiones regulares

2008-12-26T23:44:00.004+01:00

Para mejorar la búsqueda en los datos de los objetos se puede aprovechar que en ruby se puede redefinir el método de comparación con expresiones regulares (=~).

Un ejemplo.


class Persona
 attr_accessor :nombre, :apellidos, :direccion
 
 def initialize(nombre, apellidos, direccion)
  self.nombre = nombre
  self.apellidos = apellidos
  self.direccion = direccion
 end 
 
 def =~(re)
  "#{self.nombre} #{self.apellidos} #{self.direccion}" =~ re
 end
 
 def self.search(ciudad, input)
  query = Regexp.new(input, 'i')
  ciudad.select{|p| p =~ query} 
 end
end



p1 = Persona.new('Jose', 'Gonzalez', 'Sol')
p2 = Persona.new('Francisco', 'Martinez', 'Preciados')
p3 = Persona.new('Fernando', 'Solano', 'Serrano')

Madrid = [p1, p2, p3]

puts Persona.search(Madrid, 'sol').map(&:nombre)

El modificador 'i' del constructor de expresiones regulares hace que no distinga entre mayúsculas y minúsculas.
Concatenando los campos en los que queremos buscar se obtiene un matching más completo.

Con el map final se imprimen los nombres de las personas que hayan coincidido con la búsqueda.

Recuperación automática de procesos erlang

2008-12-14T13:09:00.004+01:00

La mayor ventaja que proporciona erlang es la gran potencia que tiene para la programación de procesos concurrentes.

Cuando se diseña software que va a ser programado en erlang suele dividirse el trabajo en múltiples procesos, además provee de mecanismos para comprobar fácilmente entre procesos si alguno se ha colgado y restaurarlo o ejecutar cualquier otra acción.

En el siguiente ejemplo.


-module(lib_misc).
-export([link_p/1, start/0, loop/0]).

start() -> 
 Pid = spawn(fun loop/0),
 register(divisor, Pid),
 spawn(lib_misc, link_p, [Pid]),
 Pid.

loop() ->
 receive
  {A, B} ->
   io:format("~nDivision: ~p", [A/B]),
   loop()
 end.


link_p(Pid) ->
 process_flag(trap_exit, true),
 link(Pid),
 receive
  {'EXIT', Pid, _} -> 
   NewPid = spawn_link(lib_misc, loop, []),
   register(divisor, NewPid),
   link_p(NewPid)
 end.

Al compilar la librería y arrancarla se ejecutan dos procesos, el principal loop y otro llamado link_p.

El bucle principal simplemente recibe una tupla con dos números y los divide. Tiene al menos un error conocido y es que no comprueba cuando el divisor es cero.

El proceso link_p se enlaza al principal, la tarea de este proceso es esperar a que el principal se cuelgue (por ejemplo, división entre cero).
En el momento en el que el programa principal se ha colgado, recibe el mensaje de salida, restaura el proceso y se enlaza al nuevo.

Hay un detalle más, al iniciar un nuevo proceso el pid del antiguo no nos sirve para mandarle mensajes, así que se registra el átomo divisor para tener siempre una referencia global.

Registrar un nombre global estático no es la mejor solución, ya que no se pueden iniciar múltiples instancias del proceso divisor, debería ser un parámetro, lo he dejado así por que el ejemplo fuera más sencillo.

Funciones anónimas recursivas en Erlang

2008-12-08T11:24:00.002+01:00

En erlang se pueden definir funciones anónimas con la palabra reservada fun, aunque se pueden guardar en una variable para referenciarlas posteriormente.

La sintaxis es la siguiente:

IsZero = fun(0) -> 1; (N) -> 0 end.

Esta función devuelve 1 (verdad) si el parámetro es 0, falso en cualquier otro caso.

El problema es que de esta forma no se pueden definir funciones recursivas, ya que al no estar definida la función dentro de su definición, no podemos referenciarla, para solucionarlo se puede pasar un parámetro extra, que sea la propia función.

Factorial = fun(1, F) -> 1; (N, F) -> N * F(N-1, F) end.

En este último caso habría que llamar a la función como Factorial(número, Factorial), lo que queda poco intuitivo, se puede mejorar creando dos funciones en lugar de una.

Fact = fun(1, F) -> 1; (N, F) -> N * F(N-1, F) end.
Factorial = fun(N) -> Fact(N, Fact) end.

Terminales virtuales en linux

2008-11-30T19:03:00.002+01:00

Regularmente cuando administramos equipos unix necesitamos varios terminales, por ejemplo, en el caso de estar administrando un equipo linux remoto por ssh.

Para poder tener varios terminales podemos loguearnos varias veces y usar cada conexión como un terminal, sin embargo esto está lejos de ser óptimo, una sola conexión es más que suficiente para tener abiertas varios terminales.

El comando screen de linux permite crear terminales virtuales, por lo que este problema lo tendríamos resuelto, su funcionamiento es muy simple.

Ejecutando:

sreen bash, abrimos una instancia nueva de bash en otro terminal.

Ctrl+A ", muestra una lista de los terminales virtuales.

Ctr+A 2, va a la tercera consola virtual (numeradas desde 0).

Ctrl+A Ctrl+A, va a la consola mostrada anteriormente.

Ctrl+A d, deja ejecutando las tareas en background (detach).

Expiration time en fragment caching

2008-11-30T12:49:00.005+01:00

Cuando se usa el sistema de caché de rails se pueden elegir donde guardar los items cacheados, la mejor opción es la mayoría de los casos es memcached, pero no siempre tenemos posibilidad de instalar un demonio en la máquina que da hosting.

Otra posibilidad es guardar los items en el sistema de ficheros, para ello hay que añadir en el environment.rb lo siguiente.


config.cache_store = :file_store, '/path_to_cache'

El problema que tiene usar el sistema de ficheros como soporte para la cache es que no soporta la opción de expiración por tiempo, sin embargo memcached sí que lo hace.

Se puede solucionar añadiendo el siguiente parche al environment.rb


module ActiveSupport
  module Cache
    class FileStore < Store
      def read(name, options = nil)
        super
        timestamp = File.open("#{real_file_path(name)}.timestamp", 'rb') { |f| f.read } rescue nil
        if !timestamp or (timestamp and timestamp.to_i > Time.now.to_i)
          File.open(real_file_path(name), 'rb') { |f| f.read } rescue nil
        else
          nil
        end
      end

      def write(name, value, options = nil)
        super
        ensure_cache_path(File.dirname(real_file_path(name)))
        if options and options[:expires_in] 
          File.open("#{real_file_path(name)}.timestamp", "wb+") { |f| f.write(Time.now.to_i + options[:expires_in].to_i) } 
        end
        File.open(real_file_path(name), "wb+") { |f| f.write(value) }
      rescue => e
        RAILS_DEFAULT_LOGGER.error "Couldn't create cache directory: #{name} (#{e.message})" if RAILS_DEFAULT_LOGGER
      end

      def delete(name, options = nil)
        super
        File.delete("#{real_file_path(name)}.timestamp") rescue  nil 
        File.delete(real_file_path(name)) rescue nil
      end
    end
  end
end

Se puede utilizar al igual que la opción expires_in en memcached.


<% cache 'something', :expires_in => 5.minutes do %>
 Hello, just saying hello from cache
<% end %>

Lo he desarrollado teniendo en cuenta la implementación de rails 2.1.2, y solo soporta fragment caching.

Fragment caching en rails

2008-11-26T22:16:00.003+01:00

Usando memcached y fragment caching se puede acelerar mucho la reconstrucción de las vistas en rails.

Para ello, una vez instalado memcached lo ejecutamos:

memcached -d

Por defecto estará en el puerto 11211.

En el environment.rb hay que configurar la caché para que utilice memcached.


config.cache_store = :mem_cache_store

Tras eso en las vistas podemos hacer lo siguiente:


<% cache 'key', :expires_in => 300 do %>
  texto html...
<% end %>

300 es el número de segundos que este trozo estará vigente en caché, si no se indica nada el fragmento no expirará a no ser que lo indiquemos manualmente con expire_fragment.

key es la clave que tiene el fragmento dentro de la vista, es necesario para distinguir los distintos fragmentos.

Memoization en ruby

2008-11-15T23:37:00.009+01:00

La memoization es una técnica de optimización que consiste en recordar los resultados para anteriores llamadas a una función.

Si para una llamada anterior a una función se han pasado los parámetros x=2 e y=3, la próxima vez se devolverá el mismo resultado al obtenido, sin repetir cálculos.

La implementación es muy sencilla y se pueden obtener mejoras muy significativas en funciones con cálculos pesados, basta con tener una tabla en la que utilicemos los parámetros de entrada como índices y el resultado de la función como valor.

Si ya de por sí es sencillo implementar la memoization en ruby se puede usar también la gema que hay específica para ello, esta gema implementa la memoization automática, por lo que ni siquiera es necesario mantener una tabla para los valores, la gema se encarga de ello.

Es necesario recordar que en la memoization solo se tienen en cuenta los parámetros de entrada, por lo que a las funciones que produzcan resultados a partir de otras entradas (ficheros, hora actual...) no se les debe aplicar esta técnica.

En el siguiente ejemplo se implementa la función de fibonacci recursiva (fib1), la misma función aplicándole la memoization (fib2) y por último la memoization automática a fib1. En mi máquina para este ejemplo se obtienen ganancias de 30 a 40 veces en las versiones memoizadas.


require 'rubygems'
require 'memoize'

include Memoize

def fib1(n)
 return n if n < 2
 return fib1(n-1) + fib1(n-2)
end


@mm = {}
def fib2(n)
 return @mm[n] if @mm[n]
 return n if n < 2
 
 @mm[n] = fib2(n-1) + fib2(n-2)
 return @mm[n]
end

puts fib1(30)
puts fib2(30)

memoize(:fib1)
puts fib1(30)

Ocultar parámetros del log de rails

2008-11-09T15:28:00.002+01:00

Al igual que se suelen encriptar las contraseñas al guardarlas en las bases de datos de las aplicaciones con autentificación, también se deberían omitir este tipo de campos en el log de rails.

Cuando se despliega rails en un entorno en producción normalmente guarda el log de todas las peticiones en log/production.log, ahí se pueden ver todos los parámetros que se pasan a la aplicación, incluyendo contraseñas, números de tarjetas de crédito, etc.

Hay una forma de hacer que determinados parámetros no aparezcan, llamando a filter_parameter_logging en el controlador.

class AccountsController < ApplicationController
  filter_parameter_logging :card_number

  def index
    @accounts = Account.find(:all)
  end
end

En el log aparecerá algo así.

Parameters: {"card_number"=>"[FILTERED]"...

Generacion dinámica de métodos en ruby

2008-11-02T21:56:00.002+01:00

Una característica que puede añadir mucha potencia a los módulos que creamos en ruby es la generación automática de métodos.

Se usa intensivamente en rails, tanto en la implementación de ActiveRecord como de la mayoría de plugins.

Para definir métodos de forma dinámica tan solo hay que redefinir method_missing, este método se llama cada vez que se llama a una función no definida, recibe como primer parámetro el nombre del método y como segundo parámetro la lista de argumentos.

Dejo un ejemplo.

#!/usr/bin/ruby

def method_missing(method, *args)
 if method.to_s =~ /saludo_(\w+)/
  generar_saludo($1)
 else
  super(method, *args)
 end
end

def generar_saludo(msg)
 puts "hola #{msg}"
end


saludo_mundo

Crear clases dinámicas en ruby

2008-11-01T21:58:00.002+01:00

La sintaxis de ruby para crear clases u objetos es muy sencilla, pero lo es más aún para definirlos dinámicamente.

Para ello disponemos de la clase Struct, veamos un ejemplo en el siguiente código.

Clase = Struct.new :campo1, :campo2
objeto = Clase.new('valor1', 'valor2')
puts objeto.campo1
puts objeto.campo2
puts objeto.members
puts objeto.values

En la primera línea con Struct se crea la clase Clase con dos campos, esos campos ya están disponibles en los objetos que creemos a partir de la clase. Adicionalmente, Struct añade algunos métodos como members y values para inspeccionar el contenido de los objetos creados.

Metaprogramación en php

2008-10-26T22:05:00.002+01:00

En php5 han entrado nuevas posibilidades en lo que a metaprogramación se refiere, revisando el siguiente trozo de código nos encontramos un ejemplo de que construcciones se pueden realizar.

<?php

function saludo(){
        return "hello";
}

$cadena = "saludo";
$cadena_funcion = "cadena";
?>

<?= $cadena() ?>

<br/>

<?= $$cadena_funcion() ?>

Primero podemos ver que si guardamos en una cadena el nombre de una función, y luego llamamos a la cadena con una lista de parámetros (en este caso vacía), se invoca dicha función. Esto puede ser bastante útil para elegir que acción ejecutar ante una entrada por parámetro.

En segundo lugar se muestra como utilizar las variables con doble '$', es decir, las variables de variables. Por cada '$' delante del nombre de la variable se hace una evaluación de la variable.

$cadena_funcion contiene la cadena "cadena", si por el contrario se referencia a $$cadena_funcion, se evaluará la variable $cadena.

Programación funcional con javascript

2008-10-21T21:00:00.002+02:00

En programación funcional se usa las funciones map, filter y reduce para manipular colecciones.

En javascript se pueden implementar fácilmente de la siguiente manera.

function map(f, a){
 var r=new Array();
 for(var i=0;i<a.length;i++){
  r.push(f(a[i]));
 }
 return r;
}

function filter(f, a){
 var r=new Array();
 for(var i=0;i<a.length;i++){
  if(f(a[i])){
   r.push(a[i])
  }
 }
 return r;
}

function reduce(f, a){
 if(a.length<1){
  return a
 }
 else{
  var r=a[0].__proto__;
  for(var i=0;i<a.length;i++){
   r=f(r, a[i])
  }
  return r;
 }
}

Implementación de un memory pool

2008-10-19T13:21:00.002+02:00

En aplicaciones en las que se reserva y libera memoria con mucha frecuencia se puede sufrir fragmentación de memoria. Cuando el rendimiento no es demasiado importante este comportamiento puede ser aceptable, en cambio, si esto se produce en una aplicación de tiempo real es necesario solucionarlo.

Para evitar la fragmentación de memoria existe una técnica llamada memory pool, básicamente consiste en crear un espacio fijo de memoria para que la aplicación lo administe.

En el siguiente ejemplo se crea un pool para un conjunto de threads que lo comparten.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

#define BUF_SIZE 128
#define POOL_SIZE 36
#define NUM_THREADS 10

typedef struct dataStruct{
 int id;
 char cadena[BUF_SIZE];
} data;


pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

data **dataPool;
int next_data = 0;

int get_next_memory_position(){
 pthread_mutex_lock(&mutex); 
 next_data = (next_data + 1) % POOL_SIZE;
 pthread_mutex_unlock(&mutex);
 return next_data;
}

data **allocate_pool(){
 int i; 
 data **d = (data**) malloc(sizeof(data*) * POOL_SIZE);
 
 for(i = 0;i < POOL_SIZE; i++){
  d[i] = malloc(sizeof(data));
 }
 
 return d;
}

void *thread(){
 data *param = dataPool[get_next_memory_position()];
 
 param->id = next_data;
 strcpy(param->cadena, "hello");
 
 printf("%d: %s \n", param->id, param->cadena);
}

int main(){
 pthread_t t[NUM_THREADS];
 dataPool = allocate_pool();
 int i;
 
 for(i = 0;i < NUM_THREADS; i++){
  pthread_create(&t[i], NULL, thread, NULL);
 }

 for(i = 0;i < NUM_THREADS; i++){
  pthread_join(t[i], NULL);
 }
}

En este ejemplo se asigna automáticamente memoria a los threads conforme la piden circularmente, este planteamiento no vale siempre, para cambiar la política de asignación de bloques libres solo hay que cambiar el método get_next_memory_position.

Simulando enlaces con javascript

2008-10-18T20:27:00.003+02:00

En algunas ocasiones necesitamos poner un enlace en un elemento del DOM de una web que no acepta la propiedad href.

Normalmente ocurre cuando se quiere añadir un hipervínculo que no estaba previsto al realizar la maquetación.

Para esos casos se puede simular el comportamiento de un enlace mediante javascript.

Supongamos que el div con id 'texto' es el que queremos que tenga un enlace a otra página, con el evento onclick y cambiando el document.location podemos irnos a la página que queremos al pinchar en el elemento.

El problema es que al pasar por encima el ratón nada nos indica que es un enlace, con el evento onmouseover y cambiando la propiedad css cursor podemos hacer que parezca un enlace.

Un ejemplo de como quedaría.

<html><body>

  <div id="texto" onclick="document.location='http://google.com'" onmouseover="this.style.cursor='pointer'">lorem ipsum</div>

</body></html>

Transacciones en rails

2008-10-12T16:22:00.003+02:00

En esta entrada expliqué como usar las transacciones a nivel de base de datos (MySQL), ahora lo haré a nivel de aplicación con rails.

Si usamos MySQL debemos recordar que por ahora el único motor que soporta transacciones es InnoDB.

Los objetos que heredan de ActiveRecord tienen un método transaction que acepta un bloque, las operaciones que se ejecuten dentro se realizarán indivisiblemente.

Imaginemos que tenemos un modelo llamado Post, con los campos title y content, el campo title no puede ser nulo.

Si hacemos esto.

Post.transaction do
    Post.create(:title => 'en la transaccion', :content => 'texto')
    Post.create(:content => 'texto')
end

Como la segunda operación no es válida (el campo title es nulo) ninguna de las operaciones se reflejará en base de datos, por el contrario, si le asignamos un title a la segunda operación se ejecutarán normalmente y tendremos dos entradas nuevas en la tabla de posts.

Ejecutar comandos linux sobre múltiples ficheros

2008-10-11T23:25:00.002+02:00

Para ejecutar comandos masivamente sobre una lista de ficheros en linux se pueden combinar los comandos find y xargs.

find es bastante conocido, básicamente lo que hace es buscar archivos según los criterios que le indiquemos.

xargs coge una lista y ejecuta el comando que le pasemos a cada elmento de esa lista.

La sintaxis es la siguiente.

find . -name "*.txt" | xargs echo

Con eso listaríamos los ficheros con extensión txt.

find . -name "*.php" | xargs -I fichero cat fichero >> acumulado.php

El parámetro -I hace que podamos darle un nombre a la entrada del comando que queremos ejecutar para realizar operaciones más complejas.

find . -name "*.cpp" | xargs -t -I fichero mv fichero fichero.old

Al realizar operaciones masivas con ficheros es posible que cometamos algún error, para comprobarlo se puede utilizar el parámetro -t que hace que se indiquen en la salida todos y cada uno de los comandos que xargs ejecuta.

Búsquedas fulltext en mysql

2008-10-06T23:25:00.002+02:00

Las búsqueda fulltext son un tipo de búsqueda especial para los campos de texto, en MySQL solo está disponible para el motor MyISAM. Incluso los resultados se ordenan por relevancia.

Se pueden indexar en modo fulltext los campos de tipo char, varchar y text.

Para crear un índice fulltext la sintaxis es la siguiente.

alter table tabla add fulltext(campo);

Se pueden combinar varios campos para el índice.

alter table tabla add fulltext(campo1,campo2);

La sintaxis para las consultas fulltext.

select * from tabla where match(campo) against('contenido');

Hay que tener en cuenta ciertas condiciones al realizar búsquedas, las más importantes:

1) Si la consulta aparece en la mitad de los registros se toma como 'común', se ignoran los resultados
2) Se ignoran palabras demasiado cortas

Si no nos viene bien la regla 1), podemos hacer las búsquedas en 'modo booleano' aunque en este caso los resultados no se ordenan por relevancia.

select * from tabla where match(campo) against('contenido' in boolean mode);

En 'modo booleano' se pueden aplicar también modificadores, por ejemplo, si queremos las tuplas con contenido 'texto' y sin 'basura'.

select * from tabla where match(campo) against('+texto -basura' in boolean mode);

También se puede utilizar el wildcard '*'.

select * from tabla where match(campo) against('text*' in boolean mode);

Transacciones en MySQL

2008-09-29T22:50:00.003+02:00

Las operaciones de escritura en MySQL (inserciones, actualizaciones y borrados) se realizan por defecto en modo autocommit, es decir, se actualizan automáticamente en la base de datos.

Este comportamiento es bueno para la mayoría de aplicaciones ya que los cambios se propagan muy rápido, sin embargo no son todo ventajas.

Si queremos realizar una operación compleja en la que actualizamos varios campos o tablas y falla alguna de las operaciones, la base de datos puede quedar en un estado inconsistente o no deseado.

En este caso resultaría útil poder deshacer los cambios, decirle de alguna forma que todas esas operaciones van 'unidas', o se ejecutan todas, o ninguna.

Existe una forma de hacer lo anterior, crear una transacción, los cambios se guardarán en la base de datos si todo ha ido bien, si no, volveremos al estado anterior.

MySQL soporta transacciones, pero no con todos los motores, MyISAM por ejemplo no lo soporta, InnoDB sí.

Un ejemplo de como funcionan las transacciones.


mysql> create table tabla (name char(20), unique(name)) engine = InnoDB;
Query OK, 0 rows affected (0.01 sec)

mysql> insert into tabla set name = 'primero';
Query OK, 1 row affected (0.01 sec)

mysql> insert into tabla set name = 'segundo';
Query OK, 1 row affected (0.01 sec)

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)

mysql> insert into tabla set name = 'tercero';
Query OK, 1 row affected (0.00 sec)

mysql> select * from tabla;
+---------+
| name    |
+---------+
| primero | 
| segundo | 
| tercero | 
+---------+
3 rows in set (0.00 sec)

mysql> insert into tabla set name = 'segundo';
ERROR 1062 (23000): Duplicate entry 'segundo' for key 1
mysql> rollback;
Query OK, 0 rows affected (0.01 sec)

mysql> select * from tabla;
+---------+
| name    |
+---------+
| primero | 
| segundo | 
+---------+
2 rows in set (0.00 sec)

Como se puede ver al hacer rollback volvemos al estado anterior de la base de datos, si hubiésemos querido guardar los cambios tendríamos que haber ejecutado commit.

Durante la transacción los resultados que se muestran están en memoria, pero no físicamente guardados en la base de datos, si abrimos otra sesión de mysql esos cambios no los veremos hasta que se realice un commit.

Lector RSS en ruby

2008-09-28T23:02:00.002+02:00

Para crear un lector RSS tan solo es necesario crear una conexión http hasta el sitio que queramos suscribirnos y después parsear el archivo xml que nos devuelve el servidor.

En ruby se puede hacer todo esto en unas pocas líneas.

#!/usr/bin/ruby
require 'net/http'
require 'rexml/document'

http = Net::HTTP.new 'servidor.com'
http.start

response = http.get('/path_to_rss')
xml = REXML::Document.new(response.body)
xml.each_element('rss/channel/item') do |elem|
 puts elem.elements['title'].text
 puts elem.elements['link'].text 
 puts "----------------"
end

Capturar y redirigir tráfico con netcat

2008-09-25T23:57:00.002+02:00

Cuando estamos comprobando el estado de la red o depurando el funcionamiento de un protocolo viene muy bien el comando netcat.

Una redirección de un puerto a otro con netcat se hace de la siguiente forma.

nc -l -p 5000 | nc localhost 5001

De esa forma se reenvía lo que llegue al puerto 5000 hasta el 5001.

Si agregamos el parámetro -o además podemos registrar el tráfico saliente.

nc -l -p 5000 -o log.txt | nc localhost 5001

La respuesta saldrá por consola, si tenemos una aplicación que se conecta a un host remoto y queremos saber que envía y que recibe de ese host lo podemos hacer de la siguiente forma.

iptables -t nat -A OUTPUT -p tcp -d host_remoto -j DNAT --to-destination 127.0.0.1:5000

nc -l -p 5000 -o log.txt | nc host_remoto puerto_remoto

Con esto redirigiremos todo el tráfico saliente a host_remoto a nuestro puerto 5000, guardaremos la petición en log.txt y volveremos a enviarlo a host_remoto, la respuesta a la petición nos aparecerá por consola.

Guardar datos comprimidos en base de datos con rails

2008-09-21T11:26:00.002+02:00

En ciertas ocasiones es posible que queramos tratar los datos que vienen de una aplicación rails antes de guardarlos en base de datos. Para ello podemos sobrecargar los métodos nombre_parametro y nombre_parametro= en el modelo correspondiente.

Si, por ejemplo, tenemos un campo de la base de datos que preveemos que ocupe mucho espacio y no va a leerse frecuentemente se puede comprimir de la siguiente forma.

class Post < ActiveRecord::Base

  def text
 Zlib::Inflate.inflate(read_attribute(:text))
  end

  def text=(new_text)
 old_text=read_attribute(:text)
 new_compress_text=Zlib::Deflate.deflate(new_text)
 write_attribute(:text, new_compress_text) if old_text!=new_compress_text
  end
end

Para comprimir/descomprimir los datos se usa la librería zlib así que es necesario hacer require 'zlib'.

Además es necesario que el campo de la base de datos esté marcado como binario.

Decoradores en python

2008-09-20T21:31:00.003+02:00

Para entender fácilmente los que son los decoradores en python podemos pensar que son una especie de filtros que se ejecutan antes de la llamada a una función.

Realmente un decorador se ejecuta antes de la función decorada (realizando cualquier tipo de acción) y devuelve la función a ejecutar (posiblemente la función decorada). Es más fácil de entender con un ejemplo.

#!/usr/bin/python

def filtro(f):
 def permiso_denegado(*args):
  print '%s no tiene permisos para realizar esa accion' % args[0]
  
 def comprobacion(*args):
  if args[0] == 'admin':
   return f(*args)
  else:
   return permiso_denegado(*args)
  
 return comprobacion
  

@filtro
def accion(usuario):
 print 'Accion realizada por %s' % usuario
 
accion('guest')

En este caso se intenta realizar una acción pero si el usuario pasado como parámetro no es 'admin' no puede realizarla, en lugar de devolver una referencia a la función original, se devuelve la función de permiso denegado, filtro es el decorador.

También existe la posibilidad de combinar decoradores, lo importante es tener en cuenta cuando se programa un decorador que no tiene porqué ser el único (cuidado lo que se hace con los parámetros) y el orden, en el ejemplo debug(filtro(debug(accion))).

#!/usr/bin/python

_MODO_DEBUG = True

def debug(f):
 if _MODO_DEBUG:
  print 'Se ejecuta la funcion: %s' % f.__name__
 return f

def filtro(f):
 def permiso_denegado(*args):
  print '%s no tiene permisos para realizar esa accion' % args[0]
  
 def comprobacion(*args):
  if args[0] == 'admin':
   return f(*args)
  else:
   return permiso_denegado(*args)
  
 return comprobacion
  
@debug
@filtro
@debug
def accion(usuario):
 print 'Accion realizada por %s' % usuario
 
accion('guest')

Medir el rendimiento de una aplicación web

2008-09-20T00:36:00.002+02:00

Es importante medir el rendimiento de todas las aplicaciones que creamos, en el caso de las aplicaciones web podemos usar una herramienta de hp llamada httperf.

Para ejecutarlo de la forma más sencilla se puede hacer.

httperf --server servidor_web --port puerto --num-conns numero_conexiones

servidor_web y puerto apuntan a la aplicación web que queramos probar y numero_conexiones es el número de intentos totales, entre 200 y 1000 suelen dar unos buenos resultados sin tests demasiado largos.

Si queremos probar alguna página que no sea el index se puede hacer incluyendo el parámetro --uri direccion.

Si la página que queremos probar necesita de registro también se puede solucionar con esta herramienta, primero necesitamos loguearnos con el navegador, observar la cookie que se nos ha creado y entonces añadir el parámetro --add-header='Cookie: nombre=valor', donde nombre y valor son los que hemos obtenido de la cookie del navegador.

Seleccionar parte de una imagen con javascript

2008-09-17T22:37:00.003+02:00

En las redes sociales que permite etiquetar imágenes se suele elegir una sección de la imagen que representa la parte ocupada por cada usuario.

El problema es que a la mayoría (facebook, tuenti...) solo nos dejan seleccionar una sección cuadrada fija y muchas veces no se corresponde con lo que queremos.

Con jQuery y Jcrop podemos realizar selecciones más precisas de la siguiente manera.

<html>
 <head>
  <script src="jquery.pack.js"></script>
  <script src="jquery.Jcrop.pack.js"></script>
  <link rel="stylesheet" href="/css/jquery.Jcrop.css" type="text/css" />

  <script language="Javascript">
   jQuery(function(){ jQuery('#cropbox').Jcrop(); });
   jQuery('#cropbox').Jcrop({
    aspectRatio: 1,
    onSelect: updateCoords
   });
   function updateCoords(c){
    jQuery('#x').val(c.x);
    jQuery('#y').val(c.y);
    jQuery('#w').val(c.w);
    jQuery('#h').val(c.h);
   };
  </script>
 </head>

 <body>
  <img src="flowers.jpg" id="cropbox" />
 </body>
</html>

En c.x y c.y tendremos las coordenadas dónde comienza la selección y en c.w y c.h el ancho y el alto.

Una vez que sabemos exactamente la selección del usuario se puede recortar la imagen o etiquetar cada zona.

Implementación caché para minimizar cálculos

2008-09-14T00:27:00.002+02:00

Una de las reglas de optimización más importantes es la de no repetir cálculos innecesariamente.

Guardando resultados intermedios y reutilizándolos cuando sea posible se mejora el rendimiento espectacularmente, en el ejemplo se consigue una ganancia casi lineal.

La clase NoCache sería la forma tradicional de implementar esta clase, a continuación la clase Cache optimizada para lecturas sucesivas sin repetir el cálculo si no es necesario.

#!/usr/bin/python

class NoCache:
 def __init__(self):
  self.lista = range(1,900000)
 
 def getLista(self):
  return self.lista
  
 def setLista(self,value):
  lista.append(self.value)
 
 def getMedia(self):
  return reduce((lambda n,m:n+m),self.lista) / len(self.lista)
 

class Cache:
 def __init__(self):
  self.lista = range(1,900000)
  self.__actualizado = False
 
 def getLista(self):
  return self.lista
  
 def setLista(self,value):
  self.__actualizado = False
  lista.append(self.value)
 
 def getMedia(self):
  if self.__actualizado:
   return self.__sumaCache
  else:
   self.__sumaCache = reduce((lambda n,m:n+m),self.lista) / len(self.lista)
   self.__actualizado = True
   return self.__sumaCache
 

n = NoCache()
for i in range(5):
 print n.getMedia()
 
 
c = Cache()
for i in range(5):
 print c.getMedia()

El mismo ejemplo en ruby.

#!/usr/bin/ruby

class NoCache
 def initialize
  @lista = Array.new(900000){|i| i+1}
 end

 def getLista
  return @lista
 end
 
 def setLista(value)
  @lista << value
 end
 
 def getMedia
  @lista.inject{|sum, n| sum+n} / @lista.size
 end 
end

class Cache
 def initialize
  @lista = Array.new(900000){|i| i+1}
  @actualizado = false
 end

 def getLista
  return @lista
 end
 
 def setLista(value)
  @actualizado = false
  @lista << value
 end
 
 def getMedia
  if @actualizado
   @sumaCache
  else
   @sumaCache = @lista.inject{|sum, n| sum+n} / @lista.size
   @actualizado = true
   @sumaCache
  end
 end 
end
 
n = NoCache.new
5.times{puts n.getMedia}

c = Cache.new
5.times{puts c.getMedia}

Otro resultado inesperado en este ejemplo es la gran diferencia de velocidad entre estos dos lenguajes.

En python en mi máquina este ejemplo tarda en ejecutarse 7 segundos, en ruby 1 minuto y 28 segundos. Para este ejemplo python es ¡12 veces más rápido que ruby!.

Variables de solo lectura en python

2008-09-13T15:49:00.003+02:00

Hay algunos tipos de variables, como pueden ser variables de estado, que no interesa que se modifiquen desde fuera de los métodos de una clase, aunque sí que se pueda leer su valor.

Al intentar modificar el valor de una variable de un objeto se llama a la función __setattr__, si sobrescribimos esta función se puede variar el comportamiendo habitual. Lo mismo podemos hacer con __delattr__.

Así se podría mantener una distinción en una clase entre variables de solo lectura y lectura/escritura.

#!/usr/bin/python

class Clase:
 __onlyReadVars=['x', 'y']

 def __init__(self):
  self.__dict__['x'] = 8
  self.__dict__['y'] = 1
  self.a = 2
 
 def __setattr__(self, nombre, valor):
  if nombre in self.__onlyReadVars:
   raise Exception('No se puede sobrescribir %s' % nombre)
  else:
   self.__dict__[nombre] = valor

 def __delattr__(self, nombre):
  if nombre in self.__onlyReadVars:
   raise Exception('No se puede eliminar %s' % nombre)
  else:
   del self.__dict__[nombre]

De esta forma si intentamos eliminar o sobrescribir alguna de las variables de solo lectura se lanzará una excepción.

Aun así, hay una manera de saltarse el filtro si hacemos lo siguiente.

c = Clase()
c.__dict__['x'] = 30

__dict__ es un diccionario con todas las variables del objeto y sus valores, al modificarlo no se llama a la función __setattr__, __getattr__ ni __delattr__.

Trucos para bash

2008-09-11T23:07:00.003+02:00

Hay ciertas situaciones al trabajar en consola que se hacen un poco pesadas y se pueden evitar con algunas combinaciones de teclas disponibles en bash.

Cuando necesitamos ir a un directorio y volver al que estábamos anteriormente se puede ejecutar.

cd -

Para ver todas las variables definidas en la shel simplemente escribiendo $ y pulsando dos veces al tabulador deberían aparecer.

Cuando ejecutamos un comando muy largo repetidas veces se puede hacer una búsqueda incremental en el historial pulsando Ctrl+R.

Una de las cosas más molestas de trabajar con consola es editar comandos muy largos, se puede hacer fácilmente con estos atajos de teclado.

Ctrl+A: pone el cursor al principio de la línea
Ctrl+E: pone el cursor al final de la línea
Ctrl+K: borra desde el cursor hasta el final de la línea
Ctrl+U: borra desde el principio hasta el cursor
Ctrl+Y: pega el texto que cortaste con Ctrl+K o Ctrl+U

Medir el tiempo de cada funcion en python

2008-09-09T23:19:00.002+02:00

Cuando vamos a optimizar código lo primero en lo que pensamos es en medir el tiempo que tarda cada función de nuestro programa para ver donde se puede mejorar más (Ley de Amdahl).

En python el módulo timeit nos facilita mucho esta tarea, se puede usar de la siguiente manera.

import timeit
t = timeit.Timer("funcion()", "from __main__ import funcion")
t.timeit()

t.timeit() ejecuta múltiples veces la función y devuelve el tiempo transcurrido, si se le pasa un parámetro ejecutará la función ese número de veces.

También se puede ejecutar varias veces el test anterior para asegurarnos que no influye ningún otro proceso en la medida del tiempo, para ello se puede ejecutar t.repeat(numero_de_veces) y devolverá un array con los tiempos transcurridos.

MapReduce

2008-09-07T23:29:00.002+02:00

MapReduce es una técnica popularizada por Google (aquí el documento original) para el tratamiento de grandes cantidades de información en un tiempo razonable.

El nombre proviene de las funciones propias de la programación funcional map y reduce.

En python estas dos funciones se pueden combinar de la siguiente forma para contar el número de números impares de una lista:

reduce(lambda n,m: n+m, map(lambda n: n%2, [1,2,3,4,5,6,7,8,9]))

Primero, map aplica la función n%2 a toda la lista original y cambiandola de dominio (de números naturales a [0,1]), después reduce suma la nueva lista obteniendo el número de elementos impares.

¿Qué ventaja tiene esta manera de hacerlo el recuento a la tradicional?
Lo primero que se nos hubiera ocurrido tradicionalmente sería recorrer la lista en aumentando un contador si un número es impar.
Con MapReduce hacemos un procedimiento intermedio (cambiar la lista de dominio) pero a cambio es un diseño muy sencillo de paralelizar.

Por definición map aplica una función a cada elemento de una lista, implicitamente no hay relación entre cada cálculo realizado por map, así que cada operación la puede realizar un nodo.

Tras eso se necesita almacenar todos los resultados en un nodo central para obtener el resultado final, mayor eficiencia obtendremos en este algoritmo cuanto más porcentaje del cálculo lo hagamos mediante map y menos mediante reduce.

Crear un disco virtual usando la memoria RAM

2008-09-07T12:51:00.002+02:00

En muchas ocasiones se trabaja intensivamente con un conjunto no demasiado grande de ficheros, se puede acelerar mucho el acceso a estos ficheros si se almacenan en la memoria RAM.

Para ello, en linux se puede crear un nuevo punto de montaje que acceda a la RAM, tan solo es necesario hacer lo siguiente.

mkdir /mnt/ramdisk
mount tmpfs /mnt/ramdisk -t tmpfs

Ya podemos trabajar en el directorio ramdisk, eso sí, la memoria RAM es volátil, si queremos guardar los cambios antes de apagar el pc es necesario copiarlo a cualquier otro directorio del disco duro.

Leer los parámetros de la lista de comandos en python

2008-09-06T13:41:00.003+02:00

La mayoría de programas que se usan mediante la línea de comandos aceptan parámetros y eso es lo que le da a estos programas mayor flexibilidad que a los que se usan mediante interfaz gráfica.

Para leer los parámetros de un programa en python nos puede servir la librería optparse.

Tiene bastantes opciones e incluso genera la ayuda de forma automática al llamar al programa con -h.
Un ejemplo de como se utiliza.

#!/usr/bin/python

from optparse import OptionParser

parser=OptionParser()
parser.add_option("-a", "--all", dest="todos", action="store_true", default=False,
 help="afecta a todos los elementos")
parser.add_option("-f", action="store_false", dest="todos", 
 help="affecta solo al primer elemento")
parser.add_option("--without-output", action="store_false", dest="output", default=True,
 help="sin mostrar salida")
parser.add_option("-i", "--insert", action="store", dest="newValue",
 help="inserta un elemento al final de la lista")

(options, args)=parser.parse_args()

lista=[1,2,3,4,5,6,7,8,9];
nuevaLista=lista

if options.todos:
 nuevaLista=map(lambda n: n*2, lista)
else:
 nuevaLista[0]=lista[0]*2

if options.newValue:
 nuevaLista.append(int(options.newValue))

if options.output:
 print nuevaLista

Se pueden combinar parámetros, agrupar, hacerlos excluyentes... casi todo lo que se ocurra, si necesitas algo más específico mira en el enlace anterior.

Convertir fichero .nrg a .iso

2008-08-31T11:25:00.002+02:00

Para convertir un fichero .nrg al formato .iso en linux sin necesidad de ningún programa adicional tan solo hay que ejecutar el siguiente comando.

dd bs=1k if=imagen.nrg of=imagen.iso skip=300

La explicación, con este comando lo que hacemos es copiar el fichero quitando los primeros 300kB (skip indica el número de bloques que no queremos copiar y bs es el block size).

En realidad un fichero .nrg y uno .iso se diferencian simplemente en eso, nero añade esa cabecera con información propia.

Hay un programa que hace esta misma conversión en linux, nrg2iso.
Este programa está hecho en c, la conversión la realiza de esta manera.

fseek (nrgFile, 307200, SEEK_SET);

El resto del programa es básicamente una copia de ficheros, al igual que hace el comando dd, en este caso salta 307200 bytes, que en realidad corresponde a los 300kB mencionados arriba (300*1024).

Ficheros abiertos por un proceso

2008-08-30T19:15:00.002+02:00

Para localizar los procesos que están usando un fichero en linux tenemos el comando fuser. En concreto ejecutando lo siguiente.

fuser -va fichero (fichero también puede ser un directorio).

fuser -km fichero (mata todos los procesos que acceden al fichero).

Una funcionalidad similar se puede obtener con lsof, además lsof también permite ver los sockets abiertos.

lsof fichero

Ejecutando simplemente lsof se muestran todos los fichero abiertos así que podemos filtrar mejor con grep.

lsof | grep fichero
lsof | grep UDP (sockets udp abiertos).

Hacer copia de seguridad del MBR

2008-08-27T23:19:00.002+02:00

Si instalamos y reinstalamos frecuentemente distintos sistemas operativos en el mismo disco duro es frecuente perder el MBR (Master Boot Record).

Cuando ya tenemos un MBR que nos sirve y no lo queremos perder en ninguna reinstalación podemos hacer una copia de seguridad, para ello hay que ejecutar el siguiente comando.

dd if=/dev/sda of=/mbr.bak bs=512 count=1

Donde /dev/sda es el disco duro y /mbr.bak la copia de seguridad, para reestablecer la copia de seguridad tan solo hay que hacer.

dd if=/mbr.bak of=/dev/sda bs=512 count=1

El problema al hacerlo así es que también estamos sobreescribiendo la tabla de particiones, para no afectar a la tabla de particiones sobreescribiendo el gestor de arranque hay que escribir solo los primeros 446 bytes.

dd if=/dev/sda of=/mbr.bak bs=446 count=1
dd if=/mbr.bak of=/dev/sda bs=446 count=1

Matar procesos selectivamente en linux

2008-08-26T22:03:00.002+02:00

Para terminar (matar) procesos en linux se suele usar la orden kill pid o killall programa pero hay otra forma de hacerlo más potente.

El comando en cuestión es pkill, dejo una guía rápida de las opciones que permite, siempre se pueden combinar varias.

pkill -u usuario mata todos los procesos de un usuario.

pkill patron mata todos los procesos en los que el patrón esté incluído en el nombre.

pkill -n patron mata al proceso más nuevo de los que coinciden con el patrón.

pkill -o patron mata al proceso más antiguo de los que coinciden con el patrón.

pkill -x patron mata los procesos en los que el nombre coincide exactamente con el patrón.

pkill -v -u usuario mata todos los procesos que no son del usuario (-v invierte el efecto de la acción).

Hay algunas opciones más, para verlas todas man pkill.

Número de argumentos variables en C

2008-08-24T22:40:00.002+02:00

Para crear un método que acepte un número de argumentos variables en C hay que incluir la cabecera stdarg, una vez incluída podremos acceder a las macros va_start, va_arg y va_end.

va_start acepta como parámetro el último parámetro antes de la lista variable.
va_arg necesita el tipo del parámetro que hay que devolver.
va_end libera los recursos usados para la lectura de parámetros.

#include <stdio.h>
#include <stdarg.h>

int sumatorio(int howmany, ...){ 
 int i;
 int total = 0;
 va_list ap;

 va_start(ap, howmany);
 
 for (i=0; i<howmany; i++)
  total+=va_arg(ap, int);
 
 va_end(ap);

 return total;
}

int main(){
 printf("%d\n", sumatorio(4, 1,2,3,4));
}

Comprobaciones numéricas en C

2008-08-24T01:04:00.002+02:00

Es conocido que C es un lenguaje muy potente pero a muy bajo nivel, esto tiene algunas consecuencias al trabajar con valores numéricos que con otros lenguajes ni nos plantearíamos.

En primer lugar, ¿qué devuelven las funciones matemáticas en caso de que no exista un resultado a su operación?

Hay algunas funciones matemáticas como la raíz cuadrada y el logaritmo que no siempre tienen solución, en estos casos se devuelve nan (Not A Number) y se puede comprobar con la función isnan.

Otra situación posible es llegar a un valor infinito, ¿qué ocurre entonces? pues se devuelve inf y se puede comprobar con isinf.

Aquí un ejemplo de como se puede llegar a estas situaciones, para compilar gcc prog.c -o prog -lm.

#include <stdio.h>
#include <math.h>

int main(){
 float dividendo=999999999;
 float divisor=0.000000000000000000000000000000001;
 float num=dividendo/divisor;

 if(isinf(num)) printf("Infinito\n");
 printf("%f\n",num);

 num=sqrt(-num);
 if(isnan(num)) printf("Not a number\n");

 printf("%f\n",num);
}

Threads en ruby

2008-08-22T22:27:00.002+02:00

El manejo de threads en ruby es muy sencillo, la creación de threads se basa en pasar un bloque a la creación de un objeto de la clase thread.

#!/usr/bin/ruby

t1 = Thread.new do
 10.times do
  puts "hello from thread 1"
  sleep(0.2)
 end
end

t2 = Thread.new do 
 10.times do
  puts "hello from thread 2"
  sleep(0.2)
 end
end

t1.join
t2.join

Para pasar parámetros se hace de la siguiente forma.

#!/usr/bin/ruby

t1 = Thread.new(1) do |id|
 10.times do
  puts "hello from thread #{id}"
  sleep(0.2)
 end
end

t2 = Thread.new(2) do |id|
 10.times do
  puts "hello from thread #{id}"
  sleep(0.2)
 end
end

t1.join
t2.join

Para controlar las secciones criticas tan solo hay que cambiar la variable de clase critical a true.

#!/usr/bin/ruby

counter = 0;

t1 = Thread.new do
 100000.times do
  Thread.critical = true
  counter += 1
  Thread.critical = false 
 end
end

t2 = Thread.new do
 100000.times do
  Thread.critical = true
  counter -= 1
  Thread.critical = false
 end
end

t1.join
t2.join

puts counter

Se pueden consultar los demás métodos de la clase Thread en la documentación oficial.

Resaltado de expresiones regulares

2008-08-21T21:51:00.003+02:00

A veces cuando estamos trabajando con expresiones regulares nos podemos perder un poco, para hacer más fácil la tarea se puede realizar un resaltado del matching de la siguiente forma.

#!/usr/bin/ruby

pre = "\033[7m"
post = "\033[m"

print "Cadena> "
STDOUT.flush
str = gets.chop!

while true
 print "Expresion regular> "
 STDOUT.flush
 re = Regexp.new(gets.chop!)
 puts str.gsub(re, "#{pre}\\&#{post}")
end

Un ejemplo de uso.