1) Integração com  o ctags Ctrl+] e Ctrl+t

Muito útil para projetos com vários arquivos onde é preciso navegar pela definições. Primeiro é preciso gerar a lista de tags do diretório com  o código-fonte.

ctags -R .

Se uma definição se encontra em mais de um lugar, posiciono o cursor no nome da função/definição e entro com o comando :ts ao invés do Ctrl+]

2) Tabs (:tabe) e split (:split ou :vsplit)

Utilizo para abrir vários arquivos em abas. Para movimentar entre ele utilizo “<n>gt” ou simplemente “gt“. Já o [v]split divide a tela, para alterar o foco uso o comando Ctrl+w w

3) Shell (:sh)

Acessar a shell do sistema sem fechar o editor, retorno digitando exit

4) Integração com o make (:make) e grep (:grep)

5) Tabs remotas

Este recurso só é ativado se o vim foi compilado com o parâmetro clientserver (no caso do Gentoo é a opção vim-with-x). Permite que eu abra uma única instância do vim e a medida que for abrindo os arquivos eles são visualizados nessa instância. Veja como é simples:

Cria-se um servidor:

vim --servername coding

Verifica-se os servidores disponíveis:

vim --serverlist
CODING

Aproveitando, um alias para facilitar a vida:

alias v="vim --servername CODING --remote-tab"

Depois é editar o arquivo normalmente:

v bla.c

6) Lista de definições

Uma pequena personalização no arquivo ~/.vimrc e um plug-in chamado taglist

let Tlist_Ctags_Cmd="/usr/bin/ctags"
let Tlist_WinWidth = 50
map <F5> :TlistToogle<cr>

Os comandos são auto-explicativos. O <F5> alterna a visibilidade da lista.

Lembre-se: toda documentação do vim está acessível no próprio editor, basta :help comando. É importante ler a documentação para aprender. Minha intenção não é apresentar todos os modos de utilização, o objetivo deste post é apenas mostrar algumas possibilidades de uso.

:wq

http://betterthangrep.com/

select * from flickr.photos.search where text="itajubá"

My first try to get license information was showing the pertinent part of JSON output. You could see that there isn’t a field telling that, but if you look at documentation there’s a “license” parameter.

“farm”: “5″,
“id”: “4458853758″,
“isfamily”: “0″,
“isfriend”: “0″,
“ispublic”: “1″,
“owner”: “76062736@N00″,
“secret”: “9edcd7aea8″,
“server”: “4003″,
“title”: “Clube”

Flickr! has seven options to licensing your photo (again I didn’t found in documentation, I tried each one)

• None (All rights reserved) [ license="0" ]
• Attribution-NonCommercial-ShareAlike Creative Commons [ license="1" ]
• Attribution-NonCommercial Creative Commons [ license="2" ]
• Attribution-NonCommercial-NoDerivs Creative Commons [ license="3" ]
• Attribution Creative Commons [ license="4" ]
• Attribution-ShareAlike Creative Commons [ license="5" ]
• Attribution-NoDerivs Creative Commons [ license="6" ]

My friend was looking to a way to download all photos from Yahoo! Open Hack Brazil so I decided to create a quick way to get theses photos (respecting copyrighted material). My query looks like:

select * from flickr.photos.search(0,2000) where tags="brhackday" and license="1,2,3,4,5,6"

After tests I put the URL from YQL virtual console in my Python code (that parses JSON) and generate a Shell Script to download (using curl/wget)

import simplejson
import urllib 
 
f = open("download.sh","w+")
f.write("#!/bin/sh\n")
i = 0
while True:
 
	url_base="http://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20flickr.photos.search(" + str(i) 
+ "%2C" + str(i+100) +")%20where%20tags%3D%22brhackday%22%20and%20license%3D%221%2C2%2C3%2C4%2C5%2C6%22
&format=json" 	
 
	rest = simplejson.load(urllib.urlopen(url_base))['query']
 
        if rest['count'] == '0':
		f.close()
		exit() 
 
	photos = rest['results']['photo'] 
 
	for photo in photos:
		id = photo['id']
		owner = photo['owner']
		d = "curl -s http://www.flickr.com/photos/%s/%s/sizes/o 
| egrep \"<p><img src=\" 
| sed 's/<p>//g ; s/<br \/>//g ; s/<\/p>//g ; s/<img src=\"//g ; s/\" \/>//g' 
| xargs wget ;" % (owner, id)
		f.write(d+'\n')
		i += 100
 
