He wrote THE book : “C Programming Language”. I fell in love with C with this book.

I’ll miss you Dennis !!

Remembering that I’ll be dead soon is the most important tool I’ve ever encountered to help me make the big choices in life. Because almost everything — all external expectations, all pride, all fear of embarrassment or failure – these things just fall away in the face of death, leaving only what is truly important. Remembering that you are going to die is the best way I know to avoid the trap of thinking you have something to lose. You are already naked. There is no reason not to follow your heart.

- Steve P. Jobs, Stanford, 2005

See you in a few days in Berlin ! Happy hacking !

For a year , maybe more, we’ve been using git for our projects. The experience has been good, but in the beginning was a little bit complicated. The main problem was the git learning curve. If you has been using svn or cvs, the change to git is a little bit complicated because there are new concepts to learn about how to work with different repositories . So we thought it would be necessary to create a workflow for make easier our work.

I started reading documents, articles, books about git and git workflows. There are a lot of information about it , so I took ideas from here and there  and i draw it with inkscape. While we work, we discussed the workflow and fixed it if necessary. And the final result was this (now released under CC-BY-SA  ;) )

Available in png, pdf, svg formats. And you can fork it in this repository .

The diagram has two parts, left side shows the git workflow and the right side is the explanation of the workflow steps. In the initial situation, we’ve a repository (osproject at openshine) that we want to add a feature or fix a bug.

So the workflow is as follow :

1. Fork a project in github, and this fork will be stored in your github account. To “fork” a project in github means to create a clone of this project.
2. Clone the project fork, that you create in the 1st step, in your computer.It’s really useful adding the upstream repository as remote (the repository from you forked in the 1st step).
3. Keep updated your repository from upstream whenever possible.
4. Create a branch with the feature’s name or the bug id and description. Something like add-new-configuration-window or main-window-error-57 …
5. Develop & commit, develop & commit …..
6. Check if your branch is updated from upstream.
7. Feature complete !!
8. If you want to push all your commits check 8th step in the diagram
9. If you want to push all your commits but in a single commit, check 9th step in the diagram
10. Now you’ve you branch in your github account. The last step is ask to the upstream developer if you can merge your branch in upstream. So, press “Pull request” button. When your changes will be accepted by the upstream maintainer you can remove your branch stored in your github repository with “git push origin :branch-name”.

The Maintainer workflow is about how to merge branches from the point of view of upstream. But in the new version of github is not necessary in most of cases because you have a “Merge” button.

And finally … some useful links :

• GIT homepage
• GIT documentation
• github : public git service
• gitorious : public git service and opensourced server.
• OpenShine github organization
• OpenShine git workflow : png, pdf, svg
• OpenShine workflows repository

I hope you liked it and you find it useful .

This is the best way to show the user timeline without worries. You just copy and paste some javascript code, but sometimes you need more flexibility and copy and paste javascript widget it’s not enough.

In this post you’ll find a way to parse the Twitter’s user timeline from a json file with Python. There are a lot of ways to do that, here’s mine.

This is not a Python wrapper arround the twitter api, if you are looking for something like that, please visit http://code.google.com/p/python-twitter/

Getting the Twitter’s user time

To download the last tweets, I use the GET statuses/user_timeline function that returns a json file. I’ve created a function to download the json file and  parse it. I’ve also created a Tweet class to store the tweet info.

The “read_tweets()” function parse the json file and store the tweet info in a list of Tweet instances. The Tweet class also provide some methods to store info easly.

Let’s see the code.

import Tweet
import simplejson
import urllib2


def read_tweets(user, num_tweets):
    tweets = []
    url = "http://api.twitter.com/1/statuses/user_timeline.json?\
           screen_name=%s&count=%s&include_rts=true" % (user, num_tweets)
    file = urllib2.urlopen(url)        
    content = file.read()        
    json = simplejson.loads(content)
    
    
    for js_tweet in json:
        tweet = Tweet()
        tweet.id = js_tweet['id']
        tweet.username = js_tweet['user']['screen_name']
        try:
            tweet.retweet_user = js_tweet['retweeted_status']['user']['screen_name']
            tweet.retweeted = True
        except:
            tweet.retweeted = False   
        
        tweet.set_date(js_tweet['created_at'])
        #tweet.id, tweet.username must exist
        tweet.set_tweet_url()
        #convert plain text to html text
        tweet.set_text(js_tweet['text'])
        #tweet.id, tweet.username must exist
        tweet.set_profile_url()
        if tweet.retweeted:
            tweet.user_avatar_url = js_tweet['retweeted_status']['user']['profile_image_url']
        else:
            tweet.user_avatar_url = js_tweet['user']['profile_image_url']
        tweets.append(tweet)    
    
    return tweets

