Javier Aguirre

Taikoa and the future

javaguirre — 2013-06-15T00:00:00+02:00

As some of you may know, I left Wadobo last month and started a new company based in The Netherlands, Taikoa. It was very nice to work with people as proffesional as Danigm and Edulix, we all share a vision how our company should be.

But this was a logical step for me, I wanted to focus more in my life here and I don’t plan to go back to Spain. You never know but we are so comfortable in our new place, I am in love with Delft, It’s a charming little city near cities with a shiny entrepeneurial and freelance life!

The things I value the most here are how people respect the work I do, the quietness of life and the transport, I love to use the bike for everything and the good quality of train service, the lack of stress when moving, It’s a big contrast from Madrid.

Going back to the company, I still work closely with Wadobo, everything is going very well.

I am gonna write about technical stuff in Taikoa Lab, leaving this blog for more personal matters and opinions.

Flashing Firefox OS in the Geeksphone Peak

javaguirre — 2013-05-06T00:00:00+02:00

The official tutorial is excellent to do all the process smoothly, you will need to read it first. I wanted to share with you some problems I found building Firefox OS for the Geeksphone Peak. I am using ArchLinux, but some of the problems aren’t OS related.

After getting the B2G code you will need to use the ./config.sh to build it for the Peak, It’s not in the documentation but you actually can build the peak (the options are there for this device).

To do it you will need its manifest, you can find it in.

git clone git://github.com/mozilla-b2g/b2g-manifest.git

So when you want to build it for Peak without the manifest it will crash, but you can just get the peak.xml from the previous repository.

./config.sh peak route_for_b2g-manifest/peak.xml

Following the official instructions and doing this for the Peak you will be able to config B2G for your device.

When this is finished you will need to have your device connected to run

./build.sh

Keep in mind you need to create the udev rule as It’s documented in the Mozilla instructions.

When the build is done you can flash it, so having the Android SDK correctly installed and in the PATH, you can just.

./flash.sh

If it doesn’t work(it just freezes in waiting for device) I realised I would need root permissions for one of the commands in the script, the one unlocking the Bootloader, fastboot oem unlock, so If It doesn’t work for you try with…

sudo ./flash.sh

This didnt’t work for me because the bootloader was still locked, so this was what I did to fix that.

adb reboot bootloader
sudo fastboot oem unlock

In the chinese page you can push Vol+ to change the checkbox, once is changed you just push the Power button. That’s it! You have your phone unlocked! :-)

Now we could flash the phone, the OS image has changed, so you need to activate the developer remote debugging again to use the flash script.

Once you do that, you just…

./flash.sh # or sudo ./flash.sh

And that will be it! Have fun!

Note: I couldn’t record the errors I had in the process, sorry, but If you have any doubts don’t hesitate to ask, I will try to answer when I have time.

Geeksphone out of stock, again

javaguirre — 2013-05-03T00:00:00+02:00

It seems the geeksphone is out of stock again! Firefox OS is having the attention it deserves and I’m happy for it.

When I was waiting for the shop to open, I create a small script to know when was opened again, just for fun. If you are eager to get one like I was, maybe you would like to use it. :-)

import requests
import time

WAIT = 600
r = requests.get('http://shop.geeksphone.com')
while True:
    if r.status_code == 200:
        print 'Geeksphone available'
    time.sleep(WAIT)

You can change the print to send you an email for example.

import requests
import time
import smtplib
from email.mime.text import MIMEText

WAIT = 600
r = requests.get('http://shop.geeksphone.com')
while True:
    if r.status_code == 200:
        server = 'mymachine@localhost'
        client = 'youremail@whatever.com'
        msg = MIMEText('Geeksphone available!')
        msg['Subject'] = 'Important message'
        msg['From'] = server
        msg['To'] = client
        s = smtplib.SMTP('localhost')
        s.sendmail(server, [client], msg.as_string())
        s.quit()
        break
    time.sleep(WAIT)

If you want to send an email to yourself, install an application like Postfix or Exim for Python to be able to send it.

Continuous Integration, important and fun

javaguirre — 2013-05-02T00:00:00+02:00

Three months ago I installed a server in my place, a month ago I installed my own continuous integration service with Jenkins.

It’s the first time I’m using my own CI service and I couldn’t be happier, I’m saving time and money with this service even when I’m just alone in some of the projects. It helps me being much more careful with my projects and to keep a log of the projects status. I have it here listening in localhost, so It doesn’t have connection to the outside, when I want to see it from the outside I just create a ssh tunnel for that moment.

I have always been very interested in improving my development skills, usually learning new technologies, but I’ve been thinking how to save time and control it this last months and I’m very happy about it. Productivity is always an important matter for a freelance and a difficult one to measure if you don’t have certain discipline. That’s why I’m using Vimwiki and gtimelog every day to control it and create reports of the hours I’m working. My clients want to know too, so I could use the same tool for their reports.

I love the command line and gtimelog is GTK+, so I’m using a tweaked version from Reinout Van Rees to achieve that.

Squid y túnel SSH para estar como en casa, Firefox mediante

javaguirre — 2013-03-25T00:00:00+01:00

Esta semana he puesto a funcionar un proxy vía un servidor en España, al principio fue una tarea ardua, porque no tenía ni idea de lo que necesitaba y no le estaba preguntando los términos correctos a Google, pero tras pelearme y poner en funcionamiento OpenVPN y algunas cosas más me di cuenta que tenía un problema de concepto y que lo que yo necesitaba para ver las motos y la F1 como si estuviera allí era otra cosa.

En Holanda no tenemos televisión en la casa y para ver algo tienes que pagar, mi actual compañía de Internet me ofrecía un paquete por 38.50(IVA de aquí incluido) que es menos que lo que pagaba en Madrid sólo por internet, pero nuestra negativa a no tener televisión es más de convivencia y deshacernos de cosas innecesarias.

Después de entender conceptos y saber lo que necesitaba, montar el proxy para que Firefox entrara con Ip española fue la mar de fácil, voy a comentar aquí lo que se necesita, aunque en muchos lugares podéis encontrar una solucion parecida, eso sí en inglés. El sistema que me sirve a mí es el siguiente:

En el servidor instalar Squid apt-get install squid o pacman -S squid, el paquete puede llamarse también squid3.

La configuración de squid, como sabréis estará normalmente en /etc/squid(3) y no habrá que tocarla mucho, son unas 5000 líneas, pero sin comentar yo tenía poquitas, lo ideal es tener la aplicación escuchando únicamente en localhost por seguridad, y que ssh se encargue de la conexión de los puertos entre el servidor y nuestra máquina local.

Una vez instalado y comprobado que Squid funciona (viendo que el puerto está activo con netstat, mirando con ps ax si el proceso se ha lanzado y si no tenemos ningún firewall incordiando), hacemos el túnel ssh. Si lo pusimos en el puerto por defecto de Squid bastará usar un comando del tipo:

ssh -C2TNvg -L 3128:localhost:3128 usuario@servidor

Si todo ha ido bien podemos probar el proxy con la siguiente orden.

curl --proxy 127.0.0.1:3128 http://javaguirre.net

Si no hay ningún problema recibirás el html de la página principal de esta web.

Una vez funcione la llamada curl podemos introducir los datos del proxy en la configuración de Firefox. Elegimos Preferencias, Avanzado, Configuración en Conexión y dentro Configuración Manual en Firefox, en el SOCKS y en HTTP Host tenemos que meter 127.0.0.1 y el puerto el 3128. También se puede poner las mismas opciones (Ip, puerto) en SSL y FTP si queremos usar el proxy para esos servicios.

Con esto ya tenemos el proxy funcionando y deberíamos poder acceder a las webs que queramos. :-P

Referencias:

https://calomel.org/firefox_ssh_proxy.html

/dev/haag meeting and Gitlab

javaguirre — 2013-02-25T00:00:00+01:00

Last Friday I had the opportunity to go to my first /dev/haag meeting, It is a really serious and well organized event with well-prepared talks.

The first one was about Reverse Launching and Gitlab, Sytse Sijbrandij gave us an interesting talk about trying to get feedback even before starting to ship anything, just feeding discussion about a possible market and checking the interest of people in that project in case it would came to reality.

The second one was about the beautiful RijksMuseum new website, Elaine Oliver gave us a talk about how important is to be responsive nowadays and their approach to get it for this site.

The last talk was about a topic I’m concern about, DrWhax tried to immerse us in the world of cryptography in Internet and told us about the Cryptoparties and a more securized world.

It was interesting to talk about Gitlab and its possibilities with Sytse, I had a really good time there and I will repeat next time for sure.

I also got some conclusions about what we are missing in Wadobo without a real project of our own, I think we need to improve that, explore options and try to put more efforts in our projects and less in consulting.

After FOSDEM 2013

javaguirre — 2013-02-16T00:00:00+01:00

This year has been my first time at FOSDEM. I liked the experience but I think I could have enjoyed it more with a community behind, I think this kind of event has more meaning when you are part of a FLOSS community, otherwise you are not enjoying all that offers.

In general the focus of the conferences has been mobile development(Firefox OS and others) and I missed more Hardware content, I am very interested in robotics and it would be good if talks about Open Hardware and 3d printers could have taken place, I understand that’s not anybody’s fault, but I wanted to point it out.

FOSDEM has increased my interest in contributing in a big project, concretely Mozilla, I think there are a lot of interesting stuff to do and learn there and it’s a great place to improve skills as a developer.

I’m very interested in C++, It’s a logical step for me, to start doing something with this language to be able to contribute in more different and meaningful projects.

Good experience, I think we will repeat next year, hopefully. :-)

If you want more, Danigm has written much more and detailed than me in his blog(ES).

Playing with Bootstrap tour, Anchors for navigation and onShown event

javaguirre — 2013-02-04T00:00:00+01:00

Today I have been finishing the integration of Bootstrap tour in our AngularJS application. I was having a problem with navigation with the path element in the steps because they does not support anchors for navigation, so I did a little pull request to fix that to my needs.

The second problem I had was the position of popovers, I wanted to change it after it was shown and I didn't found a good event to cover my needs in the documentation. Although checking the code I fond an onShown event I’m using to fix the position of some of the steps. The solution would be something like this.

var tour = new Tour({
    onShown: function (tour) {
        if(tour._current === 0 || tour._current === null) {
            //do something for the first step
        }
        else if(tour._current == 4) {
            //do something for the fourth step
        }
    }
});

Checking Boostrap Tour

javaguirre — 2013-01-31T00:00:00+01:00

Today we have been started using Bootstrap Tour, interesting stuff. It seems to be easy to create tours for your site with it, but I couldn't get it working perfectly yet.

It’s developed with Coffeescript and has some good events too.

It uses localStorage or cookies to store the current step of the tour and can navigate through your site when you go further in it.

I have some trouble with the integration with my Angular app, something normal, and I have fixed a little bug too, we had time for everything. :-)

There are some things to finish in our integration, I hope we could contribute more in the project.

Avoiding nodes overlapping in d3 trees

javaguirre — 2013-01-30T00:00:00+01:00

This is a simple example to avoid overlapping between siblings in a d3 tree.

I have been working a lot with d3 trees lately and dynamic node resizing, which is cool to have a complex representation for you data.

When using simple d3 trees with different node sizes, they sometimes overlap with each other. I knew there is a separation method, but I couldn’t get it working for my case, so using an example designed for d3 force element I could adapt to my current simple tree.

function collide(node, node_sibling) {
  var r = node.size,
      n1y1 = node.x - r,
      n1y2 = node.x + r;
  var r2 = node_sibling.size,
      n2y1 = node_sibling.x - r2,
      n2y2 = node_sibling.x + r2;
  result = (n1y1 < n2y2 && n1y1 > n2y1) || (n1y2 > n2y2 && n1y2 < n2y1);

  return result;
}

The size property doesn’t exist in nodes, so it will be whatever property you want to control the size of them.

I’m just checking in one dimension (x) because I want to control only siblings in my tree and they are aligned across the y axis. You could do the same with the y property in this function.

This kind of function could be approximately the same for other d3 elements.

To use it in a tree we could use it inside a forEach loop in nodes.

function detectCollisions(nodes) {
  nodes.forEach(function(d, index) {
    for (var i=0; i < siblings.length; i++)
    {
        if(d.id != siblings[i].id) {
            if(collide(d, sibligns[i])) {
                // Do something, like change the position
                // of the current sibling
            }
        }
    }
  });
}

This is it by now, I will get more deeply into it soon if I think there is something worth to comment.

Using SessionAuthentication With Tastypie tests for Django

javaguirre — 2013-01-29T00:00:00+01:00

Today I have been studying more deeply how to create good tests with Tastypie’s alpha version documentation.

It was easy to start if you knew about TestCase and django test Client, but still Tastypie documentation has a lot of blanks in this part.

I was using SessionAuthentication to authenticate my resources and it uses Django sessions in background, so it had to be easy to test it with the ResourceTestCase. It wasn’t as easy as it seemed and we needed to check the code to understand how to do it.

In a real Django app we could use login method from django.test.client.Client, and I thought tastypie.test.TestApiClient could be inheriting from it, but because you can have different kinds of authentication it wasn’t the right choice for the Tastypie api test client architecture.

If we read TestApiClient’s __init__ we can see it has a client attribute, instantiating from django.client.Client.

class TestApiClient(object):
    def __init__(self, serializer=None):
        """
        Sets up a fresh ``TestApiClient`` instance.

        If you are employing a custom serializer, you can pass the class to the
        ``serializer=`` kwarg.
        """
        self.client = Client()
        self.serializer = serializer

        if not self.serializer:
            self.serializer = Serializer()

With this in mind and following the same idea we could just do this in our tests.

from tastypie.test import ResourceTestCase, TestApiClient


class ExampleResourceTest(ResourceTestCase):
    def setUp(self):
        self.api_client = TestApiClient()
        self.get_credentials()
        self.example = {'title': 'My Data'}

    def get_credentials(self):
        result = self.api_client.client.login(username='myuser',
                                              password='secret')
        return result

    def test_post_project(self):
        self.assertHttpCreated(self.api_client.post('/api/v1/example/',
                                                    format='json',
                                                    data=self.example))

Now we can build authenticated requests for tests using SessionAuthentication in Tastypie.

Easy after all. :-)

Google Font for jQuery Mobile Themeroller

javaguirre — 2013-01-22T00:00:00+01:00

This weekend I started to play with Phonegap + jQuery Mobile for a new project I’m developing. I never have worked with it before, but I think it could be a good stack if we mix it with backbone and some other technologies, so I’m gonna give it a try.

In my research I found Theme Roller, a very good service to customize your jquery mobile theme, so I started using it and I realize it could be good to have google font support(among other things) to use it in the preview.

This new functionality is based in the work they were doing before, I reused the font input, so if you add a google font in the list of fonts(it has to be the first one in the list) and you click update font, it will preview your font in the swatches view and will add it to your zip package when you download it.

For example if the fonts are Dosis, Arial, sans-serif it will try to add the Google Font Dosis.

I made a pull request with this functionality and you can check it in my own copy of the project, there is a demo too.

Feedback is much appreciated!

New changes in Gramophone

javaguirre — 2013-01-07T00:00:00+01:00

News about Gramophone music server! We have done so many changes. I said us because I’ve joined forces with Danilo Bragen, a highly skilled developer who had a similar project, but he was builting it with Flash and jPlayer.

Due to his suggestions we moved from cherrypy to Flask. I really prefer Flask too, but I wanted to have the less dependencies possible. I think the change is a good idea since we both have experience with Flask and we both feel more comfortable with it.

We changed the Audio.js player too and we are using jPlayer now, which has more community, supports much more file extensions and has a stable development.

Filters and searching for tracks, authors and artists are also available, and we have done a little improvement in the design, although we need to work more on the frontend part and the update collection task in the server.

You can follow the development in github.

Developing Gramophone music server

javaguirre — 2012-12-17T00:00:00+01:00

It’s been a while since I received my Raspberry PI and just a few weeks since I stopped paying my Spotify premium account.

Spotify it’s a good service but the applications for GNU/Linux and Android aren’t good enough. The Spotify app for Linux runs under Wine and has some bugs such as losing the connection unexpectedly and not reconnecting again unless you rerun the app, sometimes the search bar is not working, it uses a lot of resources (it’s using Wine, so it’s not a surprise) and sometimes crashes in dwm (I think this last problem has to be with Wine, not with the Spotify app).

The Android app has a vertical layout, and that’s it, so in my Android tablet it’s a real pain, the natural position for my tablet when is placed somewhere is horizontal, so this problem added with some usability issues made me decide to stop using the service.

I wanted to use a music server in my Raspberry PI to fulfill my needs of music at home, but the one I liked is subsonic and it’s pretty heavy. I was doing some research and I found some alternatives, but I wanted something simple. I love music and I have some free mondays so it’s the perfect excuse to start building a web music server for my RaspPI. :-)

I’ve called it Gramophone (I’m a romantic :-P ), it’s built with Python3 and CherryPy, and the frontend is built with Backbonejs. The database now is Sqlite, I want to install the less packages possible to run the server. For the audio plugin it’s using audiojs, it’s simple but it hasn’t been updated for a long time, so maybe in the future it could be a good idea to change it.

You could follow it’s development in its github repository.

PyLapse, Timelapse builder in Python

javaguirre — 2012-12-12T00:00:00+01:00

It’s been a while since I don’t write anything, I’ve been really busy since I joined Wadobo.

Last weekend I built a first version of PyLapse. It intends to be a simple program to build timelapses from my Raspberry PI, but It would be really easy to use if you use GNU/Linux.

All the instructions and everything about the project is in the PyLapse repository. I need to improve the video generation, but I understand some people would like to build it themselves once they have the pictures, so you could use the app just for getting the pictures every X seconds and then manually generate the video with a proffesional program.

New look!

javaguirre — 2012-11-12T00:00:00+01:00

Celebrating my recent incorporation to Wadobo I’ve changed the look of my site inspired by wadobo.github.com :-P. I’ve been playing with the @media and screen in the css to have a navigation list more responsive, I hope you like this change. :-)

The code is in my repository.

Me uno a Wadobo

javaguirre — 2012-11-07T00:00:00+01:00

Ya hace cuatro meses que estoy viviendo en Holanda, y tras dejar mi primer trabajo debido a expectativas no cumplidas tuve la suerte de conseguir dos proyectos y empezar a trabajar por mi cuenta.

En aquel tiempo en el que estuve tomando la decisión de crear una empresa en Holanda, mi amigo Edu me llamó ofreciéndome entrar en Wadobo, una empresa con sede en Sevilla pero en la que sus integrantes trabajan desde donde quieren, centrándose en la felicidad.

Conozco a Dani y a Edu desde que estudiaba en la universidad, todos formábamos parte de un grupo de gente que tiene intereses comunes llamados Sugus, la Asociación de Software Libre de la Universidad de Sevilla, así que cuando me lo propusieron no me lo pensé. Para mí ya en aquella época ellos eran una referencia y afines a mis ideas.

Tras mi experiencia en Madrid en diversos entornos tenía muy claro que lo que quería era ser mi propio jefe y ahorrarme muchos problemas que surgen debido al, según mi opinión, mal entendimiento de lo que una empresa o grupo de trabajo de desarrollo de software saludable debe ser, y esa fue una de las razones por la cual me quería ir fuera de España, quería sentir cómo se veían las cosas fuera.

Por otra parte siempre he querido trabajar con personas afines al movimiento de Software Libre, intentando siempre dedicar mi día a día, todo lo posible, a participar en este tipo de proyectos.

Unirme a Wadobo es un paso lógico para mí en mi evolución profesional y algo por lo que estoy muy contento. :-)

Starting with Mutt

javaguirre — 2012-10-19T00:00:00+02:00

It’s been a while since I wasn’t happy with Thunderbird, thinking it could be much better for me if I switch to a shiny command line email client, today was that day, I’m switching to Mutt. :-)

Although it wasn’t a bed of roses, I had to search a lot to have the perfect configuration I wanted. I started with this inspiring article I read last week, and I just started searching for this little but essential things I was missing.

My configuration is almost final now, I want to change some colours in the scheme, but that’s just fine tuning. I’m using offlineimap in the way Steve Losh recommends it, but I desisted from using msmtp for sending emails, I’m gonna use the native smtp support in Mutt and gpg encryption for the passwords.