f.close()

Probably If you cut & paste the code they will not work due some indentation issue, so I published in gist here.

The usage I simple:

$ python flickr-d.py
$ sh download.sh

This was a extremely simple workaround but I expect you enjoy!

#include <stdio.h>
 
#define dprintf if (debug) printf
 
const char debug = 1; /* or 0 if you want disable debug */ 
 
int main(int argc, char *argv[] ) {
     dprintf ("debug message");
     return 0;
}

Remember that using printf is just one way to debug your code and an excess can impair the efficiency to analyze the situation or catch bugs. If you need start your program, specifying anything that might affect its behavior; make your program stop on specified conditions; examine what has happened, when your program has stopped or change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another; use programs such as GDB or Valgrind (especially to memory management issues)

1. Criar uma chave na API do Flickr!
2. Download do binding para acesso a API (flickrapi)

Nas distribuições Linux, um dos jeitos de instalar é usar o easy_install

easy_install flickrapi

Um modo eficaz para fazer o upload das fotos no serviço seria um script que varre e submete todas as imagens, por exemplo, de uma pasta definida. O exemplo abaixo recebe como parâmetro um diretório e busca por todos os arquivos com extensão .jpg. A função status é apenas para mostrar o andamento do upload e é executada como uma chamada callback no método flickr.upload(). Nos meus testes, precisei pegar o número definido na variável token, antes, executando na interface de linha de comando do Python os seguintes passos:

>>> api_key = "<API>"
>>> secret = "<CHAVE SECRETA>"
>>> username = "<USER>"
>>> flickr = flickrapi.FlickrAPI(api_key,secret,username)
>>> (token, frob) = flickr.get_token_part_one(perms="write")
>>> print token
>>> print frob

Na hora o browser padrão irá abrir e pedir para você confirmar o uso do aplicativo.

# -*- coding: utf-8 -*-
#/bin/python 
 
import sys
import glob 
import flickrapi
 
api_key = "<API>"
secret = "<CHAVE SECRETA>"
username = "<USER>"
 
token="<TOKEN>"
frob=None
 
def status(progress, done):
	if done:
		print "Finished ;-)"
	else:
		print "At %s%%" % progress
 
def upload(photo):
	flickr.upload(photo, callback=status)
 
if __name__ == "__main__":
 
        flickr = flickrapi.FlickrAPI(api_key,secret,username)
        flickr.get_token_part_two((token,frob))
 
        photos = sys.argv[1]+"*.jpg"
 
	for photo in glob.glob(photos):
		print "Uploading: ",photo
		upload(photo)

Um exemplo de uso:

python upload.py /Fotos

Utilize sua criatividade para extender essa idéia e criar aplicativos que ensinem e facilite sua vida.

Seguindo a filosofia code less, create more decidi fazer um script em Python que acessa a API do Twitter. Depois só configurar algum agendador de tarefas (ex.: cron) para executar o programa de tempos em tempos. Para evitar que a cada busca os mesmos twitts sejam publicados há um arquivo chamado .hashunifei que grava o número de identificação (id) das mensagens publicadas.

# -*- coding: utf-8 -*-
# Tiago Maluta <maluta@unifei.edu.br> 
 
import simplejson, urllib
import twitter 
 
list_id = []
api = twitter.Api(username='USUARIO', password='SENHA')
 
SEARCH_BASE = 'http://search.twitter.com/'
url = SEARCH_BASE + "search.json?q=UNIFEI+OR+efei"
 
def publish(user,text):
	twitt = "RT @"+user+" "+text
	if len(twitt) > 140:
		twitt = twitt[:140]
	api.PostUpdates(twitt)
 
result = simplejson.load(urllib.urlopen(url))['results']
 
with open(".hashunifei","r+") as f:
    data = f.read()
    list_id = data.split(",") 
 
f = open(".hashunifei","a")
for twitt in result:
 
	text = twitt['text']
	user = twitt['from_user']
 
	if user != "hashunifei":
		id = str(twitt['id'])
		if id not in list_id:	
			list_id.append(id)
			f.write(id+',')
			publish(user,text)
f.close()

Se quiser testar o código-fonte (lembre-se de mudar o usuário e senha e a palavra da busca)

$ touch .hashunifei
$ wget http://github.com/maluta/junk/raw/master/hashunifei.py