In “read_tweets()” I use urllib2 to read the file and simplejson to parse it. To store the info I use the Tweet Class methods.

import time
from datetime import datetime
import re


class Tweet():
    """Store the tweet info
    """
    id = None
    username = None
    url = None
    user_avatar_url = None
    tweet_url = None
    profile_url = None
    html_text = None
    retweeted = None
    retweet_user = None
    date = None

    def set_date(self, date_str):
        """Convert string to datetime
        """
        time_struct = time.strptime(date_str, "%a %b %d %H:%M:%S +0000 %Y")#Tue Apr 26 08:57:55 +0000 2011
        self.date = datetime.fromtimestamp(time.mktime(time_struct))
        
    
    def set_text(self, plain_text):
        """convert plain text into html text with http, user and hashtag links
        """
        
        re_http = re.compile(r"(http://[^ ]+)")
        self.html_text = re_http.sub(r'\1', plain_text)
                
        re_https = re.compile(r"(https://[^ ]+)")
        self.html_text = re_https.sub(r'\1', self.html_text)
        
        
        re_user = re.compile(r'@[0-9a-zA-Z+_]*',re.IGNORECASE)        
        for iterator in re_user.finditer(self.html_text):
            a_username = iterator.group(0)
            username = a_username.replace('@','')
            link = '' + a_username + ''
            self.html_text = self.html_text.replace(a_username, link)
                    
 
        re_hash = re.compile(r'#[0-9a-zA-Z+_]*',re.IGNORECASE)
        for iterator in re_hash.finditer(self.html_text):
            h_tag = iterator.group(0)
            link_tag = h_tag.replace('#','%23')
            link = '' + h_tag + ''
            self.html_text = self.html_text.replace(h_tag + " ", link + " ")
            #check last tag
            offset = len(self.html_text) - len(h_tag)
            index = self.html_text.find(h_tag, offset)
            if index >= 0:
                self.html_text = self.html_text[:index] + " " + link
            

    def set_profile_url(self):
        """Create the url profile
        """
        if self.retweeted:
            self.profile_url = "http://www.twitter.com/%s" % self.retweet_user
        else:
            self.profile_url = "http://www.twitter.com/%s" % self.username
    
    def set_tweet_url(self):
        """Create the url of the tweet
        """
        self.tweet_url = "http://www.twitter.com/%s/status/%s" % (self.username, self.id)

The most important Tweet class method is “set_text()”. It converts plain text into html code with http, user and hashtag links. I use python regular expressions to find, http://xxx, https://xxx, #xxx and @xxx and replace it for a valid Twitter link.

Django advice

If you gonna use this code with Django, please, let me give you some advice.

“read_tweets()” download a json file every time you call it so please don’t use it in a view. It’ll delay the view too much. The tweets must be stored with “read_tweets()” and the view must read this stored tweets. You can store the tweets in a lot ways. I use a “manage.py” script added to cron to stored it in memcache, but It’s your choice.

If you gonna show the html code stored en Tweet.html_text in a Django template don’t forget use the safe tag.

{{ tweet.html_text|safe }}

The first thing you must know is that everything related to Shell is Javascript and CSS. Yeah, Javascript. Everybody knows Javascript, so it’s a great starting point. All we have to do to create a Shell extension is write down a JS file, create a CSS stylesheet, and it’s done. Easy, isn’t it?

Gnome Shell is a big thing, so explaining all you can do with the extensions isn’t the point of this post. For the moment, we’ll just play with the upper panel, but it’s possible to expand the Shell in many many ways. For example, you can add new sections in the Activities menu (by default only Windows and Applications are shown), add new search engines (besides the Google and Wikipedia ones), add new items in the user menu (A Shutdown menu entry, and not only the Suspend one!), and tons of other stuff. Just think about what would be great to have in the Shell, and go for it.

HOW TO CREATE AN EXTENSION?

Although it’s not mandatory to use it (you can write your extension completely from scratch), Gnome 3 includes a bash comand to help us to create new extensions: gnome-shell-extension-tool. We’ll use it to create the draft of our extension:

$ gnome-shell-extension-tool --create-extension

The command will ask us for some basic metadata:

• Name: A name for the extension.
• Description: A more detailed explanation for the extension functionality.
• Uuid: An unique identifier for the extension. It must be in a email address format, say foo@bar.com. By example, if your extension is named WorldDomination, and you work in DevilCorp Inc, a good Uuid should be world_domination@extensions.devilcorp.com.

Once you’ve filled that steps, the command will create some files in this path:

$HOME/.local/share/gnome-shell/extensions/world_domination@extensions.devilcorp.com/

Now we can edit that files to do what we want.

HOW TO LOAD THE EXTENSION?

When a user starts a Gnome session, the Shell will load all the extensions located in the following places:

