This show will be about Python and Open Source community, and I’ll talk about the upcoming PyCon in Atlanta.

Join us at Live TWiT TV.

Nesta próxima quarta-feira, dia 10 de fevereiro às 19:30, horário de Brasília – 13:30 horário do Pacífico – eu terei o prazer de participar da gravação do FLOSS Weekly com Randal Schwartz e Leo Laporte.

Neste show falaremos sobre comunidades Python e Open Source, e eu vou falar sobre a PyCon em Atlanta que acontecerá na próxima semana.

Participe conosco em Live TWiT TV.

Até lá!

For some reason, the Graphviz version installed on my Mac is generating corrupted PNG files. Fortunately, it supports many other formats including SVG which has the greatest results.

To add SVG format support into sphinx.ext.graphviz, I had to do a little refactoring:

1. Moved the default hardcoded PNG format to a configuration variable named graphviz_output_format;
2. Render the object tag to display SVG files properly on Firefox and Safari.

I had to use the object tag because Firefox can’t render SVG with the img tag. Read more about cross browsing SVG issues.

To use it, follow these steps:

1. Create an _ext subdirectory on your Sphinx project;
2. Download the modified extension from Gist and save it to _ext;
3. Edit your config.py and make sure it contains the below lines;

sys.path.append(os.path.abspath('_ext'))
extensions = ['graphviz_svg']
graphviz_output_format = 'svg'

Por algum motivo, todos os arquivos PNG gerados pela versão do Graphviz instalada no meu Mac ficam corrompidos. Felizmente o Graphviz suporta outros formatos, dentre os quais o SVG tem um resultado simplesmente fantástico.

Para adicionar o suporte ao formato SVG na extensão sphinx.ext.graphviz, fiz uma simples refatoração no código para:

1. Mover a definição padrão do formato PNG que estava hardcoded para a opção de configuração graphviz_output_format;
2. Adicionar a renderização da tag object para exibir a imagem SVG corretamente no Firefox e no Safari.

Precisei usar a tag object, pois o Firefox não exibe SVG através da tag img. Leia mais sobre esse inconveniente.

Para usar a extensão, basta:

1. Criar um subdiretório _ext no seu projeto Sphinx;
2. Fazer download do código da extensão modificada no Gist e salvá-lo no diretório _ext;
3. Editar o config.py do seu projeto Sphinx para conter as linhas abaixo:

sys.path.append(os.path.abspath('_ext'))
extensions = ['graphviz_svg']
graphviz_output_format = 'svg'

[]‘s!

My idea was to type one command and get right into the repository directory. I’d like it to happen within a subshell so I would not need to deactivate the virtual environment. All I would need to do is press CTRL+D to exit the subshell and close my sandbox.

To accomplish it, I managed to write this scratch shell script function:

function work () {
    typeset env_name="$1"
    if [ "$env_name" = "" ]
    then
        virtualenvwrapper_show_workon_options
        return 1
    fi

    virtualenvwrapper_verify_workon_environment $env_name || return 1

    echo "source ~/.profile
          workon $env_name
          cdvirtualenv
          cd src" > ~/.virtualenvrc

    bash --rcfile ~/.virtualenvrc
}

Having virtualenv and virtualenvwrapper installed on your system, just append this function to the end of your .profile or .bash. And type: work envname.

[]‘s!

However, it’s not uncommon to see people complaining that by following this directions, their project never get to the make it fast stage. That happens because of a misconception where people treats these three steps as isolated actions of a project. And they are three stages of one development task.

While you start a development task, you have an early stage where you need to explore possibilities. You don’t quite know what is the best approach but have some ideas. If during that stage you go big looking for THE piece of code that will fit the problem perfectly, you will end up spending a considerable amount of time on that quest. That’s because you have too many uncertainties on your solution and you need to discover through experimentation to reduce those uncertainties to a comfortable amount so you can focus and implement your code. This experimentation process is the Make it Work stage where you just code to achieve the desired behavior or effect.

Just after that, you’d probably discovered what kind of libraries you will use, how the rest of your code base interacts with this new behavior, etc. That’s when you go for refactoring and Make it Right. Now you dry things out and organize your code properly to have a good design and be easily maintainable.

As Software Developers, we know it’s true that restrictions are everywhere. And for this we know that there are tradeoffs between design and performance. This is when you go for the last stage where you Make it Fast by optimizing your code to achieve the needed performance. By doing this at this point, you will see that it will require much less effort. That’s because you can focus on the small 20% of code you can tune to end up with a 80% performance increase.

Ending all those three stages, you will reach the end of your development task and can integrate this code into your project, delivering the desired value to your Product Owner.

If you ignore one of those steps while you’re coding that one task, you will probably suffer the effects of doing big design up front, increasing technical debit, and having a awful system performance.

That said, a last piece of advice: Be careful not to compensate bad time estimations delivering code that only “works”. If you do it as a rule, I assure you that you will end up with some non-tested spaghetti project where your cost of change will be so high that can put your business at risk and make your “agile” useless.

While talking about the agile values. It’s common to see manager’s eyes glowing when you reach the concept of Embracing the Changes. Unfortunately it’s also common that they end up with the wrong idea of how to put it into actions.

I heard of stories where managers misunderstood the concept, and pressured by external forces, used it as a mantra to turn developers into firefighters. They needed to “embrace the change” and fight more than one firestorm at the same time, having their work interrupted by the manager whenever flames gained height.