For sending emails from different accounts or alternates, I spent some time until realising I needed to put the set reverse_name property because Mutt didn’t want to let me just change the From with my desired email address.

set reverse_name
set my_user = "mail@example.com"
alternates javaguirre@example2.com info@gmail.com contact@example.net
set smtp_url="smtp://$my_user:$my_password@smtp.gmail.com/"

These are the most important changes I’ve done to have it like I wanted, if you want to configure it in a different way you could follow the links above. :-)

The power of f and t in Vim

javaguirre — 2012-10-12T00:00:00+02:00

Today I would like to write about some of the magic of Vim! I usually study how to code faster learning new Vim commands, some of my favourites are f and t, they’re really handy when you need to change parts of a line and these parts are not wrapped by anything, such as marks, brackets or a simple word.

We’d better see an example:

// specify an alternate install location for Bower
bower: {
  dir: 'app/scripts/vendor'
},

we would like to erase scripts/vendor from the code above, and the cursor is in the dir word, to achieve our goal we could do fs to go there and then 3dw, but the second command could be replaced by dt'.

If we wanted to delete app/ we could do dT', but if we wanted to jump to the last slash (from our actual position, the first s in scripts) and then delete everything behind and inside the marks we could do f/ and then dT'.

This example was really easy, but if you didn’t know these commands it’s a fast solution when you couldn’t just delete an inner word (diw), something between quotation marks (di'), etc.

These are the things that make me love Vim. :-)

Returning to Symfony, building API and playing with AngularJS

javaguirre — 2012-10-11T00:00:00+02:00

It’s been almost two months since I started working again, now I have two projects, one of them using Symfony because my teammate in this project knew PHP, so it was the right choice.

Symfony has improved so much since I started using it a few years ago, now they use the package manager called composer, it has a good template engine(Twig), and more. There are a lot of ways to do the same, so you could choose the better solution for your current situation.

In our case we wanted to use Symfony with AngularJS, the Javascript client framework from Google, so a Restful API was necessary. There is a really complete bundle (modules/plugins in Symfony) to achieve this, FOSRestBundle, but I thought it was too complex for what I wanted, so I decided to use a mix with the @Template annotation in the Controller and define the routing with the _format special variable.

The controller would look more or less like this…


    ...

    /**
     * @Template()
     */
	public function indexAction()
    {
        $products = $this->getDoctrine()
                ->getRepository()
                ->find();

        return array("products" => $products);
    }

    /**
     *  @Template()
     */
    public function showAction($id)
    {
        $product = $this->getDoctrine()
                ->getRepository()
                ->findOneById($id);

        return array("product" => $product);
    }

    /**
     *  @Template()
     */
	public function newAction()
    {
        return array("product" => new Product());
	}

    /**
     *  @Template()
     */
	public function deleteAction($id)
    {
        $em = $this->getDoctrine()->getManager();
        $product = $em
                ->getRepository()
                ->find($id);

        if (!$product)
        {
            throw $this->createNotFoundException('msg');
        }

        $em->remove($product);
        $em->flush();

        return new RedirectResponse($this->generateUrl('product_index'));
	}

    /**
     *  @Template()
     */
    public function editAction($id)
    {
        return $this->render("MyBundle:Product:new.html.twig");
	}

    /**
     *  @Template()
     */
    public function saveAction($product_id=-1)
    {
        ... save stuff getting JSON object
    }

This would be a normal Controller defining CRUD actions for Product, we didn’t need to define a template render here because the @Template annotation will take care of finding the right template according to the name of the action (*.html.twig or *.json.twig in my case). In the editAction we wanted to show a specific template so we didn’t need to write the @Template annotation and we write the render explicitly.

About the model, for this to work is necessary for the Entity to implement the JsonSerializable interface (new in PHP 5.4), and then create the jsonSerialize method returning the array.

Our routing file could be like this one:


    _product_index:
        pattern: /products/all
        defaults: { _controller: MyBundle:Product:index }
        requirements:
            _format: json
            _method: GET

    _product_new:
        pattern: /products/new
        defaults: {_controller: MyBundle:Product:new, _format: json }
        requirements:
            _method: GET

    product_get:
        pattern: /products/{id}
        defaults: {_controller: MyBundle:Product:show, _format: json }
        requirements:
            _method: GET

    product_create:
        pattern: /products/create
        defaults: { _controller: MyBundle:Product:save, _format: json}
        requirements:
            _method: POST

    product_save:
        pattern: /products/{id}
        defaults: { _controller: MyBundle:Product:save, _format: json}
        requirements:
            _method: PUT

    product_delete:
        pattern: /products/{id}
        defaults: { _controller: MyBundle:Product:delete, _format: json }
        requirements:
            _method: DELETE

To retrieve this data easily from Angular we would create a resource:


    angular.module('myServices', ['ngResource']).
        factory('Product', function($resource) {
            return $resource('/products/:productId', {}, {
                query: { method: 'GET', params: {productId: 'all'}, isArray: true},
                get: { method: 'GET'},
                save: { method : 'PUT'},
                create: { method : 'POST'},
                destroy: { method : 'DELETE'}
            });
        });

With this few lines we have all requests defined for Angular to retrieve and interact with data from server, if you want to know more about Angular resources, there’s good documentation in their site.

This is too long now so just a little tip, you could create the twig json template just with this line of code…


    //Resources/.../product.json.twig
    \{\{ products|json_encode|raw \}\}

If you don’t use the @Template annotation is not necessary to create this template, you could just serve a json object using json_encode, but it’s necessary with my approach.

Backbone y Flask, primeras impresiones

javaguirre — 2012-09-13T00:00:00+02:00

Hacía tiempo que quería probar Backbone y en mi trabajo no había tenido la oportunidad de hacerlo, ahora que tengo tiempo libre he decidido probar y poner en práctica todas estas cosas que creo se han convertido en estándar de facto y no he tenido la oportunidad por falta de tiempo.

Hace dos semanas estuve con un proyecto de Android y practiqué los principios básicos de su API, la semana pasada le tocó el turno a Backbone, ya que mi proyecto Android quedó en punto muerto y hay otro proyecto que quiero dejar listo pronto ahora que tengo tiempo para ello.

Estuve probando el proyecto de to-dos, primer ejemplo básico construido con Backbone y Flask, y de ahí lo adapté a lo que yo necesitaba para OpenBoe, y estoy muy contento con cómo ha quedado la estructura del frontend y lo fácil que son las cosas con Backbone una vez que le has dedicado un tiempo. Todavía mi código no es muy bueno (llevo pocas horas probando con las herramientas), pero ya hace lo que yo necesitaba, que no es poco, la segunda fase será optimizar el código y hacerlo más agradable.

Para poner en situación, OpenBOE es un servicio escrito en Flask con una tarea en background que hace scraping sobre la web oficial del BOE y guarda los datos extraídos en una base de datos en Mongo para su posterior ordenación y filtrado en el servicio. La parte del frontend ahora es más dinámica, no teniendo que cargar parte de la pantalla, ya que era innecesario completamente. Ahora sólo se refrescará la lista en función de nuestros parámetros de búsqueda y a correr. :-)

Con esto quería mostrar un ejemplo sencillo de cómo lo he hecho para los que tengan ganas de empezar con Backbone y les haya dado pereza meterse en la documentación oficial o en algún proyecto ejemplo.

La parte servidor podría ser:


    @app.route("/")
    def index():
        '''
            Cargamos la vista principal, en la que sólo cargaremos
            las secciones y los titulos para poder navegar por ellas
            posteriormente
        '''

        sections = Db().get_col('section')
        feeds = Db().get_col('feed')

        return render_template("index.html", sections=sections, feeds=feeds)


    @app.route("/links/", methods=['GET', 'POST'])
    def feed():
        '''
            Cargamos los elementos del feed rss
            tomado como parámetro, Esta función servirá
            para cargar todos los datos que necesitemos
            en cualquier sección de la web
        '''

        feed_slug = request.args.get('feed', '')
        feed = Db().find_one('feed', {"slug": feed_slug})
        if not feed:
            abort(404)

        links = Db().has('link', {"feed_id": feed['_id']}, sort_field="date")

        return  make_json_response(links)

        ...

    def make_json_response(body):
        '''
            Crea una respuesta en JSON para cuando lo solicite
            Backbone.
        '''

        resp = make_response(json.dumps(body, default=json_util.default))
        resp.mimetype = 'application/json'

        return resp

Ya tenemos todo lo necesario para empezar a jugar con Backbone, una primera vista index que se cargará al inicio, y con los menús que hemos creado en ella iremos navegando por la web, de la navegación se encargará en este caso el frontend, o mejor dicho Backbone.Router.

El método feed se encargará de dar los datos en JSON en función de en qué sección nos encontremos. Aquí podríamos definir también filtrado de búsqueda para devolver sólo los datos en los que el usuario estuviese interesado.

Vamos con la parte del frontend con Backbone.


    (function() {
        var TEMPLATE_URL = '/static';

        var Link = Backbone.Model.extend({
        });

        var LinkList = Backbone.Collection.extend({

            model: Link,

            url: '/links/',

            initialize: function(options) {
            },

            fetch: function(options) {
                return Backbone.Collection.prototype.fetch.call(this, options);
            }
        });

        var LinkView = Backbone.View.extend({
            tagName:  "div",

            initialize: function(options) {
            },

            render: function() {
                var self = this;

                $(self.el).template(TEMPLATE_URL + '/templates/item.html', self.model.toJSON(), function() {
                    self.setText();
                });

                return this;
            },

            setText: function() {
                var text = this.model.get('description');
                var title = this.model.get('title');
                var link_link = this.model.get('link');
                var guid = this.model.get('guid');

                this.$('.item-description').text(text);
                this.$('.item-link').text(title);
                this.$('.item-link').attr('href', link_link);
                this.$('.pdf-item-link').attr('href', guid);
            }
        });

        window.LinkApp = Backbone.View.extend({

            events: {
                "click #search-button": "performSearch"
            },

            initialize: function(options) {
                var self = this,
                    parentElt = options.appendTo || $('.body-container');

                TEMPLATE_URL = options.templateUrl || TEMPLATE_URL;

                parentElt.template(TEMPLATE_URL + '/templates/app.html', {}, function() {
                    self.el = $('#openboeapp');
                    self.delegateEvents();

                    self.links = new LinkList({feed: options.feed,
                                               query: options.query,
                                               params: options.params
                                              });
                    self.links.bind('add',   self.addOne, self);
                    self.links.bind('reset', self.addAll, self);
                    self.links.bind('all',   self.render, self);

                    self.section = options.section;
                    self.feed = options.feed;

                    self.links.fetch({feed: options.feed});
                });
            },

            render: function() {
                var self = this;
                return this;
            },

            addOne: function(link) {
                var view = new LinkView({model: link});
                this.$("#link-list").append(view.render().el);
            },

            addAll: function() {
                this.links.each(this.addOne);
            }
        });

        window.MyRouter = Backbone.Router.extend({
            routes: {
                "!/": "index",
                "!/:section/:feed": "feed_items",
            },

            index: function() {
                console.log("This is the index!");
            },

            feed_items: function(section, feed) {
                var myquery = query || "";
                var view = new LinkApp({
                                        feed: feed,
                                        section: section
                                       });
            }
        });
    }());

Hay varios elementos en Backbone, yo en este caso he utilizado Model, Collection, Router y View.

Lo más importante que hay que saber en este caso es que el Collection llamará a nuestro servidor cuando usemos fetch para traerse los datos de tipo Link (Model), y usará la url definida en url. Añadiendo parámetros a esta url en la inicialización del objeto o en fetch, podremos hacer consultas personalizadas.

La View se encargará de pintar su plantilla o el html asociada a ella donde nosotros le digamos (en este caso en #openboeapp), y en su initialize podremos llamar al fetch de los objetos que necesitemos para cuando esta vista se inicie así como unir algún evento a funciones de nuestra vista o casi hacer cualquier cosa que queramos.

En mi caso tengo dos views, una para pintar cada elemento y otra que se encarga de la colección, muy útil si queremos crear eventos de edición eliminación de cada objeto manteniendo limpia la vista padre y haciendo más fácil el testeo de cada parte. En LinkView tenemos un setText, que se encargará de inyectar nuestras variables en el template definido en esta parte, pero es más limpio pasarle una lista de objetos al propio template y definir en éste donde va cada variable.

Para darle un poco de sentido y localización a cada vista y los posibles datos en ellas, podemos organizarlo todo en el Router. En él definiremos la ruta y qué método se encargará de la petición entrante por ésta.

Por ahora poco más, puedes ver el ejemplo completo en el repositorio de OpenBOE y seguir otras referencias que he comentado en el artículo.

Problems with Mercurial

javaguirre — 2012-09-05T00:00:00+02:00

It’s been a while since I had this problem with mercurial in Archlinux, and now was time to fix it.

Before I started using virtualenv months ago, I did all my experiments in the Archlinux root for Python2.7, it seems it(or I) broke something in a compilation and it affected Mercurial build for my system. I couldn’t even clone a mercurial repository, it always threw this interesting error…

    Traceback (most recent call last):
  File "/usr/bin/hg", line 36, in <module>
    mercurial.util.setbinary(fp)
  File "/usr/lib/python2.7/site-packages/mercurial/demandimport.py", line 86, in __getattribute__
    self._load()
  File "/usr/lib/python2.7/site-packages/mercurial/demandimport.py", line 58, in _load
    mod = _origimport(head, globals, locals)
  File "/usr/lib/python2.7/site-packages/mercurial/util.py", line 202, in <module>
    collections.deque.remove
  File "/usr/lib/python2.7/site-packages/mercurial/demandimport.py", line 86, in __getattribute__
    self._load()
  File "/usr/lib/python2.7/site-packages/mercurial/demandimport.py", line 58, in _load
    mod = _origimport(head, globals, locals)
  File "/usr/lib/python2.7/collections.py", line 9, in <module>
    from operator import itemgetter as _itemgetter
  File "/usr/lib/python2.7/site-packages/mercurial/demandimport.py", line 114, in _demandimport
    mod = _origimport(name, globals, locals)
ImportError: /usr/lib/python2.7/site-packages/operator.so: undefined symbol: _PyUnicodeUCS2_AsDefaultEncodedString

I tried to fix it compiling python with --enable-unicode=ucs4, but didn’t work. After an hour trying to fix this in /usr/lib, I realised I could try to fix it in a virtualenv, it’s a great way to have everything under control in any of your python projects and I’ve been using it for every project.

My final solution was as easy as…

$ virtualenv2 ~/.virtualenvs/mercurial
$ workon mercurial # Or ~/.virtualenvs/mercurial/bin/activate
$ cd Mercurial-3ee5d3c372fa/ # tarball from http://selenic.com/hg/file/3ee5d3c372fa
$ python setup.py install

That’s it! it runs smoothly now.

UPDATE: Once I could isolate the problem I realised it had to be with some kind of problem with an import for SSL, I moved the operator.so file and installed the Mercurial tarball I downloaded previously in my virtualenv (and worked there), I think the problem is solved now, It seemed a compilation build was done in a wrong place. :-)

Doc Translator II

javaguirre — 2012-08-24T00:00:00+02:00

Well, this week I’ve been studying how to do the document translator and developing the project for Android, but I didn’t have good results for the text recognition in images and I don’t think I will because of the tesseract library, I knew it was old but I wanted to do some tests with it.

I don’t think it’s a solution for my problem by now, so I will keep studying Android but this project will be stopped, I will give a try to some of the applications in Google Play, maybe one of them will suit me. :-)

Now it’s time to do more research.

So much reading!

javaguirre — 2012-08-22T00:00:00+02:00

When I was in Madrid I didn’t have enough time to do nothing during the week. I work less hours here and now that I don’t have a job I spend some hours programming and reading, technical books and literature.

Our habits have changed here in The Netherlands, now we have more time in the afternoon, we watch less series and we read more. All our books are now digital because when we moved we needed to control the space and weight of our suitcases, we left all our books in Spain and now my girlfriend is happy with her kindle and I read in a TF300 tablet I bought in my last weeks in Madrid.

I have read Michael Crichton’s Jurassic Park and The Lost World books, Odisea Two from Arthur C. Clarke, first book of Asimov’s Lucky Starr and two books from Matilde Asensi in this five weeks, but I’m also finishing The Pragmatic Programmer, in the middle of The Vi and Vim Editors and starting Android Development, I’m quite interested in the last one.

I need to spend my time in a practical way, reading and programming are some of the most enjoyable ways for doing it for me. :-)

Doc Translator, First Steps

javaguirre — 2012-08-21T00:00:00+02:00

Today I resume my work in the Doc Translator project, its goal is to be capable of getting data from images via OCR (with tesseract library) and then translate it via Google Translator, it’s also a perfect excuse for me to start developing for android devices. :-)

A couple of weeks ago a friend told me this functionality is already implemented in Google Goggles, but it’s not really useful with documents. I have the same problem with Google Translator functionality, good for signs or small sentences, but not good for documents, so I will try to use the tesseract library and we’ll see if we could make any progress in this field.

I’ve been playing around with buttons and the Camera API, nothing serious yet but you can follow the development in github.

Web Static Gallery Generator

javaguirre — 2012-08-20T00:00:00+02:00

I have time now to develop some projects I left unattended this last three weeks, one of them was the web gallery generator I talked about before.

Today I have implemented some goodies and now the generator output is easier to configure. We have new options from the command line and the source of the gallery shouldn’t be the same directory as the destiny. I’ve also added a simple server to check everything is fine during development and to debug custom templates if someone does it. There’s also the possibility to reload the gallery, this wasn’t possible before.

If you want to use it and change the template of the gallery, you could build your own using jinja syntax, adding it to the templates directory, and finally selecting it from the command line with the --template-gallery option.

This is the help from the command line:

usage: generator.py [-h] [--template-gallery TEMPLATE_GALLERY]
                [--template-menu TEMPLATE_MENU] [--src SRC] [--dst DST]
                [--server] [--port PORT] [--reload]

Static Gallery Generator Options.

optional arguments:
  -h, --help            show this help message and exit
  --template-gallery TEMPLATE_GALLERY
                        Choose the name of the template for the gallery
  --template-menu TEMPLATE_MENU
                        Choose the template for the menu
  --src SRC             Source directory for the gallery
  --dst DST             Destiny where the web gallery will be generated
  --server              Executes a server
  --port PORT           Choose the port for the server, by default 8000
  --reload              Reload all galleries, even if they exist in the
                        destiny

The next step could be to create a pip package, I think I don’t need more features, but we will see. If you are interested you can check/fork the code in github or see an example.

Follow your heart

javaguirre — 2012-08-14T00:00:00+02:00

This week I quitted my actual job. It was my first job in The Netherlands and I was working there for just a month, but I was certain I wasn’t happy with it. The main reason was I didn’t want to develop web applications using the GWT stack, this wasn’t defined when I first accept the job and was a bit dissapointed at first. Anyway I think I need to search something that I could really like, I have the possibility to choose and I thank that.

People in the company was really great, but you need more than that to be happy. Now it’s time for me to search for a company where I could really fit, I’ll try to use this free time to contribute to some cool projects!

Of course I’m opened to pythonic offers. :-)

Projects, Translator and Static Gallery Generator

javaguirre — 2012-08-12T00:00:00+02:00

I've been busy these last two weeks, just exploring the country I live in. We've also visited other cities such as Rotterdam and Amsterdam so my personal projects are improving slowly now.

Although I have three new ideas, two of them currently in development, the other come out today, so it's just nothing yet. All of them cover some needs I realised I have. The first was the album gallery, I wanted to share photos with my family in Spain, I was using Flickr until I reached the 200 photos limit (didn't know Flickr had it). I didn't want to pay for this service because I barely used it in the past and I'm paying two servers for personal use, so I thought the best solution could be having a static gallery generator using my actual directory gallery tree to define navigation, that's what I did finally. I didn't like any of the projects I checked to solve the problem, because they were too big for what I wanted or for other reasons.

I found something what was aproximately what I wanted, but last week I finished rewriting almost everything(there were a few lines of code). The project uses now Jinja2 to generate everything and doesn't have any framework or standalone server like the project I forked from(It uses Flask).

