Software Livre:

Há sempre uma velha discussão de que o importante é “ser livre”. Apóio com certeza o “movimento”, inclusive ainda participo, mas tenho prioridades profissionais que é a satisfação do cliente. Sem dúvidas excelentes softwares são livres e é sempre uma primeira carta na manga na hora de executar algum serviço, principalmente em suporte. Mas não é solução única que faz milagres, ou que temos alguma obrigação de contribuir, pois afinal, não recebo patchs de alimentos, nem release candidate de carros, pre-alpha no cinema, beta de celulares, e muito menos donations por paypal para dedicar tempo exclusivo.

Software Proprietário:

Falando de uma maneira “politicamente (in)correta”, é visto com péssimos olhos pela grande massa de xiitas causando diversos conflitos de intelectualidade entre profissionais da área, como a de prestação de serviços. Mas que resolve tantos problemas quanto outros onde não há uma alternativa mais confiável. Mesmo assim muita gente não enxerga isso como uma solução, mas sim como um problema, simplesmente por alguma ética ou filosofia. (Ainda bem que não tinha nenhum xiita na mesa).

Software Proprietário baseado em Software Livre:

São soluções muito visíveis no mercado atualmente. Soluções de sistemas embarcados, onde a maior parte da base do produto é feita com software livre e o código principal é todo compilado ou gerado um bytecode. Assim é possível oferecer um sistema com uma base íntegra, confiável e todo um sistema que atende a necessidade do cliente no qual nenhum outro oferece.

Garantia:

Uma empresa quer sentir confiança no serviço prestado. Ela quer ficar tranquila de que se algum problema ocorrer, haverá uma solução imediata. Mas para isso é necessário todo um comprometimento do serviço prestado. Seja ele em software livre ou software proprietário, deve haver uma garantia de atendimento/suporte em nível de extrema excelência para solucionar qualquer tipo de problema que a empresa possa enfrentar. A empresa quer buscar além tudo, uma continuidade do serviço prestado e nunca fica na mão num problema.

Suporte:

É onde todos saem ganhando. A empresa que contrata, pois tem a garantia de que eventuais problemas serão resolvidos, e da empresa prestadora de serviços que se mantém vinculado por contrato e, com isso, irá aprimorar ainda mais seus produtos.

Divergência:

Esse o ponto crítico onde queria chegar. Devido a diversos extremos, pode haver conflitos de filosofias e éticas entre profissionais onde quem sai perdendo é a empresa que contrata o serviço. Para evitar dois pensamentos básicos resolvem:

Imparcialidade: Primeiro deve-se levar em conta o que o cliente quer. Parece óbvio mas se o cliente quer uma caixa preta, mesmo que tenha sido sugerido uma caixa azul, a caixa terá que ser feita na cor preta e ponto final. Não importa as vantagens e desvantagens apresentadas, tem que ser feito o solicitado.

Interoperabilidade: É fato. Há cada vez mais ambientes heterogêneos e temos que estar preparado para isso. O cliente pode possuir servidores windows, linux, novel, unix, solaris e também desktops windows, linux, mac, beos, etc… Onde também há diversas aplicações críticas fortemente amarradas em cada, onde o porte para alguma outra plataforma seria inviável.

Senso Crítico Profissional:

O profissional deve resolver o problema com a melhor solução viável possível. Seja ela livre, proprietária ou mista é dever de quem presta o serviço garantir a total eficácia da solução do problema, e não trazer um problema a mais por motivos de divergências

E encerro essa discussão. Acho que daria um livro maior que do Musashi tudo a ser dito, mas como ficamos sem pizza de sorvete deixarei pra uma próxima vez!

Link para consulta militonto-xiita.

Todas as funções são documentadas nas man pages, e as mesmas estou usando como base. As funções dos exemplos tem as mesmas declarações para melhor ser assimilado na consulta. Para ubuntu users: $ sudo apt-get install manpages-dev

Função strstr():

char *strstr(const char *haystack, const char *needle);

A função strstr() procura a primeira ocorrência de uma string (needle) em outra string determinada (haystack). Caso a condição seja satisfeita, um ponteiro com posição da ocorrência será retornado. Caso contrário, NULL será retornado.

(Para melhor visualizar, faça o download do fonte: strstr_ex.c)

#include <stdio.h>
#include <string.h>

int main(int argc, char **argv) {

        char *haystack = "Essa eh uma frase de exemplo para encontrarmos uma string.";
        char *needle = *(argv+1);
        char *ret;

        /* Ha alguma ocorrencia de needle em haystack? */
        if ((ret = strstr(haystack, needle)) != NULL) { 
                fprintf(stdout, "needle ENCONTRADO\\n");
                /* O retorno eh o ponteiro para a primeira ocorrencia em diante. */
                fprintf(stdout, "retorno: %s\\n", ret);
        } else
                fprintf(stdout, "needle NAO ENCONTRADO\\n");

        return 0;
}