• ~/.local/share/gnome-shell/extensions
• /usr/share/gnome-shell/extensions
• /usr/local/share/gnome-shell/extensions

But if we are developing an extension, it’s boring and time-wasting to log out and in every time we want to reload the shell. Instead of that, we can reload just the Shell, in a very easy way: Enter Alt+F2 and write “r” (reload).

OK, SHOW ME THE CODE!

If we’ve created the extension with gnome-shell-extension-tool, we can edit the extension.js file it has created:

$HOME/.local/share/gnome-shell/extensions/world.domination@extensions.devilcorp.com/extension.js

It contains a very simple extension that shows a “Hello world” message when clicking in the top bar:

// Sample extension code, makes clicking on the panel show a message

const St = imports.gi.St;
const Mainloop = imports.mainloop;

const Main = imports.ui.main;

function _showHello() {
    let text = new St.Label({ style_class: 'helloworld-label', text: "Hello, world!" });
    let monitor = global.get_primary_monitor();
    global.stage.add_actor(text);
    text.set_position(Math.floor (monitor.width / 2 - text.width / 2), Math.floor(monitor.height / 2 - text.height / 2));
    Mainloop.timeout_add(3000, function () { text.destroy(); });
}

// Put your extension initialization code here
function main() {
    Main.panel.actor.reactive = true;
    Main.panel.actor.connect('button-release-event', _showHello);
}

When we reload the Shell and click the panel, we can see this:

When Gnome Shell loads the extension, it searches the main() function. In the above code, we make the panel to be responsive to events (Main.panel.actor.reactive = true;) and connect the panel’s event ‘button-release-event‘ to execute the funcion _showHello() when the user clicks the panel.

Let’s see step by step what _showHello does:

let text = new St.Label({ style_class: 'helloworld-label', text: "Hello, world!" });

Here we create a label, with the text “Hello, world!”, and set it to use the CSS class ‘helloworld-label’. That class is defined in the ‘stylesheet.css’ file, and we can modify it if we want.

let monitor = global.get_primary_monitor();
global.stage.add_actor(text);
text.set_position(Math.floor (monitor.width / 2 - text.width / 2), Math.floor(monitor.height / 2 - text.height / 2));

Now we set the label position in the center of the main screen (we specify the main screen because we can have two or more monitors in our computer).

Mainloop.timeout_add(3000, function () { text.destroy(); });

Three seconds after the label is shown, we destroy it, so it will dissapear.

HOW CAN WE ADD ELEMENTS TO THE PANEL?

Let’s modify the extension to add a button to the panel. When the user clicks the button, the “Hello World” message will be shown.

const St = imports.gi.St;
const Mainloop = imports.mainloop;
const Lang = imports.lang;
const Main = imports.ui.main;

function PanelButton() {
    this._init();
}

PanelButton.prototype = {
    _init: function() {
        this.actor = new St.Button();
        this._label = new St.Label({ text: "HelloWorld Button" });
        this.actor.set_child(this._label);
        Main.panel._centerBox.add(this.actor, { y_fill: true });

        this.actor.connect('clicked', Lang.bind(this, _showHello));
    },

    _onDestroy: function() {}
};

function _showHello() {
    let text = new St.Label({ style_class: 'helloworld-label', text: "Hello, world!" });
    let monitor = global.get_primary_monitor();
    global.stage.add_actor(text);
    text.set_position(Math.floor (monitor.width / 2 - text.width / 2), Math.floor(monitor.height / 2 - text.height / 2));
    Mainloop.timeout_add(3000, function () { text.destroy(); });
}

// Put your extension initialization code here
function main() {
    let _panelButton = new PanelButton();
}

The button will be placed in the center of the panel, at the right side of the Calendar button. This is what will be shown when we load the extension and click the new button:

The _showHello() function remains the same. We’ve only changed the code to execute that function when we click on the button, instead of the panel.

HOW CAN I LEARN MORE?

It’s a really good question. Up to now, Gnome Shell has very few official documentation. But, as usual, you always can read some code, and search the Internet. In the Gnome’s GIT you can find a module called gnome-shell-extensions. These are some functional extensions, where you can learn how things work. It’s a good starting point. Read the README to get a description on what each extension does. But this lack of documentation isn’t going to be forever. I’m sure that soon there will be good documentation, as in every part of the Gnome desktop. Be aware of news in developer.gnome.org

The posibilities with Gnome Shell extensions are huge. Hurry up and create some of them!

Colega, ¿dónde están mis applets?

La primera sensación que tuve, tras unos cuantos minutos explorando el nuevo escritorio, es que en Gnome se han dado cuenta de que su misión es pasar desapercibido para el usuario mientras éste no lo necesite. No hay apenas barras, salvo una pequeña banda negra con la fecha y hora y poco más, los applets han desaparecido, la zona de notificaciones es mucho menos intrusiva que la de Gnome2… El escritorio llevado a su mínima expresión.