The second project I thought I need is a Dutch translator for important documents, like contracts and this kind of things. The application has two parts, we could take a photo with the device camera and then get the text using OCR technology (in this case Google's tesseract library using NDK to build a Java Library). The second part is sending the text to Google Translator API (Paid API) and then returning the text translated. This project is really useful for me in the Netherlands but I don't see a commercial exit for it because is completely dependent in Google API. Anyone who wants to use the API has to pay 20$ per 1 million words, something difficult to control and with high risk of getting people frustrated using the app (because most of them couldn't know this issue).

I will talk about the third project soon, it's related with OpenStreetMap.

Todo en Java

javaguirre — 2012-07-25T00:00:00+02:00

¡Oh no! Esto es un poco lo que pensé cuando me enteré de que todo el servicio web en la empresa estaba hecho en Java. Ahora lo veo más algo motivante e interesante, realmente estoy disfrutando que me hayan sacado de mis casillas digamos, tener que trabajar en Java y hacerme un poco la puñeta a la hora de necesitar una herramienta de desarrollo que me ayude a entender la arquitectura y me autocomplete un poquito para avanzar rápido, con lo feliz y cómodo que estaba yo usando Vim...

Me parece muy interesante tener que usar Eclipse(empecé con NetBeans pero las cosas que necesitaba tienen bugs en Arch) y sacarme de mi hábitat aunque eso cueste algún tiempo de adaptación, creo que con algún que otro plugin lo estoy sobrellevando bien (El plugin Vrapper por ejemplo, que funciona perfecto para tener los comandos de Vim en Eclipse). A pesar de tener este plugin es siempre útil aprender alguna tecla rápida más para ahorrar tiempo, siempre bienvenido.

Primeros días en Holanda

javaguirre — 2012-07-25T00:00:00+02:00

Ya llevo aquí unos días, la verdad es que estoy muy contento con ello, ya tengo mi propia bici, el tiempo es buenísimo para comer fuera ahora, la gente en todas partes a la que vas es muy amable y las personas en el trabajo han estado desde el primer día haciéndome sentir como si (casi) estuviese en casa.

Java, mi primer acercamiento al lenguaje tras aquella primera versión de Callejero, aquel código era una calamidad y acabamos reescribiendo a Symfony. Ahora en otra empresa tenemos un equipo con experiencia en Java y que saben cómo funcionan las cosas, así que para mí el acercamiento está siendo más sencillo gracias al apoyo del equipo técnico aquí.

Hasta hoy todavía tenía dudas de por qué el framework, hoy me ha quedado todo claro y estoy más contento por saber dónde me he metido. :-)

Delft es increíble, una ciudad preciosa para vivir, y ahora en verano cuando no llueve todo es bonito y la gente sale a la calle a hacer barbacoas y a pasear a la orilla del canal con un helado. Me gusta la lluvia así que no creo que sea para mí un problema, me encantaba cuando vivía en Santander y cuando estaba en Irlanda, me encanta esa sensación de estar a resguardo mientras escuchas el sonido de la lluvia. Me gusta poder ver a los enormes patos en el campus cómo van viviendo su vida tranquilamente sin que nadie les moleste, haciendo lo que les da la gana.

Pensaba que este artículo iba a ser algo más técnico, pero al final no quería volver a hablar de lo mismo de siempre, sólo que estamos usando Google Web Toolkit y tengo que decir que no está tan mal. :-P

Owncloud y Android

javaguirre — 2012-07-16T00:00:00+02:00

La semana pasada tuve un poco de tiempo para dedicarle a cosillas varias, todas centradas en OwnCloud y Android. Anteriormente estuve intentando rutear y cambiar el Sistema Operativo de un Samsung Galaxy S2 desde ArchLinux. Root fue facilísimo, pero cuando tuve que cambiar la imagen factoryfs.img con la aplicación heimdall, el proceso falló y la carga de Android se quedaba congelada. Al estar todavía operativo el modo Recovery y el Download, finalmente con la aplicación Odín en Windows pude arreglar el sistema y meter ICS, fue pan comido. :-)

Tras leer un artículo de mi amigo Edulix sobre sus ideas inspiradas por la Akademy, conocí OwnCloud, proyecto de la gente de KDE para tener tu propio Dropbox (sincronización de carpetas y WebDAV), además poder reproducir música y algunas golosinas más, hecho en PHP. El proyecto me pareció interesante desde el principio y no costó hacerlo funcionar sobre Nginx y php-fpm, no obstante no me ha convencido, tras estar una semana trasteando con él lo he borrado, tenía algunas cosas que no funcionaban para mí, y la verdad es que me da mucha pereza meterme a parchear código en PHP, ya conozco cómo es y prefiero pelearme con lenguajes que no conozco o que me gustan. No obstante es un servicio que llegará a estar realmente maduro pronto, está creciendo mucho y tienen planeada una release cada tres meses.

Con respecto a Android ahora que tengo algo de tiempo y me he comprado una ASUS TF300 me quiero meter en serio a hacer algo con él, tengo un par de ideas para practicar el desarrollo con Android y meterme un poco con Java. El primer proyecto va sobre traducción de documentos, el segundo un sencillo juego, a ver qué tal sale.

Emigro a Holanda

javaguirre — 2012-07-13T00:00:00+02:00

Llevaba unos meses barruntando la idea de irme fuera a trabajar. Me da la sensación de que ya no estaba aprendiendo todo lo que podría, y que mis prioridades iban cambiando, decantándome más por tener más tiempo libre para hacer más lo que me gusta y disfrutar más de proyectos personales y contribuciones a proyectos de Software Libre y no depender del propio proyecto en el que trabajo.

Ha sido esta la mejor etapa profesional sin duda, no sólo porque he trabajado con buenas personas, sino también porque a nivel profesional hay una calidad altísima, una gran experiencia y un cuidado por los detalles y de todos y cada uno de los integrantes del equipo pude aprender algo o mucho en función del trato que pude tener con ellos.

Sin embargo siempre hay cosas que crees que pueden mejorar, tanto a nivel personal como a nivel de empresa, y eso es lo que busco saliendo fuera de España y buscando la posibilidad de encontrar un trabajo más creativo y en el que tenga la posibilidad de liberar el software. Hay empresas muy interesantes en nuestro país en las que me habría encantado trabajar ahora, pero se me antoja muy atractivo ver cómo se trabaja más allá de los Pirineos. :-)

Conference Compass es una pequeña empresa de éxito que me ha dado la confianza para cambiar de tercio y aprender nuevas cosas y ganar calidad de vida más allá de Madrid.

Madrid es una gran ciudad, llena de posibilidades, pero ahora quiero probar otra cosa.

Primera semana de Julio

javaguirre — 2012-07-08T00:00:00+02:00

He pensado que ya que no voy a poder pisar la playa este verano (al menos no mis queridas playas del sur), que el fin de semana me sirva para aprovechar el tiempo.

Esta semana ha sido divertida, he empezado a usar tmux en serio, algo que llevaba tiempo queriendo hacer, y gracias a tmuxinator se han cumplido todas las expectativas que necesitaba (por ahora) para poder utilizarlo. Tuve que parchear un tema en tmuxinator(escrito en Ruby, curiosidad) para que tmux me forzase el uso de 256 colores en vim, por ahí algo estaba reescribiendo alguna variable, y aunque tuviese las variables de entorno correctamente configuradas como mandan los cánones, los colores no querían salir, así que metemos un tmux -2(forzando los 256 colores desde tmux) y a correr.

Tenía pensado también sacar una parte (parseador de tecnologías dada una url) de mi proyecto Sabrosous, no obstante habría que reescribirlo y el código era... como decirlo... un truño, así que investigué por ahí tener algo parecido para la consola y no tener que reinventar la rueda, encontré wappalyzer_rb. Es un port del plugin de Firefox/Chrome para descubrir las tecnologías de una web y escrito en Ruby, así que me puse manos a la obra, le faltan algunas cosillas, pero por ahora me sirve para continuar. Le envié un parchecillo al chaval para controlar algún error y hacerlo más amable (al programa, al chaval no lo conozco).

Rainbow, llevaba un mes queriendo hacer algo más para Rainbow, el coloreador de sintaxis liviano, y al final le pude dedicar un ratillo y sacar una primera versión que colorea el lenguaje Go (por ejemplo), por esta parte me gustaría añadir tests unitarios para este lenguaje y para el que hice anteriormente para Lua, lo tengo como TODO. :-)

Estuve investigando un poco cómo está MiniSub, el cliente de Subsonic, programa de streaming de música, tengo alguna idea apuntada que intentaré hacer en mi pocos ratos libres entre las tardes de esta semana y el finde que viene, entre ellas meter algunos tooltips, hacerlo más usable, que de eso le falta un poquillo.

Poco más, estamos organizando la pycon ES en Madrid y sería genial tener algo más de ayuda, de momento todo se está manejando en la lista de Python Madrid, pero se quiere mover a una lista concreta para que todo el mundo pueda contribuir desde un terreno más neutral. De momento se han concretado algunas cosas, y se está trabajando en otras, entre ellas el dossier de las conferencias, que aún está bastante verde. Si os interesa más el tema podéis apuntaros a la lista arriba enlazada.

Esto ha sido la semana, mañana comienza mi última semana en Gigas, y posteriormente moverme a lugares más frescos, a otros proyectos y quehaceres.

Primer día en Holanda

javaguirre — 2012-06-29T00:00:00+02:00

Todavía es de día en Delft, dentro de dos semanas mi ciudad de residencia por un año (al menos), y he de decir que ha sido un día perfecto. Estoy realmente contento y feliz de poder venir a esta ciudad tan bonita, agradable y hogareña.

Nada más llegar hemos conocido a mis futuros (en dos semanas) compañeros de trabajo, y nos han arropado muy amablemente en todo lo que hemos tenido que hacer hoy(incluida visita a Rotterdam de mi novia, que finalmente ha conseguido trabajo en un estudio de esta ciudad).

El complejo en el que voy a trabajar de aquí a dos semanas es una antigua nave industrial con espacios reconvertidos a salas con sofás ¡e incluso un futbolín!, con vistas al verde que aquí es muy común, y muy cerca de la Universidad Tecnológica de Delft, una especie de jaula de startups.

El día empezaba nuboso pero finalmente se ha abierto y el centro de Delft era un bullicio de gente de muchas nacionalidades, estudiantes y gente autóctona y de otras culturas que han salido a tomarse una cerveza. Mi impresión de esta ciudad es todo positiva, una ciudad tranquila, alegre y en la que la gente vive a otro ritmo, disfrutando quizás más de las cosas en su día a día, algo que realmente buscaba con este cambio además de otras cosas.

El domingo vuelvo para Madrid para mis últimas dos semanas de trabajo en Gigas, pero si os digo la verdad yo me quedaría ya en esta bonita ciudad de canales. :-)

New web changes, github and twitter plugins

javaguirre — 2012-06-22T00:00:00+02:00

Well, they are more code snippets than plugins, but it was easy to integrate it inside my static web blog, using just JSONP calls. I think the Twitter API I'm using could be deprecated soon, but it worked for me by now, so it stays as is for a few time. I will separate the two elements (twitter/github plugins) from the default view just to make easier the copy and tweak of this code in your jekyll projects.

I'm using basic jQuery in this example, so it shouldn't be difficult to get it working in your service even if you don't have much javascript background.

For twitter syntax highlighter I've reused a function I did for Sabrosous and it worked pretty well. :-)

I've also modified some things from the tag_list page, I think there were too much tags so I've limited the list to tags that has more than a post linked.

I'm really happy for the change from Wordpress to Jekyll, I love Git and now I manage every part of the content from a Git repository, really cool and easy. :-)

From Wordpress To Jekyll

javaguirre — 2012-05-25T00:00:00+02:00

Yesterday I knew about jekyll, I have been testing and using pelican for a while in development mode but some things didn't fit my blog needs. Jekyll is a static pages generator, so you can write your posts in almost any kind of markdown syntax, and then running jekyll command it builds your web application (in my case, a blog).

Lucky me, it has a wider community than pelican, so I decided to give it a try. In a few time I had my old blog content migrated thanks to the WordpressDotCom plugin contained in the jekyll app, and a great responsive design thanks to the jekyll-bootstrap project.

Now, I don't have to maintain a database neither worry about security issues concerning wordpress, a git repository at github is my database, how nice and secure for me. :-)

You could also have some plugins to build functionality when you run jekyll. I have used a plugin for related posts using your own tags.

Jekyll is written in Ruby, language that I like, so I could tweak it to my needs easily if I have to. I also have the deployment solved just adding a new remote repository to my local copy and a bare repo inside my server, it's a win-win. :-)

To serve the static content I just use Nginx.

You have all the documentation needed to get it working in the links above.

Centralised tests with Selenium, Flask, and Bootstrap

javaguirre — 2012-05-22T00:00:00+02:00

In Gigas, we started to have tests soon using Selenium, having spreadsheet files where we put descriptions about tests suites and some html files we use to execute with the great Selenium Firefox Plugin. Later we write manually the tests results in the spreadsheet file and we share it with the others.

That's over, We have started a web service using the Flask framework and the cool Twitter Bootstrap design with some Glyphicons. It also uses the Flask-Login extension for authentication and a couple of pickle files to store some persistent data we need.

The process is the following: We record and write some asserts and verifies commands using the Firefox Selenium Plugin, then we can upload it to this new web service. The service executes in the background the selenium standalone server with the htmlSuite option using python subprocess. This could be an example of the command:


java -jar /usr/share/selenium-server/selenium-server-standalone.jar -htmlSuite https://dev.gigas.local ./test_suites/04-0002.01-20120507.html results.html

It stores the result in a html file, we parse it and return the Ajax response in JSON to show them. To execute Firefox without using the X server, we do it on Xvfb, a virtual X server that doesn't show the graphical output. This is an example of the first version, I recorded it last thursday. :-)

References:

Raequel, scraping en la web de la rae con app engine

javaguirre — 2012-05-14T00:00:00+02:00

La semana pasada me enteré de que DuckDuckGo te permitía implementar plugins que luego ellos testean e introducen en la plataforma (DuckDuckHack), me pareció que podía ser muy divertido. :-)

Tras pensar varias cosas y ver cómo se podía implementar el plugin, estuve investigando por ahí y me pareció buena idea hacer un plugin que buscase en la RAE la palabra buscada y devolviese las acepciones de ésta.

En Github encontré a una persona que había hecho scraping sobre la web de la RAE y con el SDK de Python para Google App Engine había creado una API, este fue mi punto de partida. :-)

Leyendo el código y probándolo me di cuenta de que necesitaba por el momento un par de cosas por implementar, una era que la API debía ser JSONP, y otra que las peticiones debían responder más rápido.

La primera solución fue muy sencilla, simplemente añadir un par de cabeceras:


self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.headers['Access-Control-Allow-Methods'] = 'GET'

La segunda también resultó muy sencilla, ya que el SDK de Google App Engine dispone de una biblioteca para memcache, bastó añadir esa funcionalidad a la petición JSON/JSONP y listo.

Ahora toca la parte de DuckDuckGo, hará falta tiempo para ello, el proyecto está en Github.

Using Aspen

javaguirre — 2012-05-10T00:00:00+02:00

Aspen is a python web framework based in the filesystem, mixing controller and view in the same archive, it's called a Simplate.

We had some static html files in production, but months later we needed to add some server logic to this ones, without changing any url and having it integrated fast in our actual environment. These conditions make us think in this framework, it is perfect for this kind of situation, we hadn't to change our actual filesystem for our html files and we could have easily integrated this new logic inside them. :-)

Our main problem using aspen is the lack of documentation, in my opinion is really poor and it could explain more and better basic things, such as requests handling. Anyway, I like to explore the code but sometimes you don't want to spend some time in it when you have to get things done.

I have been using Django and Flask and I could say I found basics less intuitive in aspen than the others. I will try to explain what I meant in a later post when I get deeper in it.

Evolución

javaguirre — 2012-05-08T00:00:00+02:00

En la última reunión de python-madrid argumenté por qué me parecía que el Software libre, o mejor dicho su comunidad es una evolución en la vida del desarrollador corriente.

No hablaba de evolución con respecto al software propietario sino con respecto a uno mismo, en mi caso hablaba de mi experiencia. Son unos cuantos años los que llevo dedicando a mi pasión, que es el desarrollo de software y es un camino muy fácil pero a a la vez muy complejo.

¿Por qué? En ocasiones somos los reyes del mundo o Neo en Matrix, creo que siempre que se empieza a ser productivo en el desarrollo te sientes un poco orgulloso, hasta que cada día te das cuenta que hay mucha gente mejor que tú en muchas cosas pero que tu contribución es importante porque somos un equipo, y que la humildad te hace más fuerte.

He estado intentando sacar proyectos personales, software libre, pero proyectos que al final quedan en la cuneta por la simple cuestión de que no hay comunidad y de que vuelvo a inventar la rueda, sino del todo, sí en gran parte.

Hace muy poco decidí no centrarme en éstos, sino en los que me interesan, dedicando tiempo a proyectos que habían resuelto alguno de los problemas que yo quería volver a resolver, y comenzar contribuyendo en éstos. Lo sé, sonará a tontería ya que de esto va el Software Libre, pero hasta este momento no había visto la luz y la verdad es que ahora todo es mucho más divertido.

Ese abrirse más al mundo es para mí el Software Libre, y Github facilita las cosas muchísimo, he decidido pasar a ser un Doer. :-)

Lua Highlighter for Rainbow

javaguirre — 2012-04-29T00:00:00+02:00

I've been studying an Udacity course to build your own web browser(CS262), it's a great way to learn some things quicker and funnier than expected, and time is gold in this world of ours. :-)

These first chapters were easier, we were practising regexp a lot, so I decided to contribute to rainbow.js project, adding some highlight patterns for lua language.

You can look for this awesome js plugin in its webpage and at github.

Usando Subsonic y MiniSub

javaguirre — 2012-04-22T00:00:00+02:00

Tras una semana para probar Subsonic tengo que decir que estoy encantado, facilita sobremanera el control de la música en mi casa y pronto desde fuera. :-)

Mi servidor subsonic es un ArchLinux, hay un buen tutorial para empezar en la wiki de Arch para no lanzar subsonic como root aunque hay un par de cosas a tener en cuenta para sacar todo de este servidor de música.

Es necesario instalar lame y ffmpeg, ya que subsonic los usa por debajo.


pacman -S lame ffmpeg

Posteriormente necesitamos hacer un enlace simbólico al directorio /var/subsonic/transcode para que subsonic los pille.


cd /var/subsonic/transcode
ln -s /usr/bin/lame
ln -s /usr/bin/ffmpeg

Subsonic tiene además una API para construir tu propio cliente, aunque echo de menos a primera vista la posibilidad de gestionar los llamados players.

Hay algún cliente para Subsonic por ahí en construcción, uno de ellos es MiniSub, hecho en javascript usando la API de subsonic vía JSONP, le falta un poco de estabilidad y de organización en el código, pero tiene buena pinta.

M2Crypto from pip in old GNU/Linux OS

javaguirre — 2012-04-19T00:00:00+02:00

We had a problem today with M2Crypto package from pip repository in a CentOS server.


... Error: Unable to find 'opensslconf-x86_64.h'

The actual version in pip repositories is 0.21.1, but the setup.py file doesn't search for the correct headers in this version of CentOS 5.5 (It's old, I know :-) ).

There's an easy workaround to get it working, I found it in a Zenoss community thread, you can just add a new path to search for files to self.swig_opts list.

First, we can download it from pip, and modify the setup.py file.


pip install -d . M2Crypto==0.21.1
untar M2Crypto-0.21.1.tar.gz

BEFORE


#LINE 58
self.swig_opts = ['-I%s' % i for i in self.include_dirs + \                                                                                  
                 [opensslIncludeDir]]
self.swig_opts.append('-includeall')

AFTER


self.swig_opts = ['-I%s' % i for i in self.include_dirs + \                                                                                  
                 [opensslIncludeDir]]
self.swig_opts.append('-includeall')
self.swig_opts.append('-I/usr/include/openssl')

Then running python setup.py install might do the trick.

Installing BrowserQuest

javaguirre — 2012-04-18T00:00:00+02:00

