Alfonso Jiménez

TwitterContacts

alfonso — Mon, 17 Nov 2008 16:20:11 GMT

TwitterContacts is just a simple application that I built in a few nights. It’s purpose is to provide an option to check out which of the people who you are following on Twitter are not following you. Simple, clear, easy and all-in-one-page.

Someone asked me about the real value contributed by this application. Apart from the purpose, I think the real value is that you can get the code here (GPL). Anyway, doing this was just a pastime.

2008, un año más

alfonso — Mon, 17 Nov 2008 15:38:58 GMT

Como todos los años, 2008 ha sido un año singular. Un año en el que los que se supone que saben ganan a los que sin duda no saben. Para muchos, 2008 será recordado como el año en el que se demostró que los ricos también lloran.

Para otros sin embargo, ha sido el año donde perdieron a su padre, a su hija o a su mejor amigo. Ha sido el año en el que durante unos días el pan no llegaba a nuestras casas.

2008 ha sido el año en el que se cumplió un sueño donde las personas no son juzgadas por el color de su piel sino por su caracter. El sueño de la esperanza, el sueño americano.

Ha sido el año en el que algunos volvieron a saborear la libertad, y otros perdieron la libertad que nunca debían de haber tenido.

Para los más deportistas, este año quedará en sus corazones como el año en el que dijimos: “sí, podemos” y pudimos. Y como ocurre todos los años, siempre mueren los buenos de las películas.

2008 también ha sido el año en el que la ciencia progresa a pasos agigantados y los gigantes no entienden de crisis. Ha sido el año de la esperanza, donde las comunidades libres avanzan, y con ellas avanzamos todos.

2008 ha sido un año más.

Visualization of a Phing buildfile

alfonso — Thu, 30 Oct 2008 19:50:08 GMT

Raphael Stolt published a method to get a visualization of a Phing buildfile a few days ago:

Out of the box the Phing -l option can be used to get a first overview of all available targets in a given buildfile but it doesn’t untangle the target dependencies and sometimes a picture is still worth a thousand words. Luckily the Ant community already provides several tools to accomplish the visualization of Ant buildfiles, reaching from solutions that apply a Xslt stylesheet upon a given buildfile.

He uses the ant2dot tool and the Graphiz library to show the XML from a buildfile into a graphic. The image represents the flow of the build.

Via | Raphael Stolt

Webgrind: A web frontend for Xdebug

alfonso — Fri, 17 Oct 2008 11:11:37 GMT

Webgrind is a web frontend for the popular Xdebug. Written by Joakim Nygård and Jacob Oettinger, Webgrind parses the Xdebug output and shows it on a dropdown table.

It doesn’t make such a big job, but it’s nice to see the result on a clean interface. The last release is 0.81, and you can get it from Google Code.

Rasmus, Think again!

alfonso — Wed, 15 Oct 2008 15:43:37 GMT

I would like to share with you my friend Arno’s slides. He expounded this presentation during the last PHP Conference in Barcelona. He gave a speech on the usage of frameworks and software components in order to build PHP applications.

The famous Rasmus Lerdorf’s dixit is shown up in these slides, via some amusing examples: Frameworks are performing poorly. Arno prooves this statement using a Hello World application, and yes, Rasmus is right and framework performances suck for Hello Word applications.

10 ways to demotivate your team

alfonso — Sun, 28 Sep 2008 19:56:36 GMT

Set up impossible deadlines.
Let them work overtime.
Don’t allow breaks.
Place a ban on laughing.
Break the coffee machine.
Don’t shield them from the dirty daily business.
Don’t challenge them.
Underpay them.
Bribe them.
Infiltrate a team member who is demotivated anyway.

Seen on Manuel Klimex

Google 404

alfonso — Wed, 27 Aug 2008 11:44:33 GMT

I gotta say, I had thought this before. Google provides a new way to enhance 404 pages. If our visitors get a not found error, we can give them some alternatives using a simple Google snippet. This code provides the closest match (for the URL) and other things to try such as search into the site. This is useful information designed to help them find the information the users need.

You can read more about it on the Official Google Webmaster Blog.

Closed for holidays

alfonso — Wed, 30 Jul 2008 17:14:03 GMT

Closed for holidays. I’ll be in Japan until 15th August. I think I deserve a rest. Up until then, have a lovely summer.

Multiple Constructors in PHP

alfonso — Tue, 29 Jul 2008 21:02:25 GMT

