Stiod Blog

Você que utiliza algum *nix da vida já deve ter passado pelo momento mágico de ter executado o comando make em algum código fonte, não?

O make (GNU make) é uma ferramenta que executa os comandos inclusos dentro de um arquivo. É normalmente utilizado na compilação e instalação de programas.

Uma das vantagens do make é que ele identifica quais partes do programa devem ser recompiladas de acordo com as mudanças efetuadas desde a última compilação.

Dependendo do tamanho do programa pode-se economizar minutos ou horas entre as recompilações, pois não será necessário recompilar o programa inteiro.

Exemplo de uso:

$ make -f arquivo_com_os_comandos

Se você chamar o comando make sem passar nenhum parâmetro ele tentará utilizar o arquivo com nome de Makefile do diretório atual.

É o que normalmente acontece quando você precisa compilar e instalar um programa pelo código fonte.

• Descompactar o código fonte (se for um "*.tar.gz").
• Entrar na pasta descompactada. Haverá um arquivo Makefile dentro.
• Executar o comando "make" para compilar.
• Executar o comando "make install" como root para instalar.

Makefile

Se você quiser utilizar o comando make só é necessário criar um arquivo Makefile e dentro dele colocar as instruções que o make deve executar.

Formato do Makefile:

regra: dependências...
	comandos
	...

Os comandos são comandos normais do shell (bash). Pode-se colocar vários comandos, porém devem estar identados com tabulações. Isto é importante, não utilize espaços pois não irá funcionar.

A regra é só um nome para identificar um bloco de comandos. Fazendo uma analogia com programação, a "regra" seria semelhante a uma função.

As dependências são os arquivos necessários para a execução dos comandos da regra, o make irá fazer a verificação deles. Também podem ser outras regras que serão chamadas antes da execução dos comandos. Se houver mais de uma dependência elas devem ser separadas com espaços.

Aqui vai um exemplo de um Makefile que compila um programa em C:

program:
	gcc -o meuprograma meuprograma.c

Um exemplo com dependências:

program: cod1.c cod2.c lib1.a
	gcc -c cod1.c cod2.c
	gcc cod1.o cod2.o lib1.a -o program

lib1.a: lib1.c cod3.c
	gcc -c lib1.c cod3.c
	ar rcs lib1.a lib1.o cod3.o
	ranlib lib1.a

Pode-se utilizar variáveis também. A declaração é simples, mas devem ser chamados com a notação "$(variável)". Repare também que elas podem ser concatenadas:

CC=gcc
CFLAGS=-O2
CFLAGS=$(CFLAGS) -Wall

program:
	$(CC) $(CFLAGS) -o program program.c

Olha que legal no Makefile a seguir, advinha o que acontece ao executar o comando `make clean' no terminal?

program: program.c
        gcc -o program program.c

clean:
        rm *.o
        rm program

O que aconteceria também se houvesse um arquivo no diretório atual que se chamasse "clean"? O `make clean' não iria executar a lista de comandos da regra. Para evitar este tipo de conflito utilize a regra ".PHONY":

program: program.c
        gcc -o program program.c

.PHONY: clean
clean:
        rm *.o
        rm program

Agora a regra "clean" será executada mesmo se houver um arquivo no diretório atual com mesmo nome.

Hoje vou mostrar como fazer uso da API do Twitter para Python, a Python Twitter API. Sua utilização é bem simples e podemos criar vários aplicativos ou scripts para automatizar algumas tarefas no microblog, como o script que fiz no meu último post.

Instalação no Linux
Baixe o código fonte da última versão aqui.

Descompacte com o comando:
$ tar -zxvf python-twitter-XXX.tar.gz

Após descompactar entre no diretório criado e execute o seguinte comando como usuário root:
# python setup.py install


Utilização
Para utilizar a API importe o módulo twitter:

import twitter
...

As principais classes que você deve conhecer são:
twitter.Api
twitter.User
twitter.Status
twitter.DirectMessage

Para iniciar, crie uma instancia da classe twitter.Api:

import twitter
api = twitter.Api()

Com este objeto você pode utilizar os métodos da API que não necessitam de autenticação do usuário. Um Exemplo é o método GetPublicTimeline, que sem parâmetros retorna as últimas 20 mensagens de status dos usuários.

import twitter
api = twitter.Api()
status_list = api.GetPublicTimeline()
for status in status_list:
    print status.user.name

No exemplo anterior o status é um objeto da classe twitter.Status. A classe twitter.Status possui um atributo user que é um objeto da classe twitter.User.

Para realizar a autenticação de um usuário, instancie a classe twitter.Api, porém passando o usuário e a senha como parâmetros:

import twitter
api = twitter.Api(username='joao', password='abc123')

Para enviar uma mensagem utilize o método PostUpdate:

# -*- encoding: utf-8 -*-
import twitter
api = twitter.Api(username='joao', password='abc123')
status = api.PostUpdate('''Yohohoho! Enviei uma mensagem! Mas cuidado
com os limite de 140 caracteres.''')

Repare que ele retorna o status da mensagem enviada.

Várias mensagens contínuas
Um método interessante da API é o PostUpdates, que permite que seja enviada uma mensagem com mais de 140 caracteres. A mensagem na verdade é enviada como se fosse várias mensagens com no máximo 140 caracteres.

Você também pode indicar uma string de continuação no segundo parâmetro, esta string é colocada no final das mensagens para indicar a continuação.

# -*- encoding: utf-8 -*-
import twitter
api = twitter.Api(username='joao', password='abc123')
status = api.PostUpdates('''Yohohoho! Enviei uma mensagem bem grande!
Agora você não precisa se preocupar com o tamanho da mensagem pois
este método irá dividi-la para você em várias mensagens, você também
pode utilizar uma string de continuação ao lado.''', '…')

Obs: Segundo a documentação da API, o Twitter remove as reticências ("...") das strings das mensagem, por isso utilize o caractere UNICODE \u2026 ("…"). Também não ultrapasse o limite dos 150 requests permitidos por hora pelo Twitter.

Olá galera,

Hoje vou dar uma dica sobre geração de pacotes utilizando o Subversion.

O cenário é o seguinte: você desenvolve um projeto que utiliza o SVN como controlador de versões.
Periodicamente, você deve enviar pacotes para o cliente com atualizações do sistema (novas implementações, correções, ajustes, enfim...).
Entretanto, tais pacotes são incrementais, já que não é necessário enviar toda a estrutura do sistema a cada atualização.

Pelo Windows, é possível fazer a exportação dos arquivos mediante a utilização da ferramenta TortoiseSVN.
Através da opção Log, é obtido o histórico das revisões. Com base nesse histórico, podemos selecionar a última revisão que fora enviada ao cliente e a revisão desejada, comparar as revisões (a fim de obter os arquivos alterados) e, finalmente, exportá-los para uma pasta que manterá a estrutura do sistema.

Continue Reading »