It's been a while since Mozilla released BrowserQuest, a game built on nodejs with WebSockets. I love this retro style given to the game, I've always wanted to do that kind of game and now is a good chance to hack a popular game project and have some fun with it! :-) Mozilla released the code in Github, but there are some cool stuff they couldn't release yet, I hope they do it soon to create some new worlds easily. I followed this two excellent sources from Dirk Krause to get it running in local or anywhere, but I think some novice people are still a bit confused about how to do it, so I will try to clarify just a couple things, you will need the instructions from Dirk anyway. Getting the code from Github, the easiest way to get the client running is copying the shared directory inside the client one, executing it with http-server as explained before.


$ cd client
$ cp -r ../shared .
$ http-server
 
Starting up http-server, serving ./ on port: 8080
Hit CTRL-C to stop the server

Now you can go to your browser to see it running. If you click play nothing happens, we need to start the server.


$ node server/js/main.js

[Wed Apr 18 2012 20:52:46 GMT+0200 (CEST)] INFO Starting BrowserQuest game server...
[Wed Apr 18 2012 20:52:46 GMT+0200 (CEST)] INFO world1 created (capacity: 200 players).
[Wed Apr 18 2012 20:52:46 GMT+0200 (CEST)] INFO Server is listening on port 8000

You could modify client and server ports in the config_local.json file, inside both directories (client and server), but using this approach (http-server module) is not neccessary to change client's port. Server will search for config in two places:


var defaultConfigPath = './server/config.json',                                                                                                 
    customConfigPath = './server/config_local.json';

There is a config.json by default, binding the server to port 8000, so if you don't care about ports by now there's nothing to worry about. That's it, have fun!

From Wordpress to Obtvse, rake task

javaguirre — 2012-04-17T00:00:00+02:00

Obtvse is a minimalist blog, made simple and built on Rails. I like minimalism, so I wanted to test and do something with it. I worked in a rake task to just migrate my actual posts to this new platform. To make it work there's only a few steps needed. In your Gemfile you need to put...


gem "mysql"

Then add an environment to your config/database.yml


wordpress:
  adapter: mysql
  encoding: utf8
  database: obtvse_example
  username: my_user
  password: my_pass
  host: localhost

Finally you could call it from the command line...


rake wordpress:migrate_wordpress[source_db, destiny_db]

Where source_db is your Wordpress db in the database.yml file, and destiny_db is the Obtvse one. The code is not a big deal, just a few lines. I know It could be a better implementation, but is my first rake task, I would like some feedback. :-)


# -*- coding:utf-8 -*-                                                                                                                              
# Usage rake wordpress:migrate_wordpress[:src, :dst]
# You will need gem "mysql" in your Gemfile
namespace :wordpress do
    task :migrate_wordpress, [:src, :dst] => :environment do |cmd, args|
        args.with_defaults(:src => "wordpress", :dst => "development")
        config = Rails.configuration.database_configuration
        src_db = config[args[:src]]
        dst_db = config[args[:dst]]

        conn = ActiveRecord::Base.establish_connection src_db
        posts = conn.connection.execute "SELECT * FROM wp_posts where post_status='draft' or post_status='publish'"

        conn = ActiveRecord::Base.establish_connection dst_db

        posts.each do |post|
            title = post[5].force_encoding 'utf-8'
            content = post[4].force_encoding 'utf-8'
            created_at = post[2]
            updated_at = post[14]
            draft = post[7]

            if draft.end_with? "draft"
                draft_flag = true
            elsif draft.end_with? "publish"
                draft_flag = false
            end

            p = Post.create! :title => title, :content => content, :slug => Post.acts_as_url(:title, :url_attribute => :slug),
                             :created_at => created_at, :updated_at => updated_at, :draft => draft_flag
        end
    end
end

Servidor de música con Subsonic

javaguirre — 2012-04-16T00:00:00+02:00

Un servidor para todo, para tener música en tu Android por streaming, para tener en casa en cualquier portátil, y para poder manejar la música en el servidor remoto como si fuese nuestra "minicadena" (qué antiguo soy :-P), todo eso lo tenemos con Subsonic, un proyecto de Software Libre hecho en Java. Subsonic nos provee de un servicio web desde el cual podemos gestionar la música de un servidor, gestión de usuarios y distintos players por usuario. Los players son los distintos dispositivos de un usuario, un player podría ser un móvil android, otro podría ser el portátil, y otro podría ser cambiar música remotamente en el propio servidor. Este fin de semana he estado instalándolo en casa y estoy encantado, a falta de tunear mi router, que me está dando algunos problemas, estoy contento por lo rápido que funciona y todas las posibilidades que te da, entre ellas el poder subir nueva música al servidor muy fácilmente y unas cuantas cosillas más. También comentar que tiene aplicación nativa para Android, y que funciona muy bien, aunque me falta la posibilidad de conexión a un player remoto, algo que se puede hacer accediendo vía navegador. En un siguiente artículo explicaré cómo lo monté, aunque creo que es bastante sencillo para cualquiera que estudie un poquito.

Mejoras en Openboe

javaguirre — 2012-04-01T00:00:00+02:00

Hoy he estado trabajando en OpenBOE, el servicio que pretende dar la información de los RSS del BOE/Borme de una forma sencilla y por la que se pueda filtrar.

Hasta el momento no había casi nada, era un parseador de RSS que buscaba directamente en los enlaces que proveía ese RSS y daba un resultado según el filtro, todo ha cambiado.

Actualmente OpenBOE consta de dos scripts que se ejecutan sobre cron. Uno hace scraping sobre la web del boe donde se ubican los rss y los organiza por categorías, guardándolos en una base de datos en MongoDB. El segundo simplemente itera sobre los RSS y cada hora actualiza la lista de publicaciones nuevas en la base de datos.

Debido a toda esta automatización y al incluir la base de datos en Mongo, los controladores han sido modificados completamente. Quizás sería necesario quitar un par de líneas duplicadas que existen en los controladores y sacarlo a un plano superior del que estas vistas heredasen, por el momento no me lo planteo, quizás para la primera versión de OpenBOE que sacaré en un par de semanas.

Todo esto va construido sobre Flask, un framework al que tenía ganas de meter mano y se ejecuta sobre un Nginx con uWSGI.

Tenéis el código en github tanto si queréis tocarlo, criticarme (constructivamente), para nuevas ideas o para lo que queráis. :-)

Ducksboard Python module

javaguirre — 2012-04-01T00:00:00+02:00

I've done a very simple package to wrap Ducksboard API and uploaded it to Python Packages, it's my first Python package there so I'm excited. :-)

There are some things to improve in it, but it does everything you can do right now with this API.

Here is an example of code that makes succeeded requests.


#!/usr/bin/python                                                                                                                                    
                                                                                                                                                     
from ducksboard.ducksboard import Ducksboard                                                                                                         
import time                                                                                                                                          
                                                                                                                                                     
                                                                                                                                                     
MYAPIKEY = 'MYAPIKEY'                                                                                                                                        
ENDPOINT = 'gauge1'                                                                                                                                        
                                                                                                                                                     
d = Ducksboard(MYAPIKEY, ENDPOINT)                                                                                                                   

#Updates a Gauge                                                                                                                                                     
d.gauge(0.22)                                                                                                                                        

#Updates the counter                                                                                                                                                     
d.endpoint = 12317                                                                                                                                   
d.counter(22)                                                                                                                                        

#Graph                                                                                                                                                     
d.endpoint = 334                                                                                                                                      
d.graph([{"timestamp": 1299854684, "value": 10 },
         {"timestamp": 1299855600, "value": 40}])                                                           

                                                                                                                                      
d.endpoint = 1123                                                                                                                                    
d.image(image="https://dashboard.ducksboard.com/static/img/timeline/red.gif",
        caption="content")                                                                   
                                                                                                                                                     
d.endpoint = 1236                                                                                                                                
d.timeline(title="Bye", content="world",
           image="https://dashboard.ducksboard.com/static/img/timeline/red.gif",
           link="http://ducksboard.com")

I have to improve documentation and upload the example with the package, one step at a time. :-)

If you want to improve the library, found a bug or you just have an idea, you can contact me here or check for the code in Github.

Play framework in ArchLinux

javaguirre — 2012-03-26T00:00:00+02:00

I had a little problem when installing today Play! framework in ArchLinux.

Doing a strace I realized what happened:


rt_sigaction(SIGINT, {0x438d50, [], SA_RESTORER, 0x7f79584319f0}, {SIG_DFL, [], SA_RESTORER, 0x7f79584319f0}, 8) = 0
wait4(-1, java.io.FileNotFoundException: /opt/play-framework/framework/sbt/boot/sbt.boot.lock (Permission denied)
	at java.io.FileOutputStream.open(Native Method)
	at java.io.FileOutputStream.(FileOutputStream.java:212)
	at java.io.FileOutputStream.(FileOutputStream.java:165)
        ...

So You could just give permissions to that file...


sudo chmod 666 /opt/play-framework/framework/sbt/boot/sbt.boot.lock

You could have the same problem when creating the project, the bad solution is using sudo to create it, the good one is giving permissions to play-framework directory to create the project with the correct ones.

And that's all! Happy coding! :-)

Codemotion: Impresiones

javaguirre — 2012-03-26T00:00:00+02:00

Excelente evento, es lo primero que pienso del Codemotion que tuvo lugar este sábado en Madrid. Ponencias de mucha calidad a las que tuve la posibilidad de asistir con los compañeros de Python Madrid y con amigos de la Carlos III, haciendo piña. :-)

En especial querría reseñar las charlas de Sergio Gil, Juan Riaza y JJ Merelo, las tres de una gran calidad tanto técnica como humana, nos mostraron temas muy interesantes y de una forma amena y divertida, como debe ser. :-)

La charla de David Bonilla me pareció inspiradora, pero siendo yo más un animal de código me quedo con las anteriores.

Con respecto a mi charla salió mejor de lo que esperaba ya que no tuve apenas tiempo para prepararla, así que quedo con ganas de hacer una mejor en la próxima oportunidad que surja.

Finalmente en el Codemotion pudimos disfrutar de 4 charlas de Python, Openstack, Web Scraping, Evolución de python(python3), Android con Python.

También muy contento por encontrarme con compañeros a los que aprecio, y por conocer a mucha gente agradable con la que espero cruzarme de nuevo pronto. :-)

Muy buen evento y esperando que el año que viene se pueda repetir.

vundle and plugins for vim

javaguirre — 2012-03-18T00:00:00+01:00

Since I've discovered vundle for vim via my good friend Miguel I'm delighted because of its power.

You install vundle in your .vim directory and then just have to put lines with this format to install a plugin with :BundleInstall. These lines are git repositories in github or in any other place.


Bundle 'user/project'

or just


Bundle 'git_url'

We've also discovered powerful plugins which improve the power of Vim even more. :-D

I've just started using Syntastic, a great syntax checker for code, solarized and jellybeans, very good colourschemes, and finally powerline, very intuitive status bar.

By now I've installed more plugins, fugitive(for git), ack and command-t, but I have to use them in depth to talk about them.

If you love vim you should try it! If you know something better or some astonishing plugins please let me know!

My new part in .vimrc for vundle:


"vundle
set nocompatible
filetype off

set rtp+=~/.vim/bundle/vundle/
call vundle#rc()

Bundle 'gmarik/vundle'
Bundle 'Lokaltog/vim-powerline'
Bundle 'nanotech/jellybeans.vim'
Bundle 'altercation/vim-colors-solarized'
Bundle 'tpope/vim-fugitive'
Bundle 'mileszs/ack.vim'
Bundle 'scrooloose/syntastic'
Bundle 'git://git.wincent.com/command-t.git'

filetype plugin on
filetype plugin indent on

Charla de Git y de Videojuegos en javascript

javaguirre — 2012-03-15T00:00:00+01:00

He añadido ambas presentaciones a la zona de charlas, espero que puedan servir a alguien.

Como siempre agradecer a la gente del GUL de la Universidad Carlos III la posibilidad de impartir las charlas, lo pasamos muy bien y nos llena de satisfacción que haya podido servir a alguien para aprender algunos conceptos.

Nota: Faltan algunas imágenes que añadiré pronto.

Git y videojuegos en los cursos del GUL

javaguirre — 2012-03-12T00:00:00+01:00

Mañana volveré a participar en los cursos del Gul, ya tengo ganas. :-)

Esta semana han comenzado los cursos de Marzo, unas jornadas para aprender e interesarse por las tecnologías del momento de la mano de gente experimentada e inquieta.

Hemos preparado dos charlas creo que muy interesantes, la primera será de las 16 a las 18 horas, Taller de videojuegos en Javascript con Craftyjs, la segunda será Introducción a Git y Github.

He podido participar en la preparación de ambas presentaciones activamente, desgraciadamente debido a la cantidad de trabajo que tengo últimamente sólo voy a poder participar en la de Git y Github.

En el taller de videojuegos Israel pasará primero por la teoría que sostiene los videojuegos hoy en día (jerarquías vs. Entidades/componentes) y mostrará todos los componentes de distintos tipos de juego así como muchos ejemplos para empezar a programar nada más salir del taller. :-)

En la de Git hemos preparado una charla completamente práctica, Miguel y yo compartiremos un repositorio en Github, una pequeña aplicación web, e iremos mostrando todos los pasos y comandos del desarrollo en grupo con Git. Acabaremos haciendo el despliegue de la aplicación ejemplo de la charla en la increíble plataforma heroku, con la única ayuda de un paquete (gema de Heroku) y de nuestro repositorio Git del proyecto.

Al acabar las presentaciones colgaré éstas en mi página de presentaciones.

Magic with Python, getattr and eval

javaguirre — 2012-03-06T00:00:00+01:00

We have a Django project with the admin module to manage our models, some of them have an action to export model objects as CSV.

What if we want to generate a report and attach it to an email to send it once a week? Easy with Python and Django! :-)


from django.core.management import setup_environ
import os
import sys
path = os.path.dirname(__file__).replace("cron", "")
if not path in sys.path:
    sys.path.append(path)

In my case the script has to be executed outside django itself, that lines add scripts path ("cron") into python path and keeps django project environment available to access to its classes.


user = User.objects.all()[0]
report_list = ['Account', 'Order', 'Invoice']
request = HttpRequest()
request.user = user

email = EmailMessage('My report', 'Hi you! heres your report', 'example@example.com',
            ['doe@example.com', 'john@example.com'])

for report in report_list:
    model = eval(report)
    modeladmin = eval(report + "Admin")

    o = modeladmin(model, "")
    report_data = getattr(modeladmin, 'export_as_csv')(o, request, model.objects.all())
    email.attach("%ss.csv" % report.lower(), report_data, 'text/csv')

email.send()

I like to follow conventions, if you do you'll be grateful later like me. In this example we have some models ('Account', 'Order', 'Invoice') and its Admin classes ('AccountAdmin', 'OrderAdmin', 'InvoiceAdmin'), inside them an "export_as_csv" method which it's used to generate our report.

We can also use elements of the list to access models with eval(string), evaluating the string as a Python expression, so we get the class name of the Model and the ModelAdmin.

Finally we get the corresponding method of different Admin models passing a HttpRequest, and a User object (we need that in our example) to emulate the original export_as_csv admin method.

Then we can attach all files to the email and send it. :-)

Second week in the saas-class

javaguirre — 2012-03-03T00:00:00+01:00

I've finished the first assignment! Yesterday I had a score of 82/500, but today having enough time to complete everything I get 500/500. :-)

The exercises were easy but I took some time to refresh some things like binary trees search with recursion and more stuff. This first assignment was a perfect start with Ruby, five different exercises that explore different parts of the language.

I prefer the fifth one, because we entered in the magic of classes in Ruby and that's always fun in all languages! it consists in building an attribute of a class with history that tracks old values of an attribute of that class, we have to write a method inside Class class to do it.

Next week we will start with Ruby On Rails, the MVC Web Framework.

I was thinking in some web service that I could need to build it with Ruby on Rails, just to learn and practice for the next week of the course. Could be interesting for me a place to store that code snippets I use, and tag them so I could search for them later, I think I'll do that.

Next week I'll share the most interesting exercises of the assignment. :-)

First week saas-class

javaguirre — 2012-02-26T00:00:00+01:00

I've been studying hard this weekend to keep on track with Video lecture releases of Saas course. I've also started learning Ruby, and I'm happy for doing it, I'm impressed with the verbosity of the language, if you build good code it's very straight forward to understand. :-)

I finished some parts of the first assignment but some of them need to be refactored to improve conciseness.

First conclussions of the language comparing with Python, in Ruby everything is a method, and in a function the last statement is what you return, you don't need to use the reserved word return. I was surprised because zero and empty arrays are true in conditional statements, but I supposed you get used to that processing in a different way that kind of situations.

You can call a function without parentheses and you can remove more unuseful characters sometimes. Although in Python is different, when you write the name of the function you get a function object, in Ruby you get the result of the execution of that function.

I'll show you the first part of the assignment to understand my points if you haven't study any ruby code.


=begin
    Part1 of the first asignment @javaguirre
=end

def palyndrome?(string)
    string.downcase.gsub(/[^\w+]/, "") == string.downcase.reverse.gsub(/[^\w+]/, "")
end

def count_words(string)
    result = {}
    string.downcase.gsub(/[^\w+]/, " ").split(" ").each do |word|

        if result[word].nil?
            result[word] = 1
        else
            result[word] += 1
        end
    end
    puts "count_words #{string} # => #{result}"
end

puts palyndrome? "A man, a plan, a canal --- Panama"
puts palyndrome? "Madam, I'm Adam!"
puts palyndrome? "Abracadabra"
puts count_words "A man, a plan, a canal --- Panama"

I will try to post a more detailed article about my Ruby learning and Saas class soon!

Cursos del GUL en Marzo de 2012

javaguirre — 2012-02-25T00:00:00+01:00

¡Ya está disponible el calendario de las jornadas del GUL de Marzo! Es la cuarta vez que participo en los cursos y como siempre estoy muy contento de poder contribuir con mi granito de arena.

Después de que en Noviembre no pudiese hacer charlas muy elaboradas, en esta ocasión hemos decidido hacer un par de charlas por parejas para tener unas presentaciones más completas y esperemos que didácticas.

Ambas serán el día 13 de Marzo, la primera será un sencillo Taller de videojuegos con una biblioteca en desarrollo llamada Crafty, que permite fácilmente comenzar a hacer juegos web. Realizaremos esta charla conjuntamente Israel Gutiérrez y yo, un placer. :-)

A partir de las 6 introduciremos Git como Control de versiones y el servicio Github para empezar a subir el código, mi amigo Miguel, que me acompañará en esta charla propuso que nos centrásemos en explicar cómo comenzar a trabajar en grupo en Git, un concepto para los que empiezan con control de versiones algo complejo, pero que intentaremos hacer sencillo.

Espero que podáis pasaros a las charlas de los cursos del GUL en la Carlos III, campus de Leganés, una semana en la que aprender de gente experimentada sobre distintas temáticas técnicas actuales.

Google Apps Script Hackathon en la UPM

javaguirre — 2012-02-22T00:00:00+01:00

Ayer tuvo lugar la hackathon de Google Apps Script en la UPM.

Un evento bien organizado y en el que tuve la oportunidad de aprender una tecnología de Google desconocida para mí.

Google Apps Script podría decirse que es el Visual Basic del scripting en MS Office, solo que en este caso se realiza en Javascript y permite acceder a otros servicios desde Docs, como Calendar, Maps, o hacer peticiones http con la clase UrlFetch.

Lo veo práctico, pero actualmente al no usar docs no le veo nada que me haga más fácil mi vida diaria.

Al final del evento los ganadores del hackathon se llevaron un flamante Chromebook cada uno, y los demás fuimos felices con la pizza y la cerveza. :-)

Curso Online de Software as a Service

javaguirre — 2012-02-19T00:00:00+01:00

Mañana comienza oficialmente el curso de Software as a Service, que se engloba en los cursos online que han preparado diversas universidades estadounidenses de prestigio.

Ya han colgado los primeros videos en la web, y han trabajado en un libro para el curso que estoy empezando a leer, creo que dedicarle un tiempo cada día a este curso me aportará cosas interesantes.

Los ejemplos del curso serán desarrollados en Ruby y Rails, así que tendré la excusa perfecta para sumergirme en un lenguaje y una tecnología nuevos para mí.

Animo a todo el que quiera aprender a que se interese por alguno de los cursos que han preparado, creo que es una oportunidad única de escuchar a estudiosos del sector.