He was doomed from the beginning! What about really stop the fire? What about not setting the fire in the first place? The result could not be different. His got everything burned out saying “Agile doesn’t work! It made my team unproductive”.

If you are a manager, don’t fool yourself! You can’t be agile buying a box. The traditional culture and miss-behavior affects you as well as your team. Revalue your truths and establish a better way of making things happen. Enjoy the ride with them.

More than speak about professional behavior, Kent Beck describes by example the psychological structure of a software developer at work.

In a more deep sense, this is a talk about self-awareness, getting real, and getting things done. So even if you’re not a programmer, I recommend it.

It’s very important to have the habit of spend some time finding the right links to reference in a blog post. Links are extremely powerful! It can turn a post into a knowledge hub.

Adding much relevant links as possible to your posts, not only add value to your text but gives credibility to it. It works just like bibliography in books.

Those articles were somehow superficial and focused too much on people “immediate” (as in chat) communication and collaboration. Like instant messaging wasn’t real time enough so Google came up with an upgrade with it’s new web application.

IMHO that’s only the tip of the iceberg. It’s not simply an improved way of communication. Putting directly: Google Wave is not about text it’s about data!

In order to understand Google Wave, we need to take a look at Google’s mission. If you visit the company’s website you can read it: “Google’s mission is to organize the world’s information and make it universally accessible and useful.”

Today they already know the current state of most somewhat-static data. Google’s Search Engine robots crawl’s the entire web gathering data from web pages processing html and the related separating presentation data and scripts from semantic data. They actually do a nice work and as the time passes they can identify trends and people’s behavior.

To fulfill it’s mission, Google needs more. It must know all information, at least all publicly available information by the time it is created, so Google can reduce the lead time for organizing and make it useful and available.

So here enters the new Google Wave, that will act as a distributed data processing pipeline.

Google’s announced that it was a new platform for communication and collaboration. But, this wave can go deep into the “communication” definition, transcending the simple layer that we all know about exchanging text messages to describe ideas, and build it’s representation: a document.

That’s not the first time Google tried something like that. Google Base was an attempt to group data and enable people to publish it. But Google Base wasn’t “fluid” and collaborative enough. There are lot’s of data that should be kept private and those data are stored in specific in house ways. This works as an entrance barrier, turning Google Base integration, a task with little appeal.

Google Wave solve this problem by being an open source platform divided in Client, Server and Protocol based on a real-time publishing strategy using the operational transformation technology.

This enables companies to have their on Wave Servers where some waves are kept private and other can be shared with another Wave Servers through the Google Wave Federation Protocol.

So basically any person’s action in the real world could generate a Wave transformation. Imagine that you buy something with your credit card. Your bank’s robot could publish this transaction, then your company’s ERP system could have a robot that monitors that wave and updates the company’s private cash flow wave, hosted on your own wave server.

Another internal robot, then updates the company’s public balance that is available in some shared wave that is visible to the internet through the Wave Federation Protocol providing transparent real-time information to investors that could have robots capable of using Wave’s Playback features to analyze the balance document history and evolution through time.

This new way to transit and persist data make lot’s of sense if you analyze Google’s effort’s on developing it’s distributed storage named Big Table and making it available to users through Google App Engine. Then you can see a strong movement on the web development community to study and improve persistence strategies with initiatives like CouchDB.

It’s a new way to think the dynamics of data life cicle. It’s a new change from a imperative way of computing and storing data, defining how it is persisted at the minimal structured level, to a more declarative way of publishing data changes and letting the structure evolve as needed.

As part of a selling processes, a friend had to fill up three documents with his client’s information: a letter, a label, and a warranty card. Doing this manually was extremely error prone and annoying.

So what if he could type his customer’s data once and get all the three documents ready to print? That’s what the Autoword Project do!

Autoword Project opens a Cocoa window with an input form and a “generate” button. The user enters the customer data and Autoword generates PDF files ready to print based on the given Microsoft Word 2008 for Mac template documents.

I had no intentions to create a generic program, since I had little time to do it and it was my first Applescript initiative. Instead I focused on develop a simple XCode Applescript Application that could serve as baseline to anyone who has similar needs. So adapting Autoword Project is simply a matter of:

1. Set up the fields you need into the Cocoa window;
2. Create a Word for Mac docx template file with the proper docvariable fields;
3. Reference your template files in the beginning of the autoword.applescript;
4. Adapt the buildDocument procedure to pass on your data if you changed the Cocoa form.

You can clone Autoword Project repository at GitHub. I encourage you to fork the project and improve it at your will. And if you have more ideas, it would be great to hear, so please drop me a comment.

This simplifies the process of adding multiple issues from:

1. click on new issue;
2. describe and save it;
3. get redirected to the saved issue details;
4. click on “new issue”.

To just:

1. click on “new issue”;
2. describe, save and continue.

This is very useful! And could be better if Redmine didn’t reset the entire form, making the user set every issue attribute again.

To solve this problem, I made this little patch that enables a new issue to inspire itself on another issue.

It was done by adding the method inspire_on to the issue model plus adding 2 lines to it’s controller. This probably isn’t the best way to do it, since Redmine supports plugins. But it’s my first Ruby on Rails code, so that’s fine.

I’ve tested the patch against the stable releases 0.8.1 and 0.8.2, and the result is really worthy. Enjoy!