As you probably know, it’s possible to have multiple constructors in Java. They need to have the same name as the class, and they can only be distinguished by the number and type of arguments. In PHP5, you can only have one constructor. You can define it using the reserved word __construct. If the __construct function doesn’t exist, PHP5 will search for the old-style constructor function (by the name of the class). So if we cannot have multiple constructors, how could we create objects with different initial conditions? It’s not a big deal. There’s a pattern called Factory Method, which defines virtual constructors using static methods. Let’s see an example:


class Person
{
    private $name;
    private $email;

    public static function withName($name)
    {
        $person       = new Person();
        $person->name = $name;

        return $person;
    }

    public static function withEmail($email)
    {
        $person        = new Person();
        $person->email = $email;

        return $person;
    }

    public static function fullPerson($name, $email)
    {
        $person        = new Person();
        $person->name  = $name;
        $person->email = $email;

        return $person;
    }
}

We have a class called Person which contains 2 private attributes: name and email. It also has 3 static methods: withName, withEmail and fullPerson. These methods will behave like constructors.

So if we want to create a Person object just with the name value, we can do it using the following statement:


$person = Person::withName('Example');

7 tips to write intelligible code

alfonso — Sun, 27 Jul 2008 12:52:41 GMT

Writing intelligible code helps to increase the productivity of a developing team, even if you are an independent worker. Why is it so important to write intelligible code? How can it improve the productivity of my team? A messed up code could delay your partners understanding, or it could create a barrier for new developers. Even trying to understand your own code could be a real challenge as well. Here are 7 tips of how to make more intelligible PHP code (coding style tips):

75-85 characters per line: Each line must contains approximately 75-85 characters. If a line exceeds more than 85 characters, consider splitting the line into multiple lines. It will be helpful for code readability. You can see a great post on this topic in Paul Jones’ blog. He talks about why this limitation is not really arbitrary, and he puts some brilliant examples such as this one:
Bad
```
list($foo, $bar, $baz) = array(Zim::getVal('foo'), Dib::getVal('bar'), Gir::getVal('baz', Gir::DOOM));
```
Good
```
$foo = Zim::getVal('foo');
$bar = Dib::getVal('bar');
$baz = Gir::getVal('baz', Gir::DOOM);
```

Assignment statements: Assignment statements ought be aligned for better readability. Let’s see an example:

Bad


$example = 'string_value';
$anotherExample = 42;
$exampleInst = new ExampleClass();

Good


$example        = 'string_value';
$anotherExample = 42;
$exampleInst    = new ExampleClass();

4-spaces block indentation: Use an indent of 4 spaces with no tabs. It helps to avoid problems with diffs, patches and SVN history. It helps the readability as well. Usually tabs are 8 spaces length, which means a 5th-block indent starts 40 spaces from the left border (nearly to 50% of a code line).
```
{block1}
    {block2}
        {block3}
            ...
```
Control & conditional structures: These statements must have one space between the control keyword (if, else, for, while, …) and the opening parenthesis, to distinguish them from function calls (which obviously don’t have a space). It’s nice to always use curly braces because they help to decreases the likelihood of logic errors.
```
if ($display === 1) {
    while ($obj->next()) {
        echo $obj->toString();
    }
}
```
Class and function/methods declarations: Class and function/methods declarations have their opening brace on a new line.
```
class Foo
{
    private $_obj;

    public function __construct($obj)
    {
        $this->_obj = $obj;
    }
}
```
Comma-space between items of a list: When we list some items, it’s nice to separate them clearly with a comma followed by a space.
BAD
```
$example = array(Foo::get('key',2),$value,true);
```
GOOD
```
$example = array(Foo::get('key', 2), $value, true);
```

Use constants properly: If we have a method which returns some status codes, it’s nice to use literal constants. Having descriptive constants helps to make better intelligible code. For example:

BAD


class Foo
{
    public static function getStatus()
    {
        $res = 0;

        if (!self::isValid()) {
            $res = 1;
        }
        ...

        if ($res === 0 && self::isRepeated()) {
            $res = 2;
        }

        return $res;
    }
}

GOOD


class Foo
{
    const STATUS_SUCCESS  = 0;
    const STATUS_FAILURE  = 1;
    const STATUS_REPEATED = 2;

    public static function getStatus()
    {
        $res = self::STATUS_SUCCESS;

        if (!self::isValid()) {
            $res = self::STATUS_FAILURE;
        }

        ...

        if ($res === self::STATUS_SUCCESS && self::isRepeated()) {
            $res = self::STATUS_REPEATED;
        }

        return $res;
    }
}

These tips are just some coding style tips. If we really want to write intelligible code, we would keep in mind many more things like to use software patterns, to make use of well established software practises, …