TornadIO2

javaguirre — 2012-02-13T00:00:00+01:00

Un módulo en Python que implementa la biblioteca socket.io sobre Tornado para realizar aplicaciones que se actualicen en tiempo real.

Funciona en cualquier navegador moderno, incluido Internet Explorer, ya que el módulo se adapta al navegador cliente con el protocolo disponible que mejor funcione para éste.

Entre los distintos protocolos que implementa socket.io se encuentran Websockets, flashsocket, htmlfile (para explorer), distintas soluciones xhr, y alguna más que podéis ver en el repositorio de Tornadio.

Si alguna vez has usado Tornado se integra perfectamente en sus Handlers y sus Sockets, así que no tendrás ningún problema en la implementación de esta solución. También gracias a los ejemplos en su repositorio, que dan una idea muy buena de lo que es capaz este módulo con pocas líneas de código. :-)

Espero tener un ejemplo interesante que mostrar la próxima vez.

Finde productivo

javaguirre — 2012-02-12T00:00:00+01:00

Este fin de semana me he dedicado a arreglar unos cuantos temas del blog, he añadido tres plugins que mejoran bastante la web, el WP super cache, Disqus comments y Mobile Pack, así que ahora será más sencillo verlo desde el móvil. :-)

Este finde quería dedicarme casi íntegramente a Sabrosous y la verdad es que donde otras veces no consigo arreglar tantas cosas como querría esta vez he conseguido muchos progresos en poco tiempo, aunque aún hay algunas cosillas que mejorar antes de lanzar la beta.

En otro término de cosas, esta semana ha sido la reunión mensual de Python Madrid, con algunos temas muy interesantes y en las oficinas de Tuenti, a la que nunca había tenido la oportunidad de ir.

En el trabajo he estado jugando con sockets e hilos en Python, espero poder hacer algún tutorial sobre este tema y alguno sobre Javascript, al que le estoy dedicando mucho tiempo libre. ;-)

Nota: He encontrado una herramienta de monitorización de servidores muy interesante hecha en Python sobre Tornado, pero aún no he tenido la oportunidad de probarla, a ver si esta semana le dedico algo de tiempo.

Con ganas de Javascript

javaguirre — 2012-02-08T00:00:00+01:00

Ocasionalmente he hecho cosas más grandes en Javascript que efectillos con jQuery o llamadas vía AJAX, pero hasta hace poco no tenía tiempo para preguntarme ¿cómo se hace una clase de la manera correcta en este lenguaje? ¿cómo plantear la organización del código de una manera correcta?

El problema general en Javascript en cliente es que se hace mucho copiar y pegar, y se juega mucho con el "simplemente funciona".

Me gusta Javascript por muchas razones, y ahora que dedico algo de mi tiempo libre al desarrollo en este lenguaje me gustaría aprender de verdad un porcentaje alto de éste, es uno de mis propósitos en estos próximos meses.

Mi primer proyecto Javascript de la nueva era será una pequeña Introducción a Crafty, el framework de videojuegos, algo que me atrae mucho. :-)

Sabrosous se reinventa en estilos

javaguirre — 2012-02-06T00:00:00+01:00

Manu ha trabajado en un nuevo diseño muy interesante, así que hemos decidido cambiar completamente los estilos de Sabrosous e implementar alguna cosa más antes de la salida en beta.

El estilo actual de Sabrosous se había ido quedando anticuado en este último año, estoy seguro de que este diseño es más usable que el anterior.

Espero que de aquí a un mes tengamos una primera versión usable y en beta para que se pueda ir usando, yo creo que no andamos desencaminados, aunque quizás sean dos meses.

Aún hay que pensar en las funcionalidades finales para esa beta, pero el camino será mejorar el parseador de html y la usabilidad de las entradas de twitter y rss.

Charlas, nuevo apartado de la web

javaguirre — 2012-02-04T00:00:00+01:00

He creado un nuevo apartado en la web, charlas, donde iré colgando las presentaciones que voy haciendo. Desde que me baso en la presentación html que tiene colgada la gente de Google en GoogleCode todo me resulta más sencillo en estos temas (nunca me han gustado las aplicaciones tipo Impress/Powerpoint, no me preguntéis por qué :-P).

Este apartado nuevo de la web es un nginx con el autoindex activo y alguna pequeña personalización más, cada día me gusta más nginx. :-)

Cursos GUL en Marzo de 2012

javaguirre — 2012-02-02T00:00:00+01:00

Marzo vuelve a estar cerca y con él vuelve la semana de cursos del GUL. :-)

Esta vez lo he pillado con mucha más antelación así que desde ya estoy empezando a preparar los temas, que luego pasan las semanas y no hay tiempo para nada.

Siempre he querido aprender a hacer videojuegos, es una de esas cosas que siempre he dejado de lado. Afortunadamente ahora es más sencillo empezar a desarrollar juegos con alguna biblioteca Javascript, y el usuario no necesita instalarse nada extra.

Así que este Marzo he decidido proponer una charla sobre videojuegos usando la biblioteca en desarrollo Crafty. Llevo siguiendo el repo escasos días, y lo que he visto ha sido código mejorable y también mucho movimiento de desarrollo.

Me gusta mucho el paradigma de entidades y componentes que están desarrollando, muy sencillo y te permite hacer cosas complejas en pocas líneas de código, y mucha facilidad para reutilizar código.

También hemos decidido proponer una charla sobre Git y Github. Mi amigo Miguel y yo nos hemos animado mutuamente para proponer esta charla que ya en anteriores ediciones se quedó en el tintero.

A falta de saber qué charlas serán las más votadas seguiremos preparándolas, y aunque no sea esta vez cuando la realicemos, aprender cosas nuevas y profundizar en otras que conocemos bien siempre es divertido. :-)

Wappalyzer detecta Python y Django

javaguirre — 2012-01-29T00:00:00+01:00

Seguro que más de uno conoce esa maravillosa e interesante herramienta que es Wappalyzer, un detector de frameworks, servidores y tecnologías en las que está construido un servicio web para Firefox/Chrome, aunque la versión de Firefox está mucho más avanzada.

La semana pasada introdujeron la funcionalidad de detectar Python/Django, con bastante truco. :-)

En ambos casos (Python/Django) intenta detectar un script csrf y un Powered by Django en el html, en caso de que exista implicará que es Django, y por tanto Python.

Una jugada muy buena y una actualización más de esta gran herramienta para el curioso desarrollador. :-)

Configurando Nginx

javaguirre — 2012-01-29T00:00:00+01:00

Había estado ya bastante tiempo escuchando a la gente que estaba usando Nginx para sus entornos de producción con Django, y tras leer la semana pasada un poco configuraciones de Nginx, me encantó. :-)

Me gusta mucho su limpia sintaxis, acostumbrado a la de Apache la verdad es que ha sido un alivio para mí. No soy mucho de temas de administración de sistemas, en general aprendo lo que necesito, pero en este caso me apetecía meterle caña a Nginx y cambiar mis configuraciones por algo más agradable y que consumiese menos recursos.

Estoy apenas en el capítulo 3 del libro Nginx 1 Web Server Implementation Cookbook pero ya he hecho conseguido cambiar casi toda mi configuración básica, y todo va muy bien. :-)

No obstante aún me tengo que quitar la espina de aprender el capítulo de rewrite y de modificar unas reglas para ereselchef.com, el servicio web de mi amigo Manu.

Tampoco he conseguido migrar la web del cuslmadrid, un Symfony1.4, pero todo se andará, no parece tener mucha más historia.

Tanto Wordpress con php-fpm y Django+Gunicorn funcionan muy bien, y me queda por estudiar cómo hacer la configuración de Flask+uwsgi, por cambiar un poco.

Siempre he sido más de la parte de desarrollo, pero todo esto me está divirtiendo mucho y estoy encontrando un nuevo filón para mis tardes. :-)

Importador de Delicious y más para Sabrosous

javaguirre — 2012-01-22T00:00:00+01:00

Hoy he podido trabajar un poquito en Sabrosous, hay pocas novedades. Entre ellas el importador de marcadores de Delicious, ahora para probar Sabrosous se podrá importar directamente de Delicious fácilmente.

He arreglado algunos temas de duplicidad de código, para hacerlo más bonito, así como integración con Gravatar que tendré que probar más a fondo.

Poco más por ahora. Falta subir todo al repositorio y empezar a dejar entrar a la gente, no obstante la estética de la página cambiará completamente pronto, va a mejorar mucho gracias a @weapp :-)

Sabrosous: Cambios en views, ahora son clases

javaguirre — 2012-01-15T00:00:00+01:00

Tras ir a la primera reunión de Python Madrid, y estar hablando un rato con Andrei sobre Django en la segunda, especialmente temas de vistas, decidí hacer una clase genérica para mis vistas de Sabrosous, ya que me gusta que las peticiones get y post estén bien diferenciadas como en Flask.

Esta tarde he estado investigando el repo de niwi-web y de timebank de mis amigos de wadobo, finalmente me he decidido por la versión de GenericView del primero, aunque creo que integraré más cosas en esa vista genérica para quitar de encima código repetido. :-)

Por lo demás he arreglado un problema tonto que tenía al editar links. Al intentar integrar el Tag Inputs, me cargué la edición, ya que en el __init__ de la clase LinkForm estaba llamando a super con ModelForm, cuando tenía que hacerlo con BaseModelForm, cosas del directo.

Sigue habiendo muucho código mejorable y antiguo de cuando empecé con este proyecto, pero vamos simplificando poco a poco.

Me he acabado el primer libro de Juego de Tronos, ya he empezado el segundo. :-)

Al codemotion

javaguirre — 2012-01-15T00:00:00+01:00

Ayer hubo mucho movimiento en la lista de Python Madrid, y pensando que hoy se acababa el plazo para el Call for papers del codemotion, publicamos unas cuantas posibles ponencias.

Codemotion es un evento técnico en el que se reunirán todas las comunidades de desarrollo de Madrid y parte de España, teniendo la posibilidad de acceder a charlas de todo tipo.

Pensándolo durante este par de días y con ayuda del grupo, se me ocurrió que sería interesante impartir estas charlas:

- Python en las nubes: Una charla sobre frameworks web (Django, Flask, etc) y su despliegue en servicios cloud como plataforma (Heroku, DotCloud, Ep.io, etc). Una charla que seguramente realizaré conjuntamente con Rafael Durán que hablará sobre AWS y Openstack.

- Introducción a Django: Iniciación al framework más avanzado de Python.

- Python2 vs Python3: Repaso de ambas versiones desde el punto de vista del futuro de Python. Esta charla seguramente la realizaré conjuntamente con Pablo Lobariñas.

Charlas relámpago:

Aspen.io: Un framework orientado a ficheros.

Tornado: El servidor web.

Apis en la web - Requests: Mostrar lo fácil que es interaccionar con APIs web en Python.

De todo esto que he enviado finalmente no se cuántas charlas tendrán hueco, pero creo que hay un par de temas que podrían ser muy atractivos en el evento.

De momento el call for papers se ha ampliado hasta el 1 de Febrero, con lo que tocará esperar para ver si nuestras charlas finalmente tienen cabida en codemotion.

Añadido el BOE diario y el Borme a Openboe

javaguirre — 2012-01-10T00:00:00+01:00

Hasta ahora sólo había añadido los llamados Canales Temáticos a Openboe, desde ayer noche también se podrá buscar en todas las secciones del BOE y del BORME.

También he arreglado un pequeño problema con codificaciones en el buscador, ahora la búsqueda es más cómoda y no hay que meter tildes. :-)

Ahora mi idea es ir encapsulando las distintas entradas de los distintos RSS en una base de datos MongoDB para guardar un histórico de las entradas RSS antiguas y las que vayan apareciendo en éstos, para poder ser consultadas en el futuro.

También arreglar los títulos de cada lista de canales/boe/borme, adecuándolo a lo que pone en la web del boe.

Tras esto y tras securizar un poco la web tocará ponerla en producción, y empezar a pensar en los pasos siguientes para hacerlo más usable y práctico, por ahora es poco práctico.

Terra Nova no es muy nueva

javaguirre — 2012-01-08T00:00:00+01:00

No, porque parte de simplones guiones que ya han sido repetidos hasta la saciedad, como ocurrió en Falling Skies, una idea que parecía muy buena en un principio muere rápido, aunque se basaba en el argumento de moda que ya vemos en otras series actuales (mundo en colapso por alguna catástrofe). Los primeros dos capítulos muestran un Parque Jurásico mezclado con Avatar, aunque cuando avanza la serie no le queda ni lo mejor de la una ni de la otra me temo.

Guión monótono. Empieza el día muy bonito, hay un problema extraño, se soluciona y se acabó el capítulo, no se ve trama principal ni fuerza en la historia, que prometía mucho, pero que tras ver el quinto capítulo se ve bastante agotada.

Una pena, una buena idea que al final no da algo muy bueno, y tras ver la muy buena última temporada de Sons of Anarchy necesito algo a la altura, creo que probaré Breaking Bad, me la han recomendado mucho. :-)

Referencia: Terra Nova

Python class decorator for classes

javaguirre — 2012-01-08T00:00:00+01:00

We've been thinking this week in a good solution to separate credentials logic from our functional modules, and we've realised that decorators could be it. I came to this idea looking Tornado and Django's solution.

There are a lot of good posts and discussions about python decorators, but I needed to look deeper than most of tutorials.

There are many tutorials describing what a decorator is, so I won't enter in it, anyway there's a good classification (spanish) which I will refer to now.

According to the classification, the implementation approach is a bit different in these cases:

Decorator without parameters
Decorator with parameters
Decorator class without parameters
Decorator class with parameters
Decorator class with parameters for another class methods

Why a class instead of a simple function?

Because I needed to separate initialization from execution. If you know how to use a decorator you will understand my approach easy.

Finally my class:


class CheckPerm(object):
    '''Check permissions by a type'''
    def __init__(self, type):
        self.type = type

    def __get__(self, obj, type=None):
        ''' We need this to get the class of the function'''
        return self.__class__(self.func.__get__(obj, type))

    def __call__(self, func):
        self.func = func

        def wrap(*args, **kw):
            if self.type == 'one':
                result = self.check_one(args)
            elif self.type == 'two':
                result = self.check_two(args)

            if not result:
                return {"status": "1",
                        "error": "You dont have permissions"}

            return self.func(*args, **kw)
        return wrap

    def check_one(self, args):
        ''' Just for the example'''
        pass

    def check_two(self, args):
        ''' Just for the example'''
        pass

In the __init__ function I take the decorator parameter (type).

The __get__ function is necessary for not to lose our function class.

When we __call__ the function, we take it in our decorator, we check parameters (with hypothetical check_one and check_two functions) and return the execution of the function or our custom error.

In __call__ function we need this wrap to catch function parameters.

Now we can call our decorator like...


class myClass():

    @CheckPerm('one')
    def my_function(self, my_arg):
        pass

And that's all, hope it helps you understand better a solution for this need. :-)

Avance en Openboe, estilos y búsqueda por fecha

javaguirre — 2012-01-08T00:00:00+01:00

Hacía tiempo que tenía ganas de continuar mi proyecto OpenBOE, un proyecto que intenta crear una manera sencilla de acceder a la información del BOE, a la que actualmente se puede acceder por RSS.

No se si ahora ya tiene tanto sentido tras la apertura de una web por parte del gobierno para abrir los datos (no he tenido la posibilidad de estudiarla), pero creo que puede seguir cubriendo una necesidad que no está cubierta (proveer datos en bruto de forma más sencilla).

El proyecto comenzó siendo desarrollado en Silex, pero tras mi radicalización a hacer todo lo que pueda en mi lenguaje favorito, Python, y mi interés por el framework Flask, reescribí lo muy poco que tenía a esta tecnología.

Hoy he empezado además a introducir el twitter bootstrap para los estilos, lo había usado hace tiempo para alguna prueba de concepto y tenía ganas de utilizarlo más en profundidad, una delicia. :-)

Así que hoy ha tocado introducir los estilos según el bootstrap y añadir una búsqueda por fechas (desde, hasta) a los feeds RSS del BOE.

Puedes seguir el proyecto en github, si quieres participar también eres bienvenido. :-)

Hammerfight

javaguirre — 2012-01-03T00:00:00+01:00

Si algo ha conseguido Humble Bundle es acercar los juegos independientes a un público más amplio, un público que además ha premiado creativos y adictivos juegos hechos con poco presupuesto, así como contribuido a ONGs.

La pasada semana de vacaciones por Navidad pude disfrutar probando Hammerfight, un juego de combates muy original. El protagonista lleva una especie de helicóptero que tiene adosada un arma, ya sea un martillo, una espada, etc. Ésta está fija a un eje y se mueve de forma circular con el movimiento de la nave, que se maneja con el ratón. El truco es acertar con el arma a los otros enemigos, que usan la misma técnica para intentar atacarte.

Me ha gustado mucho el juego, muy original con un modo historia bonito y unos cuantos modos más (arena, tribal, mata bichos, etc), además puedes ir coleccionando armas diferentes e ir equipando la que más nos interese en la armería. A las armas se le pueden engarzar gemas, que tienen propiedades mágicas (regeneración, daño por fuego, etc).

No obstante la movilidad del jugador es en ocasiones complicada, y a veces no sabes cómo te han matado (por las explosiones) o te bloquean en parte de la pantalla y no puedes escapar. También hay veces que en el modo campaña los malos desaparecen y te dan la misión por ganada, aunque no suele pasar a menudo.

Ahora que el humble bundle #4 ha acabado, se puede obtener vía Steam.

Implementando jQuery Tag Inputs en Django, Parte 2

javaguirre — 2012-01-01T00:00:00+01:00

Ayer comencé un artículo sobre cómo implementar en Django el plugin de Jquery Tag Inputs, usado por Tumblr, y nos centramos en cómo mostrar las etiquetas que ya tenemos guardadas a la hora de editarlas como campo ManyToManyField.

Hoy nos centraremos en cómo validar y limpiar los datos para guardarlos en la base de datos. Para ello lo primero es crear una clase que herede de ModelMultipleChoiceField, ya que hemos cambiado el widget asociado a éste por defecto (hemos puesto un Textarea), y en el formulario al hacer submit el campo Field para este elemento se va a encontrar con una cadena en vez de con una lista al validar y devolver los datos correctos.

Este proceso de validación se lleva a cabo en la función clean dentro de cualquier clase del tipo Field de Django. Como Tag Inputs define separación de comas entre tags y nos devuelve un string, comenzaríamos haciendo un split de los datos obtenidos, para posteriormente y basándonos en el código de ModelMultipleChoiceField original, cambiar la variable value que se usa en todo el método por nuestra variable (yo la he llamado value_splitted).

La clase quedaría de la siguiente manera:


class MyModelMultipleChoiceField(ModelMultipleChoiceField):

    def clean(self, value):
        value_splitted = value.split(",")

        if self.required and not value_splitted:
            raise ValidationError(self.error_messages['required'])
        elif not self.required and not value_splitted:
            return []
        if not isinstance(value_splitted, (list, tuple)):
            raise ValidationError(self.error_messages['list'])
        
        key = "slug"
        qs = self.queryset.filter(**{'%s__in' % key: value_splitted})
        # we run custom validators here
        self.run_validators(value_splitted)
        return qs

El Field por defecto no te deja elegir una etiqueta que previamente no esté en la base de datos(fallaría la validación), yo necesitaba que todas las etiquetas pasasen el filtro independientemente de que estuviesen en la base de datos, con lo que eliminé esas líneas. También modifiqué el atributo con el que tomar las etiquetas de la bd, uso un campo slug en vez del id.

Todavía se puede arreglar más el clean (como comprobar si el value es vacío antes de hacer el split), pero nos sirve de ejemplo plenamente funcional. :-)

Finalmente en nuestra clase Form para el modelo correspondiente cambiamos la clase ModelMultipleChoiceField por nuestra clase.

Implementando jquery tag inputs en Django

javaguirre — 2011-12-31T00:00:00+01:00

Parecía sencillo, pero finalmente costó lo suyo dar con una solución que le gustase a Django y a jQuery Tag inputs, un excelente plugin para organizar tags dentro de un textarea que cumplía con todas las necesidades que Sabrosous necesita.