En general, estoy de acuerdo con la decisión de que así sea. Por supuesto, echo de menos algunos applets que solía usar, como le pasará a todo el mundo que lleve tiempo usando Gnome. Sin embargo, el sistema de extensiones de Gnome Shell permite crear nuevas utilidades para el escritorio. El sistema de desarrollo para estas extensiones es javascript y CSS, ambos viejos conocidos para prácticamente cualquier programador, por lo que espero que sea cuestión de tiempo que empecemos a ver sorprendentes nuevos usos del Shell.

Gestión de ventanas

El nuevo sistema para visualizar las ventanas que tenemos abiertas también es un cambio importante respecto a versiones anteriores. Como ya no existe la lista de ventanas en la barra de tareas, cuando estamos trabajando con una aplicación no podemos saber cuántas ventanas tenemos abiertas. Para ello tenemos que ir a la “Vista de Actividades”, donde tenemos algo parecido al Exposé de MacOSX, aunque más evolucionado. Quizá sea más espectacular que útil, pero si no nos convence seguimos tenemos el clásico Alt+Tab, que sigue funcionando igual que siempre.

La nueva barra de título de las ventanas, sin los botones de minimizar/maximizar también ha sido una decisión polémica. Yo personalmente estoy de acuerdo con ella. Siempre he utilizado la minimización con una única finalidad: acceder al escritorio. Con Gnome3 ya no hay escritorio al que acceder, por lo que realmente, en mi caso al menos, dejan de tener utilidad (Aunque quizá para el futuro sí que convenga tener una forma de acceder al escritorio de manera rápida . Es probable que vayan apareciendo extensiones que le vuelvan a dar una utilidad).

Aplicaciones

Y llegamos al sitio donde, lamentable, no estoy del todo de acuerdo con las decisiones tomadas en Gnome3: La Vista de Actividades. Supongo que la idea en esta vista es tener un único sitio al que acceder para hacer cualquier cosa. El problema es que, normalmente, cuando se tiene mucha funcionalidad acumulada en un mismo sitio suele ser más complicado encontrar lo que andas buscando.

El ejemplo más obvio es el menú de aplicaciones. Para ver la lista de aplicaciones ahora hay que hacer dos clicks (Actividades -> Aplicaciones). Y lo que obtenemos es un listado completo de todas las aplicaciones que tenemos instaladas. Si queremos ver, por ejemplo, los juegos, necesitaremos otro click adicional. Poco práctico para quien no tiene perfectamente claro qué tiene instalado. Además, si quieres lanzar más de una aplicación a la vez (algo bastante habitual al iniciar sesión), tendrás que acceder varias veces seguidas a la Vista de Actividades. Es un poco incómodo si lo tienes que hacer todos los días al empezar tu jornada.

Otro punto en el que creo que se han pasado de simplificación es en la Configuración del Sistema. Exceptuando el fondo de pantalla, no se puede personalizar el escritorio en ningún aspecto: Ni cambiar el tema de GTK, ni cambiar los tipos de fuentes, ni elegir el salvapantallas… ¿Será algo permanente, o simplemente una omisión temporal para poder cumplir con los plazos de publicación?

¡Viva Gnome!

Realmente, me ha costado trabajo dar con las tres o cuatro cosas que no me han gustado de Gnome3. El trabajo realizado por las cientos de personas implicadas ha sido prácticamente impecable. En general, la nota que le doy sería un sobresaliente bajo, pero estoy absolutamente convencido de que será un sobresaliente completo en muy poco tiempo.

Me queda explorar las novedades de Gnome3 para los desarrolladores: la nueva introspección de GObject, las novedades de GTK+ 3.0, etcétera. Pero lo haré en otro post más adelante.

I really feel proud of belonging to this community. Thanks to all hackers, translators, QA people, sysadmins, webmasters, release team members, marketing team members, foundation members …. Thanks for Gnome 3 !!

This morning i was thinking about it while i was reading news and drinking coffee. Sometimes it’s boring to write because you have to do it. So i’ve decided to write on this blog just for fun. And … what is fun for me ? it was my next thought . Hmmm funny question, isn’t it ?. Software obviously. But, in what way ?. I mean, which is the goal of this blog? . So i started to think about it, more and more, and finally my thoughts led me to another question : When in my daily life is fun talk about software and in what way? The answer was easy : when i talk with other hackers (and friends) about software and technology (usually while drinking beer) and when i try to explain things about software to people that they want to learn. So that’s it, that’s i was looking for! . I need to write the blog post in the same way as i talk with my friends or teach to other people.

So here i am, just thinking about software.