ip_fix@konoha:~/C$ gcc -Wall -o strstr_ex strstr_ex.c
ip_fix@konoha:~/C$ ./strstr_ex teste
needle NAO ENCONTRADO
ip_fix@konoha:~/C$ ./strstr_ex exemplo
needle ENCONTRADO
retorno: exemplo para encontrarmos uma string.
ip_fix@konoha:~/C$ ./strstr_ex encontrarmos
needle ENCONTRADO
retorno: encontrarmos uma string.
ip_fix@konoha:~/C$


Como esperado, quando há uma ocorrência satisfeita o ponteiro é retornado a partir desse resultado.

Função strdup():

char *strdup(const char *s);

A função strdup() é muito útil em situações onde temos que alocar um espaço na memória para copiar determinada string. Sem utiliza-lá, teríamos que alocar o espaço antes com malloc(), para em seguida usar strncpy(), por exemplo, para copiar a string. A função retorna um ponteiro com a string já alocada (podendo ser liberado com free() depois de seu uso) em caso de sucesso, ou ENOMEM como erro caso a memória não tenha sida alocada por insuficiência.

(Para melhor visualizar, faça o download do fonte: strdup_ex.c)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char **argv) {

        char *string;
        char *s = *(argv+1);

        /* SEM strdup() */

        /* Alocamos a memoria com malloc(). */
        string = (char *)malloc(strlen(s)); 
        /* Copiamos o conteudo de s pra dentro de string. (agora que possui espaco alocado). */
        strncpy(string, s, strlen(s)+1); 
        fprintf(stdout, "Sem strdup(): %s\\n", string);
        /* Liberamos o espaco alocado. */
        free(string); 

        /* COM strdup() */

        /* Alocamos a memoria exata e jah copiamos o conteudo s para dentro da string. */
        string = strdup(s);
        fprintf(stdout, "Com strdup(): %s\\n", string);
        /* Liberamos o espaco alocado (dessa vez por strdup()). */
        free(string);

        return 0;
}

ip_fix@konoha:~/C$ gcc -Wall -o strdup_ex strdup_ex.c
ip_fix@konoha:~/C$ ./strdup_ex "teste de string"
Sem strdup(): teste de string
Com strdup(): teste de string
ip_fix@konoha:~/C$


Fica bem claro a facilidade de usar strdup() em vista de que não precisamos ficar chamando malloc() e strncpy() toda vez que precisamos gravar alguma string numa variável já que a função faz todo o serviço.

Função strtok():

char *strtok(char *s, const char *delim);

A função strtok() é muito útil quando precisamos “quebrar” nossa string em algum delimitador comum. Ele separa os tokens de tal forma que podemos trabalhar individualmente em cada pedaço. A função retorna um ponteiro para o próximo token ou retorn NULL caso tenha chegado ao fim.

(Para melhor visualizar, faça o download do fonte: strtok_ex.c)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {

        /* Alocamos e copiamos a frase dentro de s. */
        char *s = strdup("Essa eh uma frase de exemplo."); 
        /* Delimitador. Nesse caso quebraremos a string nos espacos em branco. */
        char *delim = " "; 
        char *res;

        /* Primeira chamada antes do laco. */
        res = strtok(s, delim);

        while (res != NULL) {
                fprintf(stdout, "%s\\n", res);
                /* Repetimos a chamada ate o fim da string. */
                res = strtok(NULL, delim);
        }

        /* Liberamos o espaco alocado. */
        free(s); 

        return 0;
}

ip_fix@konoha:~/C$ gcc -Wall -o strtok_ex strtok_ex.c
ip_fix@konoha:~/C$ ./strtok_ex
Essa
eh
uma
frase
de
exemplo.
ip_fix@konoha:~/C$


Assim vemos grande utilidade quando pensamos em “parsear” algum tipo de dados que possua algum delimitador em comum. Claro que coisas simples, mas já um ponta pé inicial de implementações mais complexas que podem ser adaptadas.

Encerro por hoje esse post básico mas que tenho certeza que deixa claro para muita gente o uso dessas simples funções que muitas vezes é uma mão na roda em algumas tarefas. Em breve postarei mais funções interessantes com exemplos. Espero ter mais retornos no comentários, adoro dúvidas e sugestões!