la parte más compleja por el momento ha sido al formatear las etiquetas/tags de un enlace que ya estaban en la Base de datos, ya que por defecto Django muestra sólo las claves primarias en los ManyToManyFields al hacer el render del formulario. Lo hace llamando a la función model_to_dict en django.forms.


if isinstance(f, ManyToManyField):
            # If the object doesn't have a primary key yet, just use an empty
            # list for its m2m fields. Calling f.value_from_object will raise
            # an exception.
            if instance.pk is None:
                data[f.name] = []
            else:
                # MultipleChoiceWidget needs a list of pks, not object instances.
                data[f.name] = [obj.pk for obj in f.value_from_object(instance)]

Al intentar reescribir la función model_to_dict en mi archivo links/forms.py me di cuenta que no tomaba esta sobreescritura, así que tuve que reescribir el constructor de mi clase LinkForm, que hereda de ModelForm. Más adelante pensaré en una mejor solución, aunque ésta por el momento me parece bastante decente.

Así que finalmente modificando una línea en el model_to_dict en el módulo forms conseguimos que al mostrar los tags seleccionados no muestre el id sino el campo que nosotros queramos. Al hacer esto faltará procesar este campo (tags) del formulario para guardarlo correctamente en la base de datos al hacer submit, así que recomiendo mostrar un campo único, en mi caso, un slug.

Aquí cómo queda el archivo final, las partes importantes son LinkForm y model_to_dict.


from django import forms
from django.forms import ModelForm
from links.models import Link, Tag

from django.forms.util import ErrorList


def model_to_dict(instance, fields=None, exclude=None):
    """
    Returns a dict containing the data in ``instance`` suitable for passing as
    a Form's ``initial`` keyword argument.

    ``fields`` is an optional list of field names. If provided, only the named
    fields will be included in the returned dict.

    ``exclude`` is an optional list of field names. If provided, the named
    fields will be excluded from the returned dict, even if they are listed in
    the ``fields`` argument.
    """
    # avoid a circular import
    from django.db.models.fields.related import ManyToManyField
    opts = instance._meta
    data = {}
    for f in opts.fields + opts.many_to_many:
        if not f.editable:
            continue
        if fields and not f.name in fields:
            continue
        if exclude and f.name in exclude:
            continue
        if isinstance(f, ManyToManyField):
            # If the object doesn't have a primry key yet, just use an empty
            # list for its m2m fields. Calling f.value_from_object will raise
            # an exception.
            if instance.pk is None:
                data[f.name] = []
            else:
                #mi linea para TAG INPUTS
                data[f.name] = ", ".join([obj.slug for obj in f.value_from_object(instance)])
        else:
            data[f.name] = f.value_from_object(instance)
    return data


class LinkForm(ModelForm):
    tags = forms.ModelMultipleChoiceField(
                                queryset=Tag.objects.all(),
                                widget=forms.Textarea
                              )

    def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
                 initial=None, error_class=ErrorList, label_suffix=':',
                 empty_permitted=False, instance=None):
        opts = self._meta
        if instance is None:
            if opts.model is None:
                raise ValueError('ModelForm has no model class specified.')
            # if we didn't get an instance, instantiate a new one
            self.instance = opts.model()
            object_data = {}
        else:
            self.instance = instance
            object_data = model_to_dict(instance, opts.fields, opts.exclude)
        # if initial was provided, it should override the values from instance
        if initial is not None:
            object_data.update(initial)
        # self._validate_unique will be set to True by BaseModelForm.clean().
        # It is False by default so overriding self.clean() and failing to call
        # super will stop validate_unique from being called.
        self._validate_unique = False
        super(ModelForm, self).__init__(data, files, auto_id, prefix, object_data,
                                        error_class, label_suffix, empty_permitted)

    class Meta:
        model = Link
        fields = ('title', 'url', 'description', 'tags')


class UploadFileForm(forms.Form):
    file = forms.FileField()

Generar claves ssh desde python sin meter contraseña

javaguirre — 2011-12-31T00:00:00+01:00

Para un proyecto hace un par de semanas estuvimos jugando con la generación de claves ssh-rsa desde python, que para la conexión automática segura entre servidores resulta de lo más cómodo. Buscando algo de información llegamos rápido a varios hilos en Stackoverflow hablando sobre el tema, aunque finalmente nos tuvimos que meter un poco en código. :-)

        from M2Crypto import RSA
        from base64 import b64encode
        import os

        key = RSA.gen_key(1024, 65537)
        raw_key = key.pub()[1]
        b64key = b64encode(raw_key)

        username = os.getlogin()
        hostname = os.uname()[1]
        key.save_key("/.ssh/%s" % login, callback=lambda v: "")
        keystring = 'ssh-rsa %s %s@%s' % (b64key, username, hostname)

        #devolvemos la clave pública
        return keystring

Opté por trabajar con la conocida biblioteca M2Crypto, con la que ya había jugado para temas de SSL, ignorando el certificado para xmlrpc.

En el ejemplo anterior generamos una clave RSA de 1024 bits, con un exponente RSA de 65537. Tomamos los datos de la parte pública con pub() y lo desciframos en base64. usamos los datos de la maquina del usuario y su login para añadirlo a la clave pública final.

Con save_key guardamos la clave privada ssh en formato PEM en el directorio que queramos con el nombre que queramos (normalmente en el $HOME/.ssh). Devolvemos la clave pública por si queremos hacer algo con ella (enviarla a una máquina con subprocess o lo que se nos ocurra :-) )

def passphrase_callback(v, prompt1='Enter passphrase:',
                           prompt2='Verify passphrase:'):
    from getpass import getpass
    while 1:
        try:
            p1=getpass(prompt1)
            if v:
                p2=getpass(prompt2)
                if p1==p2:
                    break
            else:
                break
        except KeyboardInterrupt:
            return None
    return p1

En este caso, podemos crear una función que se ocupe de introducir la contraseña para generar la clave final privada. En el ejemplo de M2Crypto en util.passphrase_callback se le preguntará al usuario qué contraseña quiere y se comprobará una segunda vez (código de arriba).

Usando el método ejemplo en util.passphrase_callback lo más sencillo fue finalmente implementarlo de una manera correcta, añadiendo como callback (como vemos en el código de más arriba) la función lambda.

...
key.save_key("/.ssh/%s" % login, callback=lambda v: "")
...

Al querer contraseña vacía basta con pasarle como callback una función lambda que recoja el parámetro de la función, devuelva vacío y listo. :-)

Reunión diciembre de Python Madrid

javaguirre — 2011-12-14T00:00:00+01:00

Ayer tuve la oportunidad de ir por pimera vez a la reunión de Python Madrid, y estoy encantado, genial ambiente y gente con un gran nivel técnico con la que apoyar y aprender cosas del lenguaje que nos apasiona.

Además tuve la oportunidad de dar una pequeña charla de Flask.

Estoy muy contento porque vamos a poder participar en la codemotion (ya me siento parte de esta comunidad, intentaré contribuir todo lo que pueda :-) ), que creo que es un evento muy interesante y que englobará a diversas comunidades de Software Libre.

También descubrí dónde trabaja la gente de Kaleidos, una empresa con una filosofía afín a mí y con gente de altísimo nivel. :-)

Lecturas de semana, Ruiz Zafón y Reverte

javaguirre — 2011-12-08T00:00:00+01:00

Esta semana me he acabado dos libros, El Asedio de Reverte, que llevaba leyendo un par de semanas, y el nuevo de Ruiz Zafón, El Prisionero del Cielo, que lo he devorado en un par de días.

El Asedio, novela histórica y asesinatos en la Cádiz del asedio francés, interesante por la ambientación, caracterización de personajes, etc. Una pieza para aprender vida y cultura pasadas y de historia marinera, que a mí personalmente me gusta (duelos navales, pasar por la quilla, todo ese tipo de temas ;-) ). Entretenido, y en ocasiones hasta educativo como son algunas obras de Reverte.

El Prisionero del Cielo, para mí el peor o menos bueno de la trilogía, menos psicológico, menos extraño, más basado en los hechos de la época de la posguerra, manido tema por muchas veces repetido. Sigo quedándome con lo siniestro y la paranoia del Juego Del Ángel. No me ha convencido este libro, aunque me ha resultado entretenido como todos los de Ruiz Zafón, le falta chicha, me ha sabido a poco, le ha faltado magia.

Aún tengo pendientes algunos libros más antes de que acabe el año, entre ellos la última aventura de Alatriste, aunque quizás leeré algo entremedias, por eso de cambiar de autor y contextos, quizás algo de Arthur C Clarke.

El Concurso de Software Libre comienza a moverse en serio

javaguirre — 2011-12-08T00:00:00+01:00

Parece que tras la finalización de la inscripción en el Concurso, los participantes empiezan a moverse en la forja de RedIRIS. Este año la participación está siendo tan activa, como mínimo, como los años anteriores, lo cual es un logro teniendo en cuenta que ésta es ya la sexta edición.

En su momento me propuse hacer un pequeño seguimiento de vez en cuando a los proyectos del concurso, sobretodo a nivel de código, que es lo que a mí me interesa más de los proyectos.

En la forja del concurso hay ya unos 25 proyectos registrados, de los cuales son menos de diez proyectos los que han hecho alguna actualización en el sistema de control de versiones. Viendo por encima los inicios podemos ver que tres de los proyectos han elegido Python, dos Java, PHP, y uno C++, curioso que siga teniendo tanto éxito Python entre los universitarios, y de que ninguno lo haya hecho en Ruby (al menos ninguno de los que ha empezado), con el éxito que está teniendo Ruby en los últimos tiempos.

Entre los que ya han comenzado: Abreforjas, Bytecode Land Kit, Helmet Wars, Workespeis FKP, SeventhEngine, daf-collage o Cormoran, proyectos muy variados.

Todavía es muy pronto para ver cosas hechas, pero esperemos poder meternos pronto en el código de los participantes. :-)

Jugando con Vim

javaguirre — 2011-12-06T00:00:00+01:00

Hace mucho tiempo que tenía pendiente aprender a usar el editor vim, sobretodo para saber realmente si me iba a servir de ayuda para mejorar productividad y tareas repetitivas del día a día.

He de decir que tras tres semanas de haberme leído A Byte of Vim, libro que me recomendó mi amigo mgdelacroix, estoy muy contento con el resultado, y aunque todavía me falta para sacarle todo el partido que podría, ya soy bastante más productivo que antes usando otros editores.

Aparte de los comandos típicos de estos casos, preparándolos especialmente para Python en mi caso, como tabstop, shiftwidth, expandtab, smarttab, otros como showcmd, number, syntax, hlsearch o incsearch para temas generales.

En plugins, exuberant ctags, para ver los métodos y las clases en un archivo, el project para crear proyectos y navegar fácilmente por sus archivos, autoclose, para que me cierre corchetes y demás, minibuffer, que te muestra los búffers abiertos actualmente, el xml para cerrar automáticamente las etiquetas html es aproximadamente lo que uso diariamente.

Como expresiones regulares que iluminen el código, me he encontrado con una que me muestra los espacios en blanco que he ido dejando por ahí, para así luego poder elmininarlos. Además se deshabilita cuando entramos en modo inserción, para que no moleste. La última línea es por temas de eficiencia.

highlight ExtraWhitespace ctermbg=red guibg=red match ExtraWhitespace /\s\+$/ autocmd BufWinEnter * match ExtraWhitespace /\s\+$/ autocmd InsertEnter * match ExtraWhitespace /\s\+\%#\@
Estoy lejos de sacarle mucho zumo al vim, pero cada pocos días aprendo cosas y eso me gusta. :-)

Introducción a Extensiones en Gnome Shell

javaguirre — 2011-11-27T00:00:00+01:00

Hace un tiempo que tenía ganas de aprender las posibilidades de Gnome Shell, hoy he empezado a hacerlo. :-)

Gnome shell es la nueva interfaz de usuario en Gnome 3. Me gusta su estilo minimalista y sencillo, soy de los que no les gusta que les interrumpan las notificaciones de escritorio y demás historias, y con Gnome estoy bastante contento en este sentido.

La parte más interesante de Gnome Shell es que su sistema de extensiones y los componentes de escritorio están escritos en Javascript. Su motor javascript (gjs) está basado en el SpiderMonkey de Mozilla.

Existe un muy buen artículo sobre la arquitectura de Gnome Shell y para iniciarse en el desarrollo de extensiones y personalización de componentes de éste.

Mi prueba de concepto está basada completamente en este artículo. Con éste y algunas directrices más es muy sencillo empezar a hacer cosas.

Lo primero que creo hay que saber es que existe una consola JS (LookingGlass) para depurar nuestro código, así como para acceder a los componentes que se están utilizando y para ver los métodos de la API.

La consola consta de las pestañas:

Evaluator, que es la consola javascript, podemos acceder a todos los datos actuales del escritorio con la variable global.

Windows, que son las ventanas que están actualmente en ejecución con su correspondiente instancia de objeto javascript.

Errors, para depurar las aplicaciones/extensiones. Podemos enviar mensajes a esta consola con global.log(string).

Memory, memoria utilizada actualmente.

Extensions, extensiones, activas o no, que reconoce gnome-shell.

Gnome-Shell tiene un comando para crear nuevas extensiones, que automáticamente te crea un metadata.json(metadatos de la extensión), un extension.js(Código principal de la extensión), y un extension.css (estilo de la extensión).

Para activar/desactivar las extensiones podemos usar gnome-tweak-tool o gsettings.

Para probar los cambios en el código de una extensión/aplicación podemos hacer un Alt-f2 y teclear r o restart para reiniciar gnome-shell.

Para modificar el código propio de Gnome-shell (como el de lookingGlass, o panel, etc), el código se encuentra en /usr/share/gnome-shell/js.

En el siguiente artículo hablaré sobre cómo hacer una extensión en Gnome3.2, aunque podéis encontrar bastante información para comenzar en las referencias de más abajo. No obstante algunos métodos/clases en estos artículos no son iguales en Gnome3.2 y tocará hacer un poco de investigación con lookingGlass y el código de gnome-shell. ;-)
Referencias:

http://live.gnome.org/GnomeShell/Development

http://blog.fpmurphy.com/2011/04/gnome-3-shell-extensions.html

http://blog.fpmurphy.com/2011/05/more-gnome-shell-customization.html

http://blog.fpmurphy.com/2011/03/customizing-the-gnome-3-shell.html

Charla API Javascript HTML5

javaguirre — 2011-11-09T00:00:00+01:00

El lunes hice una pequeña introducción a la API Javascript en HTML5 en los cursos del GUL de la Carlos III.

Quizás lo mejor de la charla para mí fue la presentación, fue a lo que le pude dedicar más tiempo el fin de semana, y creo que quedó bastante bien...

La charla en sí fue algo compleja para mí, ya que estos cambios de temperatura me han afectado y no estuve al 100%, no obstante creo que pude transmitir algunas cosas a las personas interesadas en el tema.

Para los cursos de Marzo tengo alguna idea que creo puede ser atractiva, y ya que Israel Gutiérrez y Miguel de la Cruz me han propuesto amablemente hacer algo conjunto para esas fechas, creo que podremos realizar algo que pueda ser más educativo. :-)

La presentación la podéis descargar desde github. Agradecer como siempre al GUL de la Carlos III su implicación, como siempre un placer.

Adding status update to tasks in Teambox Chrome Notifier extension

javaguirre — 2011-11-09T00:00:00+01:00

I've been using the Chrome/Chromium Teambox extension for a while and I thought in some changes that makes it more useful to me.

The developer of this extension has done a good job and a good start for adding more features in the future. Actually Teambox Notifier shows your last activity entries such as tasks, conversations, etc.

I found it useful, but I thought it could be better for my needs with some simple functionality. First I'm thinking about putting a selector in all tasks in the activities list and make a put request to change the state of a task so you don't have to enter in Teambox site to do it.

I hadn't enough time to finish it and now I'm having a 500 Internal Server Error when doing a PUT request, so I'm waiting for an answer of the Teambox support team. At least I'm improving my javascript skills, the main goal of this improvement. :-)

You'll be able of following my progress (bad or good) at github.com. :-)

Ducksboard hackaton

javaguirre — 2011-11-05T00:00:00+01:00

El jueves cuando volví de Sevilla me enteré de que la gente de Ducksboard iban a organizar una hackatón.

Ducksboard es un servicio que provee una interfaz como un tablero, en los que añades widgets que toman la información de distintos servicios (Twitter, Zendesk, etc) y en tiempo real te va mostrando las actualizaciones vía WebSockets.

Esto me parece interesante, pero lo que realmente me gusta de Ducksboard es la API que permite, añadiendo los llamados "custom widgets", actualizarlos vía API Rest con los datos que nosotros queramos. Lo mejor para entenderlo es ver un ejemplo. :-)

Había pensado hacer varias cosas, me apetecía usar varias APIs, aunque no tuviese tiempo para profundizar mucho en ellas, y que fuesen datos útiles para alguien como yo. Al final me decidí por hacer unos 5 widgets:

Github

Google Weather

Mediante bluetooth comprobar quién se encuentra en la habitación

Datos básicos del servidor (CPU, RAM, disco, red)

Lo he hecho rápido e intentando guardar algo de orden, pero es bastante mejorable, si mañana tengo algo de tiempo intentaré añadirle más cosas.

Si te interesa puedes ver el ejemplo en mi tablero público, el código en Github, y si quieres ver los proyectos presentados puedes en la web del Hackatón.

Openboe en Flask

javaguirre — 2011-11-01T00:00:00+01:00

Este puente además de aprovechar para descansar, he estado aprovechando para avanzar algo más en Sabrosous, comenzando a probar algunas de las funcionalidades, aunque aún están algo lejos de ser 100% usables sus características básicas.

Tenía ganas desde hace tiempo de probar Flask, el microframework de Python, que me resultaba tan parecido a DENIED, aunque siendo el primero Software Libre, del segundo no he encontrado el código en ninguna parte. Una noche comencé a jugar con Flask y reescribí lo poco que tenía de mi proyecto openboe, una aplicación que de forma amigable quiere interactuar con la información que el Boletín Oficial del Estado muestra en RSS.

La aplicación principal de openboe sería la siguiente:

# -*- coding: utf-8 -*- from flask import Flask, render_template, request, abort, redirect, url_for from app_modules.feed import parse app = Flask(__name__) @app.route("/") def index(): return "Hello World!" @app.route("/feed/", methods=['GET', 'POST']) def feed(name): feeds = ["seccionI", "seccionII", "seccionIII", "seccionIV"] topics = { "becas": "http://www.boe.es/rss/canal.php?c=becas", "ayudas": "http://www.boe.es/rss/canal.php?c=ayudas", "estudio": "http://www.boe.es/rss/canal.php?c=planes", "convenios": "http://www.boe.es/rss/canal.php?c=ccolectivos", "divisas": "http://www.boe.es/rss/canal.php?c=cambios", "prestamos": "http://www.boe.es/rss/canal.php?c=prestamos", "servicios": "http://www.boe.es/rss/canal.php?c=cartas", "colaboracion": "http://www.boe.es/rss/canal.php?c=ccolaboracion", "premios": "http://www.boe.es/rss/canal.php?c=premios" } filter_by = "" if request.method == 'POST': #TODO check POST['q'] filter_by = request.form['q'] if topics.has_key(name): links = parse(topics[name], filter_by) else: abort(404) return render_template("feeds.html", links=links, query=filter_by) if __name__ == "__main__": app.debug = True app.run()

La aplicación es bastante sencilla. Creamos un objeto app único para toda la aplicación y que se encargará de "hablar" con mod_wsgi.

Mediante @app.route definimos la ruta de una vista, definida por la función siguiente a este decorador. En ésta podemos recoger los parámetros que tomamos de la url en app.route.

En este ejemplo en función del name pasado por url, miramos en un diccionario que tiene los rss a los distintos contenidos del BOE, si existe el name en el diccionario, parseamos el RSS, si no existe, devolvemos 404 con la función abort de Flask.

Finalmente usamos render_template para elegir la plantilla que vamos a utilizar, usando el motor Jinja2 para éstas, y tras ello le pasamos todos los parámetros que necesitamos para el template.

Podéis ver el ejemplo completo en mi github. Para ejecutar basta lanzar python application.py

Python virtualenv

javaguirre — 2011-10-25T00:00:00+02:00