Limitações: A mensagem é truncada em 140 caracteres (limite do twitter).

Eu sinceramente não sei se é assim que o pessoal faz, foi a primeira idéia que tive…, se o pessoal que entende de web quiser colaborar seria ótimo.

int x = 1;
if (*(char *)&x == 1)
/* little endian */
else
/* big endian */

Using GCC you can use -mbig-endian or -mlittle-endian to generate appropriate endianess. Remember to check man pages section on your architecture (i.e: i386 and x86-64 don’t implement this option whilst IA-64 and ARM yes)

One interesting point regards on byte swapping. Suppose that you have a file that starts with 0xaabbccdd referring to little endian and 0xddccbbaa referring to big endian (note that I took these values and order arbitrarily). In order to use one kind of byte order in your code we need check what endianness your file was generated and if necessary rectify. This C++ code exemplifies.

class Endian {
 
     int _byteSwapped;
 
public:
 
     Endian(unsigned long dw) {
 
        if (0xaabbccddL == dw) _byteSwapped = 1;
        else if (0xddccbbaaL == dw)  _byteSwapped = 0; 
        else throw "error";
 
     }
 
     long rectify(long dw) const {
 
        if (!_byteSwapped) return dw;
        char result[4] = {((char*) &dw)[3],((char*) &dw)[2],((char*) &dw)[1],((char*) &dw)[0]};
        return (*((long*) result));
 
     }
};

Another way to do byte swapping is using an macro. The following example swap two bytes:

#define SwapTwoBytes(data) ( (((data) >> 8) & 0x00FF) | (((data) << 8) & 0xFF00) )

One of the best practices is provide one software that will work correctly no matter which processor Endian-architecture the code is executed on, eliminating the need to rewrite the code. Intel has a interesting paper on Converting Endian-specific to Endian-neutral Code (pg. 15-16).

• IBM DeveloperWorks about Inline asssembly for x86 in Linux
• Linux Documentation Project HOWTO describing GCC Inline Assembly

The syntax may be confusing, if you don’t understand read the documentation available. Each example are an C function with the special construct “asm” for inline assembly code. Examples:

Increment an value:

void inc(int *value) {
 
    asm ( "incl %0"
         :"=a"(*value)
         :"0"(*value)
        );
 
}

Exchange to numbers:

void swap(int *x, int *y) {
 
    asm(""
        : "=a"(*y),"=b"(*x)
        : "a"(*x),"b"(*y)
       );
 
}

Copy an vector:

void vector_copy(int *v_src, int *v_dst, int *count) {
 
    asm("up: lodsl;"
	"    stosl;"
	"loop up;  "
	:
	: "S"(v_src), "D"(v_dst), "c"(*count)
	: "%eax"
	);
 
}

A simple copy:

void copy(int *from, int *to) {
 
     asm ("movl %1, %%eax;"
          "movl %%eax, %0;"
          :"=&r"(*to)
          :"r"(*from));
 
}

A very simple implementation for strncpy:

void _strncpy(char *src, char *dst, int *count) {
 
    asm("cld;"
        "rep movsb;"
        :
        : "S"(src), // 'S' == %esi
	  "D"(dst), // 'D' == %edi
	  "c"(*count)); // 'c' == %ecx
}

If you like to try check this example:

wget http://github.com/maluta/junk/raw/master/asm-inline.c
gcc -Wall -ggdb asm-inline.c -o asm-inline
./asm-inline

• Otimização é importante
• Mas frequentemente: Código legível é mais importante
• Aprenda o que seu compilador faz
  E então deixe-o fazê-lo.

Exemplo. As quatro instruções abaixo fazem a mesma coisa, zeram um registrador da CPU x86, qual é a melhor forma?

Analisando no GDB (x/FMT ADDRESS) temos:

movl  0xb8    0x00    0x00    0x00    0x00
andl  0x83    0xe0    0x00
subl  0x29    0xc0  
xorl  0x31    0xc0
 

E agora? sub ou xor, veja que ambos produzem uma falsa dependência em %eax, mas a CPU sabe como ignorar no caso do xor.

Você sabia?

O compilador sim.

Se você usar o sub na prova seu professor provavelmente irá descontar alguns pontos ou te dar zero…

• Se você fizer uma otimizacão, teste em dados reais.
• Se tornar o código ilegível não tornar o programa drasticamente rápido, não faça.