Resolvi falar sobre lista encadeada em C poque alguns contatos no meu MSN sempre me perguntam sobre e também porque é muito utlizado em diversos algoritmos. Apesar de já ter alguns códigos prontos resolvi refazer dando ênfase nas sugestões do livro, que realmente recomendo já que fala sobre listas, árvores, hash, entre outros mais.

Chega de papo, Show me the Code!, o código abaixo implementa um exemplo de uma lista simples encadeada onde os dados não são ordenados e a forma que são armazenados é igual uma pilha, onde o último dado a entrar é o primeiro a sair, conhecido também como LIFO (Last In, First Out).

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define BUFFER 64

/* Estrutura da lista declarada para armazenar nossos dados. */
typedef struct lista {
        char *nome;
        int idade;
        struct lista *proximo;
} Dados;

/* Prototipo das funcoes de manuseio dos dados. */
Dados *inicia_dados(char *nome, int idade);
Dados *insere_dados(Dados *dados, char *nome, int idade);
void exibe_dados(Dados *dados);
void busca_dados(Dados *dados, char *chave);
Dados *deleta_dados(Dados *dados);
int checa_vazio(Dados *dados);

/* Prototipo das funcoes do menu.*/
void insere(void);
void exibe(void);
void busca(void);
void deleta(void);

/* Inicializa a estrutura de dados principal. */
Dados *principal = NULL;

/* Cria a nova lista apontando o proximo no para NULL. */
Dados *inicia_dados(char *nome, int idade) {

        Dados *novo;

        novo = (Dados *)malloc(sizeof(Dados));
        novo->nome = (char *)malloc(strlen(nome)+1);
        strncpy(novo->nome, nome, strlen(nome)+1);
        novo->idade = idade;
        novo->proximo = NULL;

        return novo;
}

/* Como a lista nao esta mais vazia, apontamos o proximo no para lista anterior. */
Dados *insere_dados(Dados *dados, char *nome, int idade) {

        Dados *novo;

        novo = (Dados *)malloc(sizeof(Dados));
        novo->nome = (char *)malloc(strlen(nome)+1);
        strncpy(novo->nome, nome, strlen(nome)+1);
        novo->idade = idade;
        novo->proximo = dados;

        return novo;
}

/* Percorre todos os campos da lista e imprime ate o ponteiro proximo chegar em NULL. */
void exibe_dados(Dados *dados) {

        fprintf(stdout, "Cadastro:\\n\\n");

        fprintf(stdout, "------------------------\\n");

        for (; dados != NULL; dados = dados->proximo) {
                fprintf(stdout, "Nome: %s\\n", dados->nome);
                fprintf(stdout, "Idade: %d\\n", dados->idade);
                fprintf(stdout, "------------------------\\n");
        }

        getchar();
}

/* Percorre cada ponta comparando o nome com a chave. */
void busca_dados(Dados *dados, char *chave) {

        int achou = 0;

        fprintf(stdout, "Cadastro:\\n\\n");
        for (; dados != NULL; dados = dados->proximo) {
                if (strcmp(chave, dados->nome) == 0) {

                        fprintf(stdout, "------------------------\\n");
                        fprintf(stdout, "Nome: %s\\n", dados->nome);
                        fprintf(stdout, "Idade: %d\\n", dados->idade);
                        fprintf(stdout, "------------------------\\n");
                        achou++;
                }
        }

        if (achou == 0)
                fprintf(stdout, "Nenhum resultado encontrado.\\n");
        else
                fprintf(stdout, "Foram encontrados %d registros.\\n", achou);

        sleep(1);
}

/* Deleta o ultimo registro inserido. */
Dados *deleta_dados(Dados *dados) {

        Dados *novo;

        novo = dados->proximo;

        free(dados->nome);
        free(dados);

        fprintf(stdout, "O ultimo registro inserido foi deletado com sucesso.\\n");
        sleep(1);

        return novo;
}

/* Apena checa se a lista e NULL ou nao. */
int checa_vazio(Dados *dados) {

        if (dados == NULL) {
                fprintf(stdout, "Lista vazia!\\n");
                sleep(1);
                return 1;
        } else
                return 0;
}

/* Obtem os dados necessarios para chamar as funcoes de manuseio de dados. */
void insere(void) {

        char *nome;
        int idade;

        nome = (char *)malloc(BUFFER);

        fprintf(stdout, "\\n\\nDigite o Nome: \\n----> ");
        scanf("%s", nome);
        fprintf(stdout, "\\n");

        fprintf(stdout, "Digite a Idade: \\n----> ");
        scanf("%d", &idade);
        fprintf(stdout, "\\n");

        if (principal == NULL) 
                principal = inicia_dados(nome, idade);
        else 
                principal = insere_dados(principal, nome, idade);
}