Tras unas semanas trabajando con django más en serio y día a día y con distintas versiones en local y en nuestro servidor, he decidido usar virtualenv evitando adivinar qué módulos/métodos podía usar y cuáles no del salto de la 1.2 a la 1.3.

Para este objetivo viene que ni pintado el módulo virtualenv para python, que con mucha sencillez te permite cargar en un entorno distintas versiones de módulos python, haciendo fácil replicar las versiones de módulos usados en un entorno de producción a local.

Hay un tutorial muy bueno sobre cómo instalarlo y activarlo en la wiki de Archlinux.

Una vez instalado podemos jugar con los repos de pip y con un sencillo pip install modulo=version instalar la versión que necesitamos sólo para nuestro entorno activo.

Para volver a la normalidad basta con un deactivate, podéis comprobarlo en otro tutorial de virtualenv.

VI Concurso Universitario de Software Libre

javaguirre — 2011-10-18T00:00:00+02:00

El Concurso Universitario de Software Libre vuelve un año más, excelente noticia es que año tras año se mantenga esta iniciativa docente por el Soft Libre, aunando en valores como son la comunidad, el aprendizaje y la cooperación entre alumnos.

Este año no he tenido tiempo para colaborar organizando el Premio Local de Madrid, me habría gustado poder hacerlo.

No obstante he tenido una nueva idea. Después de todos estos años en los cuales he podido colaborar en mayor o menor medida en la organización, lo cierto es que no he podido seguir con atención los proyectos a nivel técnico.

Así que he decidido dedicar un par de horas cada semana o cada 15 días para escribir una crónica personal de cómo van los diversos proyectos del concurso, creo que puede ser muy divertido.

El periodo de inscripción sigue abierto, también el periodo de patrocinio, esperemos que siga manteniendo el éxito de las cinco ediciones anteriores. :-)

Sabrosous soporta rss de favoritos

javaguirre — 2011-10-16T00:00:00+02:00

Bueno, pues hoy he dedicado un par de horillas a Sabrosous, y he de decir que estoy satisfecho. He vuelto a añadir funcionalidad al robot de encontrar el twitter de la página favoriteada, y vía JSONP cargar los twits del usuario.

Además también detecta los feed RSS de la página, y haciendo click en el botón RSS del link favorito podemos, vía Ajax, acceder a las últimas publicaciones (ésa es la idea :-) ), aunque por ahora carga el título del primer artículo.

En ambos casos, twitter y Rss, falta el formateo de los datos de respuesta, una tarea quizás algo menos interesante pero necesaria que será lo próximo que realice.

Además para esta semana que empieza quiero añadir el plugin chosen para la funcionalidad de los tags (añadir, eliminar) y añadir funcionalidad al buscador para encontrar los links vía tags.

Podéis seguir el transcurso del proyecto en GitHub. :-)

Vuelvo a Sabrosous

javaguirre — 2011-10-12T00:00:00+02:00

A veces me pregunto si al blog le sentaría mejor un verde en los links en vez de este rojo...

Hoy después de unos meses sin tiempo para nada he vuelto a tocar Sabrosous, uno de esos proyectos que empiezo y nunca acaban, una aplicación que cubre una necesidad que tengo desde hace tiempo, un Delicious en bueno con más funcionalidades técnicas, y Software Libre.

He mejorado la petición http a la url favorita, he cambiado el httplib.HttpConnection de Python por pycurl, creo que es más cómodo y puedo hacer más cosas.

También he modificado el parseador HTML, de una librería/biblioteca que no recuerdo a lxml, mucho más amigable a mi modo de ver.

Aún queda mucho fine tuning ya que el código inicial fue de hace meses y he mejorado mucho en conocimientos y limpieza, pero esa parte del corazón inicial de Sabrosous ya tiene más sentido, aunque no esté reconstruido del todo.

Espero poder dedicarle algo más de tiempo pronto y meterle mucha más magia en el front, tiene bastantes cosas rotas desde la última vez que lo toqué.

Trauma Game - Crónica

javaguirre — 2011-10-09T00:00:00+02:00

Vía Humble Bundle llegué a un juego esta semana que me pareció bastante atractivo y fuera de lo común. No soy una persona que juegue mucho, de hecho si mi tiempo de juego llega a 3 horas mensuales me sorprendería, pero de vez en cuando me atrae la atmósfera y las sensaciones de este tipo de juegos indies.

Por unos 5 euros más lo que quieras pagar puede comprar Trauma en su propia web vía Paypal. Para ejecutarlo en ArchLinux instalé el standalone-flashplayer de AUR, y lo ejecuté vía $ flashplayer trauma.swf.

El juego trata sobre los extraños sueños de una chica hospitalizada, y en ellos vamos descubriendo claves ocultas en una atmósfera misteriosa, caótica y oscura. La música y el entorno nos sumerge en los distintos escenarios, muy logrado. La navegación es a base de diapositivas, y haciendo click a tu alrededor vas moviéndote por el escenario.

El juego es muy corto, eso sí, esperemos que tenga continuación.

Madrid es ruido

javaguirre — 2011-10-07T00:00:00+02:00

Madrid es ruido, ríos de catenarias que se pierden en barrios interminables de bloques de pisos. Luces de focos en la noche, atardeceres rojizos sobre antenas de áticos antiguos. Frías montañas tras urbanizaciones del extrarradio, señores disfrazados entre el bullicio, tardes de domingo en la Latina o paseando en el Parque del Oeste.

Pero sobretodo ruido, e historia, arco iris cultural, estrés y prisas entre semana y rumor cultural los fines de semana. Humo de coches en el atasco y miradas cansadas en los pasajeros del autobús, auriculares y libros en el metro, calor en la Puerta del Sol, desahogo bajo las ramas de los árboles del parque. Terrazas animadas y sonido de raíles.

Desorden humano, variedad y oportunidades.

Abierta propuesta Cursos de GUL Noviembre 2011

javaguirre — 2011-10-06T00:00:00+02:00

Me entero hoy de que está abierta la web para proponer charlas en los cursos del GUL 2011. :-)

El año pasado participé en las jornadas tanto de Noviembre como de Marzo, siempre está bien practicar las dotes de presentación delante de personas interesadas en aprender, y sobretodo hablar de software libre con gente simpática.

He pensado proponer tres temas:
- jQuery - Javascript API HTML5 - Git y Github
Animo a todo el mundo a que se pase por los cursos del GUL.

Probando NodeJS

javaguirre — 2011-09-27T00:00:00+02:00

Mucho revuelo ha habido en los últimos meses alrededor de NodeJS, y yo como animal curioso que soy he de decir que tenía ganas de ver el por qué de aquello.

Suele ocurrir que cuando un tema se comienza a comentar y se hace popular, surge un efecto dominó que hace vaya teniendo más y más repercusión, pero de entre esa gente que le da bola, al menos la mitad no han llegado a la segunda página de lo que es este framework, y mucho menos han desarrollado algo más grande que un Hola Mundo.

Es por ello recomendable probarlo por uno mismo, no sólo por el placer de aprender algo nuevo, sino porque antes de opinar es esencial tener un criterio sobre lo que se opina (perogrullada).

Saltando de enlace a enlace leyendo sobre Node, llegué a un par de libros interesantes para comenzar, y por sólo 8 dólares los adquirí.

Actualmente estoy leyendo el primero de ellos, Node Beginner de Manuel Kiessling. Explicado de forma sencillísima, un libro corto y excelente para empezar en esto de Node.

También es esencial leerse alguna entrada de blog en el que nos ayudan a entender mejor la metodología de desarrollo del framework y cómo funciona.

La principal diferencia que me he encontrado con respecto a frameworks que uso normalmente es que con Node tú creas un servidor, una capa más por debajo de control, y que en vez de pasar datos, pasas funciones, trabajas con verbos, en vez de con nombres.

Reseñable es también la gran cantidad de movimiento que hay en la comunidad de Node, y lo fácil que es integrar los módulos de otros en tu proyecto. Llevo dos días practicando con él, me está gustando, pero aún tengo cosas que aprender para hacer una introducción interesante.

A los que les gusta probar, les recomiendo encarecidamente instalarlo.

Conclusiones de mis últimas andanzas

javaguirre — 2011-09-25T00:00:00+02:00

Hace ya mucho tiempo que escribí por última vez, y siempre me hago la misma promesa, volveré a escribir con mayor asiduidad, desgraciadamente siempre me engaño.

En los últimos meses me ofrecieron trabajar con un grupo de personas que han participado en proyectos muy interesantes, con gran experiencia y ganas de hacer las cosas muy bien, algo que siempre he querido hacer y que por desilusión/decepción en mis anteriores trabajos no he podido. Un proyecto ambicioso y en el que siento aprendo cada día a dar lo mejor de mí, y lo hago encantado.

Tengo mucho que aprender, y estar al lado de personas con experiencia en hacer las cosas mejor que bien hacen que mi trabajo mejore y que mis conocimientos crezcan mucho más rápido cada día. A un apasionado de mi trabajo/sector como soy yo esto no es más que satisfacción personal y profesional.

Pero no quería extenderme hablando de estas cosas, quería ser más técnico. Me he dado cuenta que desde que empecé a investigar en ese gran grupo personal que es SUGUS (Asociación de Software Libre de la Uni de Sevilla), que yo quería trabajar desarrollando con Python, ahora también aprender a fondo Javascript/bibliotecas y demás sucedáneos, y que en mi tiempo libre/profesional otros lenguajes iban a tener un espacio mucho menor.

Es en esta época cuando cambio mi experiencia en Symfony por aprender a fondo Django (y otros frameworks Python) en vez de optar por Symfony2, para así disfrutar más de Python, aunque siga trabajando día a día también con PHP a nivel servidor. Jquery es mi más leal compañero en el día a día en la magia a nivel navegador.

Ahora veo que necesito más base y más entender cómo funcionan las cosas, cómo mejorar a nivel estructural, algorítmico, estudiar ciertas cosas que complementen lo que hago día a día para hacerlo de una forma más correcta.

Lamento que hayais tenido que soportar estas disertaciones tan largas, y prometo ir mucho más al grano en las siguientes publicaciones. :-)

Google Music Beta para GNU/Linux

javaguirre — 2011-08-10T00:00:00+02:00
Tras mi última publicación, he de decir que Google no ha tardado mucho en sacar una versión para GNU/Linux de su cliente para Google Music, con lo que el momento de probar su tecnología está más cerca. Sigo siendo fan de Grooveshark, pero habrá que estar atentos a lo que Google puede ofrecer en este aspecto. ¡Más detalles pronto!

Google Music Beta

javaguirre — 2011-06-29T00:00:00+02:00
Cuando estuve en la Google IO Extended 2011 en Madrid, uno de los productos que más me llamó la atención fue Google Music Beta. Tras echar un breve vistazo a la aplicación, lo único que puedo decir es que puedes subir canciones descargándote un cliente de escritorio (al menos por ahora), y que éste no existe para GNU/Linux. Esto es una confirmación a lo que yo pensaba, que seguiré usando Grooveshark. Los colores de la aplicación, no obstante, son muy bonitos.

ArchLinux mola :-)

javaguirre — 2011-06-21T00:00:00+02:00

He usado diversas distribuciones GNU/Linux a lo largo de estos años, Ubuntu, Debian, openSUSE, Sabayon... con ninguna he estado tan satisfecho como con ArchLinux.

Por muchas razones ArchLinux mola :-)

Configuraciones no mágicas

Arch User Repository

Documentación enorme y de mucha calidad

Gestor de paquetes pacman

Filosofía KISS

Ligero

Últimas novedades de software

Silex y MongoDB para proyecto OpenData

javaguirre — 2011-06-14T00:00:00+02:00

¿Qué ocurre cuando el miniframework Silex se encuentra con MongoDB en una iniciativa para hacer más fácil la lectura de datos en la Administración Pública? OpenBOE. :-P

Pronto en github.

Usando DENIED, micro-framework web Python

javaguirre — 2011-06-12T00:00:00+02:00

DENIED es un microframework web hecho en Python, que facilita el desarrollo rápido de pequeñas aplicaciones web y su posterior reutilización. Podemos en un mismo método aglutinar ruta y funcionalidad (de forma bien diferenciada), gracias a los decoradores de Python, por ejemplo.

Viene con un servidor para realizar el desarrollo (como unos cuantos frameworks python más), pero la gracia viene en la manera de desarrollar los módulos, y lo fácil que parece realizar éstos desde cero, su fácil reutilización posterior.

En el screencast de ejemplo en la web de DENIED, el desarrollador muestra lo fácil que es hacer un libro de visitas, cómo tomar los datos POST en el controlador/función y cómo posteriormente guardamos los datos en JSON en un pequeño archivo de texto, olvidándonos de bases de datos SQL.

@route('/blog') def show_posts(): return render_template(posts=get_all_posts()) @route('/create') def create_post(): add_post(request.values['title'], request.values['text']) return redirect(url_for('show_posts'))

Parece ser que tienen el proyecto en github, pero no parece código por ninguna parte, es un pequeño archivo que llama a los demás recursos, con lo que por ahora no hay mucho código que destripar. También está en éste el proyecto de ejemplo que desarrollan en el screencast.

Se me ha ocurrido que sería divertido (y fácil) hacer un pequeño módulo python realizando un blog y guardando los datos en una Base de Datos Mongo, compartiré impresiones pronto, estoy seguro.

Habrá que seguir con atención el desarrollo del framework, tiene muy buena pinta. :-)

Update: AL final todo fue una coña del April's Fool Day, no obstante esto derivó en el framework Flask.

SQLAlchemy sobre Base de datos MySQL existente, migraciones faciles

javaguirre — 2011-05-31T00:00:00+02:00

Si hay algo que considero tedioso son las migraciones de datos cuando hay cambios estructurales de una BD a otra. Normalmente me hacía un script en Python, y con python-mysql me hacía unas cuantas consultas SQL, sacaba los datos y me peleaba con la correspondiente lista de datos producto de la consulta.

¡Nunca más! Desde que descubrí SQLAlchemy y SqlSoup encontré una manera mucho más bonita y agradable de trabajar con los datos, con clases. Esto no crea nada nuevo... pero si os digo que las clases las crea automáticamente SqlAlchemy a partir de los metadatos de las tablas y que no tenemos que definir ni una sola clase para disfrutar de toda la potencia y facilidad de los objetos, la cosa cambia, y mucho.

import sqlalchemy from sqlalchemy.ext.sqlsoup import SqlSoup from sqlalchemy import MetaData def main(): engine = sqlalchemy.create_engine('mysql://user:password@localhost/bd?charset=utf8') db = SqlSoup(MetaData(engine))

Obviando las líneas de importación, simplemente creamos una conexión mySQL a la BD en cuestión y le pasamos a una instancia de SqlSoup los metadatos de éstos. Posteriormente, para acceder a los datos sólo hay que consultar la variable db y el nombre de la tabla de la siguiente manera:

project_list = db.project.limit(30) for project in project_list: print project.name participant_list = db.participant.filter_by(project_id=project.id) for participant in participant_list: print participant.name

En db.project tomaríamos los 30 primeros datos de la tabla project. Posteriormente iteramos sobre éstos y realizamos una consulta sobre la tabla participant, la cual está relacionada con la tabla project por el project_id. Conseguimos los datos de participant e iteramos por ellos.

Como véis para acceder a un campo de la tabla basta con hacer un project.name (nombre_tabla.elemento), así de fácil.

Si queréis saber más, los enlaces de arriba os serán de ayuda.

Creando una API con Django y django-piston

javaguirre — 2011-05-21T00:00:00+02:00

Django-piston es una app de Django para crear APIs para tu web de una manera muy sencilla.

Actualmente estoy trabajando en un proyecto (Software Libre) para el que necesito una API y autenticación mediante OAUTH. Por el momento he estado desarrollando únicamente el read, mostrar la lista de datos.

Para ello sólo hay que definir dos cosas, un handler, que se ocupará de tomar la url y mostrar los datos que le pidamos, y la url desde la que llamaremos al handler, con menos de diez líneas, podremos mostrar muchas cosas. :-)

En mi ejemplo, que se puede ver en el repositorio de Sabrosous, mostraremos los datos de enlaces que tienen todos los usuarios en "favoritos", así como la lista de enlaces favoritos por usuario, ambas cosas con el mismo handler. El handler lo podríamos poner en una app de nuestro proyecto llamada api, creando el archivo handlers.py con este contenido:

from django.contrib.auth.models import User from links.models import Link from piston.handler import BaseHandler

class LinkHandler(BaseHandler): allowed_methods = ('GET', 'POST') model = Link def read(self, request, username=None): if username: user = User.objects.get(username=username) return user.link_set.all() else: return Link.objects.all()

En este handler definimos los métodos a utilizar, el modelo de nuestra base de datos, y el método read. Si recibimos el nombre del usuario en la url, mostramos los enlaces de éste, si no recibimos nada, mostramos todos los enlaces.

El archivo urls.py lo ubicaríamos en la misma app api, y en ésta las siguientes urls:

from django.conf.urls.defaults import * from piston.resource import Resource from api.handlers import LinkHandler link_handler = Resource(LinkHandler) urlpatterns = patterns('', (r'^list/(?P\w+).(?P.+)$', link_handler), (r'^list.(?P.+)$', link_handler), )

Como vemos, importaríamos nuestro nuevo handler, y definiríamos dos urls, una para cuando introducimos usuario, otra para tomar todos los datos. La url tomaría también un valor , que definiría la forma de mostrar los datos.

Por defecto tenemos las opciones json y xml, aunque podemos hacer nuestro propio Emitter para mostrar los datos de la manera más propicia para nosotros y de una manera fácil.

Un ejemplo de llamada a la API de usuario:

http://midominio.com/api/list/usuario.json

Para ver la lista completa de enlaces:
http://midominio.com/api/list.json
Para más información, la wiki de django-piston.

Google IO, Impresiones y Android@Home

javaguirre — 2011-05-14T00:00:00+02:00
El miércoles pasado me invitaron a asistir a la Google IO Extended, en la oficina de Google de Madrid. Estuvimos reunidos viendo por videoconferencia las novedades que Google traía este año en uno de sus eventos más importantes. Hubo muchas novedades interesantes, pero para mí la más sorprendente fue Android@Home, con las funcionalidades de conectar tu Android a cualquier dispositivo electrónico de tu casa (o fuera de ella) con un circuito con una placa Arduino. Mediante conexión USB podemos llevar a cabo el desarrollo de la aplicación (no deja de ser un Arduino :-)). Las herramientas para estas posibilidades están compiladas en lo que se llama el Android Open Accessory Development Kit. Con respecto a Android, se lanzó la versión 3.1 del sistema, con algunas mejoras interesantes, como el control mediante movimientos corporales (por webcam) de las aplicaciones.. De las novedades más sonadas no tengo mucho que decir, Google Music y la posibilidad de descargarte películas desde el Android Market, nuevos servicios que no creo que traigan un boom o una gran sorpresa con ellos, ya hay servicios que aproximadamente cumplen estas necesidades, y por el momento sólo se lanzará como tal en Estados Unidos. Agradecer igualmente la amabilidad de la gente de Google en Madrid, un trato siempre correcto.

Modificando Pronamic Google Maps para Wordpress, Caja de busqueda

javaguirre — 2011-03-30T00:00:00+02:00
Para un proyecto personal sobre restaurantes vegetarianos, Comando Lechuga necesitábamos un localizador de publicaciones y, posteriormente, un mapa que nos localizase todas las publicaciones que previamente habíamos escrito. Decidí usar el plugin Pronamic Google Maps y me encontré con la necesidad de buscar en el mapa, ya que veía necesario que un usuario tuviese la posibilidad de buscar los restaurantes de su municipio fácilmente. Para ello realicé un par de modificaciones en dos archivos del plugin, de los que hablo ahora.
Cambio en el archivo classes/Pronamic_Google_Maps_Mashup.php

Después de la línea actual en el archivo...
$content .= sprintf('', esc_attr(json_encode($options)));

podríamos añadir...

$content .= ' ';
Simplemente añadimos un div con una caja de texto y un botón que al pulsarlo llamará al javascript que mostramos ahora.
Cambio en el archivo js/site.js