void exibe(void) {

        if (!checa_vazio(principal))
                exibe_dados(principal);
}

void busca(void) {

        char *chave;

        if (!checa_vazio(principal)) {

                chave = (char *)malloc(BUFFER);

                fprintf(stdout, "Digite o nome para buscar: \\n--> ");
                scanf("%s", chave);

                busca_dados(principal, chave);
        }
}

void deleta(void) {

        if (!checa_vazio(principal))
                principal = deleta_dados(principal);
}

int main(void) {

        char escolha;

        do {
                system("/usr/bin/clear"); /* Nao lembro de nada melhor!  */
                fprintf(stdout, "\\n\\t\\tCadastro de Pessoas\\n\\n");
                fprintf(stdout, "Escolha uma opcao: \\n");
                fprintf(stdout, "1 - Insere Dados\\n");
                fprintf(stdout, "2 - Exibe Dados\\n");
                fprintf(stdout, "3 - Busca Dados\\n");
                fprintf(stdout, "4 - Deleta Dados\\n");
                fprintf(stdout, "5 - Sair\\n\\n");

                scanf("%c", &escolha);

                switch(escolha) {
                        case '1':
                                insere();
                                break;

                        case '2':
                                exibe();
                                break;

                        case '3':
                                busca();
                                break;

                        case '4':
                                deleta();
                                break;

                        case '5':
                                exit(0);
                                break;

                        default:
                                fprintf(stderr,"Digite uma opcao valida!\\n");
                                sleep(1);
                                break;
                }

                getchar(); /* E para impedir sujeira na entrada da escolha. Nao lembro de nada melhor tambem.  */
        }

        while (escolha > 0); /* Loop Principal. */

        return 0;
}

Veja o uso de uma única lista (principal) que no decorrer das chamadas das funções de manuseio de dados, ela vai se alterando com cada ponteiro retornado, tornando mais fácil seu uso.

Não tenho muito que falar porque fiz esse código correndo em umas 2 horas (mas que levou 2 dias por causa de conversas paralelas no MSN, Gmail, entre outros! =P), inclusive nem fiz mais tratamentos devidos mas enfim, a idéia é quem tiver dúvidas, que pergunte nos comentários! Eu AMO responder dúvidas (inteligentes) e acredito que sempre tem alguma visto que a linguagem C em si é um tanto quanto confusa pra maioria (principalmente pra mim!) mas que sempre podem ser sanadas!

Ainda quero postar exemplos melhores na prática, como por exemplo códigos a nível de kernel (LKM – Loadable Kernel Module) onde temos estruturas interessantes para criarmos block devices, mexer com file operations, hookar funções de rede entre outros! Há uma vasta diversidade para treinarmos mais e melhorar nossos códigos! Espero falar mais em breve. Por enquanto até a próxima!

E quem quiser baixar o fonte direto está aqui: lista_simples_encadeada.c

Aguardo as dúvidas!

Em 1998, Robin Dunn, anunciou o binding (porte) para python: wxPython.

Como a linguagem Python é uma ótima escolha para um desenvolvimento rápido, e wxWidgets uma ótima escolha para o desenvolvimento de uma interface rica de elementos e portabilidade, wxPython é a toolkit que une o útil ao agradável!

Apesar de ter diversas vantagens e desvantagens, cito apenas as principais:

Vantangens:

• Portabilidade (Windows, Linux, Mac OS, entre outras)
• Velocidade de desenvolvimento (Não chega a ser tão redundante quanto outras bibliotecas gráficas)
• Simplicidade, atualizações de bugs & features (Tente outras toolkits em diversas linguagens, wxPython é uma das mais claras e menos burocráticas. E seu desenvolvimento é constante, sempre com novas features e bugs corrigidos)

Desvantagens:

• Péssima documentação (Todas funções são documentadas, mas muito confusas e não claras)
• Desempenho inferior (Pelo fato de ser interpretado e tudo ser uma abstração, é claro que não se compara a velocidade de um codificado nativamente)
• Falta de Informação (Apesar de um bom wiki, não há muitas iniciativas em prol, muito menos brasileiras. Esse é o principal motivo que me leva a escrever sobre)

Agora vamos a prática que interessa. Como ambiente de desenvolvimento estou usando o Ubuntu Feisty 7.04.
Para preparar nosso ambiente de trabalho, vamos prosseguir:

ip_fix@konoha:~$ sudo apt-get install libwxbase2.8-0 libwxgtk2.8-0 python-wxversion python-wxgtk2.8 wx2.8-examples wx2.8-doc

Assim temos todas libs e dependências satisfeitas. Agora vamos testar pra ver se ficou tudo realmente OK. Para quem quiser baixar e compilar a partir do fonte, deve primeiro baixar o wxWidgets e em seguida o próprio wxPython

ip_fix@konoha:~$ python
Python 2.5.1c1 (release25-maint, Apr 12 2007, 21:00:25)
[GCC 4.1.2 (Ubuntu 4.1.2-0ubuntu4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import wx
>>> wx.__version__
'2.8.1.1'
>>>
ip_fix@konoha:~$

Sim! Tudo está OK! O módulo wx foi importado e a versão foi exibida através de seu atributo especial (__version__). Já é o suficiente para prosseguirmos.

ip_fix@konoha:~$ python
Python 2.5.1c1 (release25-maint, Apr 12 2007, 21:00:25)
[GCC 4.1.2 (Ubuntu 4.1.2-0ubuntu4)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import wx
>>>
>>> app = wx.PySimpleApp()
>>> frame = wx.Frame(None, -1, "wxPython r0x! =)")
>>> frame.Show()
True
>>> app.MainLoop()
>>>
ip_fix@konoha:~$

Acompanhe o resultado na figura abaixo:

Sim! Com apenas 3 linhas temos uma “janela”!

Um objeto foi criado para a aplicação em si; declaramos outro objeto para um frame com seu título definido no atributo; setamos o frame como ‘visível’; e por fim entramos no looping infinito que permanece exibindo a aplicação.

Claro que irei explicar melhor, mas no próximo post, aí temos somente código, vários exemplos e explicações.É isso, quero ver críticas, dúvidas e sugestões! São sempre bem-vindo todas!

A única distribuição que consegui, foi o pre-release do Ubuntu Feisty, mas após instalação ele não iniciava com o grub, sempre numa tela preta congelada. Baixei o Ubuntu Feisty que foi lançado hoje para testar, e infelizmente o grub continuou congelando! Então resolvi tentar com o LILO e obtive sucesso! Acompanhe os macetes abaixo:

Após dar o boot com o Ubuntu Feisty 7.04, abra o terminal e assuma o root. Em seguida monte a partição previamente instalada:

ubuntu@ubuntu:~$ sudo su -
root@ubuntu:~# mount /dev/sda3 /mnt

Precisamos agora espelhar os dispositivos dinâmicos que o udev do kernel 2.6 cria na inicialização no /dev e também o /proc. Com isso podemos tornar o /mnt nossa nova raiz:

root@ubuntu:~# mount --bind /dev /mnt/dev
root@ubuntu:~# mount -t proc proc /mnt/proc
root@ubuntu:~# chroot /mnt
root@ubuntu:/#

Agora vamos fazer download dos binários do LILO e extrair na raiz, assim os binários irão ficar em seus devidos lugares. Em seguida o lilo.conf é criado com a configuração abaixo:

root@ubuntu:/# wget http://home.san.rr.com/johninsd/pub/linux/lilo/lilo-22.8.bin.tar.gz
root@ubuntu:/# tar xf lilo-22.8.bin.tar.gz
root@ubuntu:/etc# cat lilo.conf
boot=/dev/sda
prompt
timeout = 50
vga=791
lba32
image = /boot/vmlinuz-2.6.20-15-386
initrd = /boot/initrd.img-2.6.20-15-386
root = /dev/sda3
label = Ubuntu_Feisty
append="root=/dev/sda3"
read-only
root@ubuntu:~# lilo
Added Ubuntu_Feisty *
root@ubuntu:~#

Sim, foi necessário o append=”root=/dev/sda3″, apesar root acima já especificado.

Agora basta reiniciar o sistema e veja iniciando normalmente!

Muitos já conhecem a linguagem Python, porém poucos sabem do binding que fizeram do wx. Não que não saibam, mas não tenho visto discussões pt_BR.

Apesar de uma grande tendência da “web 2.0” (esse pessoal do marquetingui!), onde tudo é on-line (até nosso editor de planilha! wow!), não podemos esquecer de que ainda há a necessidade de aplicações stand-alone em desktops.

Há inúmeras toolkits para esse tipo de desenvolvimento, mas por um desenvolvimento com agilidade e velocidade, optei pelo bind do wxwidgets pra python: wxPython.

Como toda escolha é ingrata, onde ganhamos velocidade de desenvolvimento, podemos perder velocidade na execução, da interpretação, apesar do bytecode não ficar tão lento ainda sim há um pequeno aumento de consumo de memória e outros recursos.

No próximo post sobre o tema, irei falar das vantangens e desvantagens sobre o uso dessa toolkit com linguagem python. Espero que desperte o interesse no pessoal!