Podemos introducir estas líneas dentro de la función buildMashup. Con el selector jquery tomamos el botón al lado de la caja de texto y llamamos a la clase geocode de Google Maps, que nos geolocaliza, nos devuelve las coordenadas de Longitud y Latitud en función de la cadena de texto que le pasamos como parámetro. En este caso el valor de #map-text. Posteriormente le damos un zoom razonable y centramos el mapa en la posición deseada.
jQuery("#map-button").click(function(){ geocoder = new google.maps.Geocoder(); geocoder.geocode( { 'address': jQuery("#map-text").val()}, function(results, status) { if (status == google.maps.GeocoderStatus.OK) { map.setCenter(results[0].geometry.location); map.setZoom(13); } else { alert("Geocode was not successful for the following reason: " + status); } }); });
Bastante fácil ¿no? :-)

Charla de Django en los Cursos de Marzo del GUL

javaguirre — 2011-03-20T00:00:00+01:00

Añado también la charla de Django que realicé en el campus de Leganés el miércoles 16 de Marzo de 2011.
Video de presentación. Material de la charla.

Consultas SQL con Propel en Symfony 1.4

javaguirre — 2011-03-18T00:00:00+01:00
Me ha llevado un tiempo encontrarlo, pero muchas veces la culpa de no encontrar es que no has preguntado convenientemente. Hacer consultas SQL personalizadas cuando los Peer no son suficientes en Symfony con Propel es tan fácil como...
$connection = Propel::getConnection(); $sql = "YOUR SQL QUERY"; $statement = $connection->prepare($sql); $statement->execute(); while($result = $statement->;fetch(PDO::FETCH_ASSOC)) { echo var_dump($result); }
Fuente: http://joaquinnunez.cl/blog/2010/07/01/custom-sql-queries-in-symfony-1-4-with-propel/ Pronto explicaré cómo hacer un mapa con svg y RaphaelJS, lo tengo pendiente. :-)

Introduccion a Arduino

javaguirre — 2011-03-17T00:00:00+01:00

El Grupo de usuarios de Linux (GUL)de la Universidad Carlos III hace todos los años por estas fechas una semana de cursos para todo el que se quiera acercar al edificio de Informática de Leganés, donde ellos tienen sede. Ya en noviembre me acerqué para dar una charla sobre Symfony, y ayer impartí dos, una sobre Arduino y otra sobre Django.

En líneas generales estoy satisfecho con las charlas, aunque me salió mucho mejor la de Arduino. No obstante creo que lo pasamos muy bien, que es parte importante de los cursos y de conseguir que a la gente le llegue algunos de tus conocimientos.

Voy a colgar el material de la charla de Arduino en este artículo (también hay video que enlazo a continuación), y se lo facilitaré a la gente del GUL para que lo tengan en el mismo lugar que todo el material de estos cursos. En un artículo posterior añadiré el enlace al material de Django.

Podeéis acceder al material de todas las charlas en el ftp del GUL.
Presentación y código ejemplo Video de la presentación.
Agradezco mucho al GUL que me haya dado la oportunidad de realizar estas charlas. :-)

Repositorio de código con Git y Gitolite en Debian

javaguirre — 2011-02-10T00:00:00+01:00

Desde que Linus Torvalds, creador del Kernel Linux, desarrolló el sistema de control de versiones Git, ha ido comiendo terreno su implantación en la comunidad del Software Libre, hasta el punto de que ya son pocos los proyectos importantes que no usan éste como sistema control de versiones.

Gitolite te permite crear un servidor git centralizado con mucha facilidad, pudiendo controlar muy fácilmente los usuarios, los repositorios y los grupos de desarrolladores así como sus relaciones.

Ya había tenido experiencia con Gitosis, y aunque lo estamos usando en otros proyectos en un servidor personal, no me había convencido del todo. Para un grupo de investigación de la Universidad Carlos III en el que actualmente estoy trabajando decidí estudiar alternativas, y surgió gitolite.

Hay algunos tutoriales en Internet sobre cómo configurar tu servidor con gitolite, pero ninguno me convenció al 100% y me encontré con algún problema que no estaba bien explicado, por lo que para mí era necesaria una aclaración, de ahí esta entrada. :-)

Para este tutorial se tendría que tener conocimientos básicos de bash.

Para cualquier duda, podéis consultarme por los comentarios. :-)

Tutorial de Gitolite

Primero de todo añadimos el repositorio de lenny-backports (si no está ya en el archivo) a /etc/apt/sources.list

(# significa hacer estas acciones como root, $ como usuario normal)
# nano /etc/apt/sources.list
Introducimos la siguiente línea en el archivo:
deb http://www.backports.org/debian lenny-backports main
Una vez hecho esto instalamos git y gitolite en la máquina.
# apt-get -t lenny-backports install gitweb git-daemon-run gitolite
Instalados los paquetes, añadimos nuestra clave pública ssh (Si no tenemos una nos hacemos una con el comando ssh-keygen). Ésta suele estar guardada en...
~/.ssh/id_rsa.pub
La subimos al servidor en /tmp (este comando lo ejecutamos desde nuestra máquina, no en el servidor):
$ scp ~/.ssh/id_rsa.pub root@servidor:/tmp
Ahora volvemos a entrar al servidor por SSH, y ejecutamos lo siguiente:
# cd /var/lib/gitolite # gl-setup /tmp/id_rsa.pub
Esto añade a gitolite la clave ssh para poder descargarnos el repositorio de administración de gitolite, poder crear nuevos repositorios en la máquina y nuevos usuarios que trabajen en ellos.

Llega el momento de crear nuevos proyectos y dar acceso a usuarios a su proyecto. Descargamos el repositorio de admin de gitolite, gitolite-admin, en nuestra máquina donde generamos la clave ssh (usuario):
$ git clone gitolite@servidor:gitolite-admin.git
Tenemos dos directorios, conf, donde creamos los nuevos proyectos y los permisos de los usuarios, y keydir, donde pondremos las claves públicas ssh de los nuevos trabajadores de nuestros proyectos. Vamos a añadir un proyecto example con un usuario juan que lo controla (permisos lectura/escritura), y dos personas, javier y luis, que sólo lo leen para descargarse los datos pero no pueden escribir en el proyecto.

Editamos el archivo conf/gitolite.conf dentro de gitolite-admin y al final añadimos lo siguiente:
repo example: RW+ = juan R = javier luis
Una vez hecho esto añadimos las claves públicas SSH de los usuarios juan, luis, y javier en la carpeta keydir. Recordamos que las claves ssh se generan con el comando ssh-keygen, y que se encuentran en /home/usuario/.ssh/id_rsa.pub

Los metemos en el directorio keydir, renombrando el id_rsa.pub con el nombre de usuario.pub, en nuestro caso la carpeta keydir tendría los siguientes archivos, con las claves ssh de nuestros compañeros:
keydir/ luis.pub javier.pub juan.pub
Ya tenemos todo para descargarnos el repositorio example y trabajar con él, falta subir estos cambios a gitolite, para que nos cree el repositorio, los permisos y todo lo que necesitamos.

En la carpeta gitolite-admin que descargamos y en la que hemos estado trabajando:

$ git add . (Añadimos todos los cambios del proyecto, lo que hemos hecho en la carpeta conf y en keydir) $ git commit -m 'Añadido repositorio example' $ git push origin master (Subimos los cambios al servidor)
¡Ya podemos trabajar con nuestro proyecto example!
En nuestra máquina podremos hacer...
$ git clone gitolite@server:example.git
Espero que esté un poco claro. :-)

Concurso Universitario de Software Libre

javaguirre — 2011-01-27T00:00:00+01:00

Quería hoy escribir sobre una pequeña modificación que hice esta semana en un widget de Symfony que mejora ligeramente la usabilidad de éste, pero me apetececía hablar de algo más personal.

Quizás el Concurso Universitario de Software Libre fuese hace tres años lo que me empezó a posicionar en el lugar dentro del ámbito de la informática en el que quería estar, en el desarrollo de Software, Software Libre siempre que pudiese ser posible, y en ese sentido y en muchos otros estoy muy contento por haber participado en aquel evento.

Debido a mi fuerte vinculación con el Concurso y a que el Concurso de Software Libre de Madrid no podía seguir contando con sus grandes valedores del año anterior por no tener suficiente tiempo para pelearse con estamentos administrativos, valoré, allá por Septiembre, si era posible poner la semilla para un Concurso Universitario que pudiese ser duradero en Madrid.

Con la inestimable e imprescindible ayuda de algunos profesores conseguimos sacarlo adelante. Hubo momentos en los que pensé que a lo mejor no le iba a importar a nadie el lanzamiento del Concurso en Madrid, o que una persona nueva en Madrid que no tenía nada que ofrecer mas que trabajo y buenas intenciones y sin apoyo no podía conseguir nada.

Evidentemente no me equivocaba, pero los días que no tenía respuestas ni apoyos fueron superados y la perseverancia que en muchas otras ocasiones había sido un punto débil en mi vida, esta vez me ayudó a perseguir el objetivo.

Es totalmente cierto que si yo no hubiese ayudado o contribuido a organizar el concurso, lo habrían hecho otros, y posiblemente igual o mejor que yo, no obstante creo que la idea de no emparejarlo con una sola universidad para que todos lo alumnos que quisiesen participar pudiesen hacerlo fuesen de la universidad que fuesen era algo que nos parecía muy importante.

Sólo puedo concluir lo agradecido que estoy a esta iniciativa, y mi orgullo por poder decir que pasen los años que pasen el Concurso ha permanecido fiel a su idea inicial, ser un trampolín para aprender con el Software Libre, contribuir en él como comunidad en la docencia y no dejarse vender.

Todo el tiempo que dedicamos al Software Libre merece la pena porque estas ideas permanecen intactas, y es este agradecimiento el que me hace dedicar todo el tiempo que puedo al CUSL. :-)

Mod_auth y apache2, poniendo password a tu sitio web

javaguirre — 2011-01-05T00:00:00+01:00

En ocasiones estamos desarrollando un proyecto y queremos tenerlo online o empezar a probarlo en nuestros servidores, pero sin que el gran público pueda acceder hasta que el sitio no esté completamente preparado.

Para requerir autenticación nos sirve el módulo del servidor Apache Mod_auth, que viene instalado y activado por defecto en todas las distribuciones GNU/Linux populares una vez hemos instalado Apache.

¿Cómo podríamos fácilmente poner contraseña a nuestro sitio web en construcción? Muy sencillo, aquí va una de las posible maneras.

Primero deberemos ver si el módulo mod_auth está habilitado. En Debian podemos cerciorarnos de este detalle si se encuentra mod_auth, auth_basic, o algún archivo de nombre parecido en /etc/apache2/mods-enabled (el directorio en otras versiones o en otras distros GNU/Linux podría ser modules.d).

En caso afirmativo, crearíamos un archivo .htaccess en el directorio del sitio que queremos cerrar (/srv/www/midominio.com) con contraseña con el siguiente contenido:

AuthType Basic

AuthName "Authentication required"

AuthUserFile /srv/www/midominio.com/.password

Require valid-user

Creo que las líneas son autoexplicativas. Tras esto bastaría con crear el archivo .password donde le hayamos dicho en la ruta anterior e introducir en este las tuplas del nombre de usuario y contraseña de la siguiente forma:

usuario1:$1$HmwZG55x$bC4F2/JUfEyl30K7.0ikl.

usuario2:$1$nZ1vx3dy$7D8r0fWEiynBbCUBsuJqs1

La contraseña va tras el nombre de usuario, y ambos están separados por dos puntos. La contraseña se puede generar fácilmente por consola con este comando (teniendo los paquetes para md5 de tu distribución instalados):

md5pass palabra

Donde palabra sería tu clave o password. Copiamos la salida del comando en el archivo .password al lado del nombre de usuario como he comentado anteriormente y listo. :-)

La carta esférica, la película

javaguirre — 2010-12-30T00:00:00+01:00

Nunca me gusta ver una película basada en un libro o generada a partir de éste sin antes haberlo leído, me parece como una pequeña traición a mi imaginación, que siempre me da tanto.

La carta esférica es una película basada en la novela homónima de Pérez Reverte. Habla de tesoros en barcos hundidos, ambiciones y obsesiones marineras e históricas en el siglo XX.
Los personajes principales, una enigmática y calculadora Aitana Sánchez Gijón en el papel de historiadora del Museo Naval de Madrid, un Carmelo Gómez marinero, visceral e impulsivo y un conjunto de misteriosos y en ocasiones perseverantes enemigos completan el ciclo de personajes de la película. Película entretenida, con todo lo malo y bueno que este adjetivo conlleva. Quizás lo que más me gustó fueron las escenas marítimas, el velero en busca de aventura, y el contraste del bullicio que trasmite la ciudad con respecto a los pequeños pueblos pesqueros, que siempre tanto me han atraído. También es reseñable el papel de Aitana en alguna de esas escenas a las que nos acostumbran las películas españolas. Para una tarde de invierno no está nada mal.

Mailman y Gitosis

javaguirre — 2010-12-26T00:00:00+01:00

Hoy está siendo un día completito. Tras estar instalando y configurando mailman (listas de correo) por petición de los participantes del Concurso Universitario de Software Libre de Madrid, me he puesto a configurar gitosis para la gestión de mis/nuestros proyectos en un servidor Debian que he adquirido recientemente.

Me ha dado algún que otro disgusto, pero después de un par de horillas ya está todo configurado. :-)

Fuentes: http://kalendas.net/docs/mailman.html

http://ymbra.com/es/blog/ramon/gestion-de-repositorios-git-con-gitosis

Humble Bundle, juegos indie por el dinero que quieras

javaguirre — 2010-12-25T00:00:00+01:00

Una propuesta de lo más interesante, Humble Bundle, un conjunto de juegos indie que durante un periodo de tiempo puedes comprar por el dinero que quieras. Una iniciativa que bajo mi opinión hay que apoyar, aunque sea por poco dinero, merece la pena, sobretodo para los linuxeros, que casi nunca podemos disfrutar de buenos juegos para GNU/Linux, ésta es una gran opción.

Algunos de los juegos son de una gran calidad, como el premiado World of Goo de la edición Humble Bundle del año pasado (la de este año es la segunda edición).
Me han gustado mucho algunos de los juegos de esta segunda edición, como Machinarium, aunque aún no he podido hacer que me funcione muy bien, tiene una pinta genial. También el Braid, o el Revenge of The Titans, intentaré dar una opinión cuando los pruebe, por ahora de algunos sólo he visto el video. También disponible como regalo, una buena oportunidad de comprar software de calidad y contribuir directamente con los desarrolladores de videojuegos y con algunas organizaciones no lucrativas, como Child's Play. En el video a continuación podréis ver una intro de los juegos. ¡Feliz Navidad! :-)

Garry Kasparov, Como la vida imita al ajedrez

javaguirre — 2010-12-22T00:00:00+01:00

Ya hace mucho tiempo que mi abuelo me enseñó este juego, pero hace apenas dos meses que me apasiona de verdad, y me sirve como alivio y diversión casi diaria. A través del ajedrez he adquirido nuevos puntos de vista y creo que he aprendido a ser más calculador y a limitar algunos de mis defectos.

Puede parecer sorprendente, hablo como si de la panacea se tratase, pero lo cierto es que aparte de un juego y un arte, el ajedrez puede llegar a ser una interpolación de la realidad, como muestra el campeón del mundo de ajedrez Garry Kasparov en su libro Cómo la vida imita al ajedrez.

Desde el punto de vista del ajedrez, y basándose tanto en su carrera ajedrecística como en su introducción en la política, nos cuenta cómo desde el punto de vista del juego, dibuja un entorno de la realidad, e igual que saca conclusiones delante del tablero muestra su punto de vista como si la vida (y sobretodo los negocios) se tratase de una partida de ajedrez.

También tiene tiempo para repasar su carrera y hablar de una colección de libros que está desarrollando sobre los grandes maestros del ajedrez, un mundo que personalmente me resulta fascinante, ya que cada uno de los grandes campeones, como en todo, eran excelentes jugadores, pero poniendo su personalidad y su sello a sus partidas y a su juego.

Tengo que decir que esperaba con ansia leerme el libro una vez descubierto, y que me ha ayudado a tener un punto de vista diferente de las cosas, muy influenciado por mi reciente pasión por el juego o arte del ajedrez.

Jugando con Websockets

javaguirre — 2010-12-18T00:00:00+01:00

Los viernes son los días de Software Libre en mi actual empresa, y llevaba un tiempo queriendo hacer algo más interesante y/o complejo. El jueves que viene vamos a dar un conjunto de charlas y decidí realizar una sobre Websockets, una tecnología de HTML5 para abrir conexiones persistentes bidireccionales y full-dúplex sobre un mismo socket TCP.

Tras unos cuantos ensayos y errores conseguí hacer esto (imagen y código), y de paso ayudar a continuar(o comenzar) un proyecto de un amigo con el que siempre comparto mis ideas, locas o no.

La aplicación conecta a dos usuarios mediante un websocket(habrá que meter un websocket por usuario en un futuro) a un servidor, que muestra las cartas que van eligiendo sobre un grupo de cartas que aleatoriamente les han tocado.

El código de la aplicación está en gitorious, es fácil de instalar leyendo el README, se puede probar en Google Chrome(también en Firefox, pero como aún no están implementados los websockets en la versión 3, en ésta no los usa).

Al ser la primera versión y no tener tiempo (ni ganas) de refactorizar ayer para dejarlo más bonito, así se quedó, no esperéis un código bonito, aún. :-)

Fuente: maddemcode.com

Arcade Fire

javaguirre — 2010-12-16T00:00:00+01:00

Recuerdo perfectamente que la primera vez que supe de Arcade Fire aún me refugiaba en el Harbour Bar, en la bahía de aquel pequeño pueblo a 40 minutos en tren de Dublín, Bray. Las noches entre semana enchufaban a la pantalla grande Youtube y ponían videos de grupos, y el nombre Arcade Fire salía con asiduidad, sin embargo la acústica no era suficiente para que me quedase con ninguna de sus canciones ni para que entrasen en mi cabeza.

Meses después, ya en Madrid, de una u otra manera volvió a cruzarse en mi camino, y algún día de curro di una oportunidad a sus discos. Alguna de sus canciones recordaba haberlas escuchado en algún lugar, posiblemente en Irlanda, donde estos grupos tienen más cabida y no se confunden tanto con la basura musical de los anuncios con los que las grandes marcas comerciales nos deleitan.

No sabría calificar bien la múscia de Arcade Fire, en ocasiones es rock, en otras algo pausado que no logro reconocer entre mi escaso conocimiento de los géneros/movimientos musicales. Me empezó a gustar.
Canciones como Intervention, No Cars Go, Rebellion(Lies), menos conocidas como The Well and the Lighthouse, o Black Wave-Bad Vibrations, con letras elaboradas, cambios de ritmo sorprendentes y en mi opinión geniales en algunas de sus pistas, y un directo artesanal y ruidoso que desgraciadamente me perdí en su visita a Madrid son algunas de esas características que me han hecho distraerme con su buena música. Arcade Fire - Rebellion (Lies)

Barney Stinson juega un Angry Birds muy real

javaguirre — 2010-12-14T00:00:00+01:00

Hoy me he encontrado con la noticia de que el videojuego Angry Birds ha llegado a los 50 millones de descargas.

Mientras tanto, en los video Games Awards 2010, el actor Neil Patrick Harris (Barney Stinson en How I Met Your Mother), jugaba una divertida partida de Angry Birds, con cerdos y pollos de verdad, para no perdérselo. :-)

Discurso Mario Vargas Llosa, Nobel de Literatura 2010

javaguirre — 2010-12-13T00:00:00+01:00

Hoy he tenido la oportunida de leer el discurso de Mario Vargas Llosa durante la entrega del Nobel de Literatura. He de decir que no he podido parar de leerlo hasta el final, una lectura recomendable para aquéllos que amamos la buena literatura.

En el discurso habla de sueños, de literatura, de influencias, de política, colorea todo el discurso con su punta de vista y finalmente expresa el amor que, desde pequeño, ha tenido a la literatura, un todo con su suprema calidad narrativa.

Nunca había tenido interés o no había llegado a tener conocimiento sobre estos discursos (los del Nobel), y francamente ha sido para mí la lectura del día.

Primera entrada

javaguirre — 2010-12-12T00:00:00+01:00
Primera entrada del blog.