quarta-feira, 12 de novembro de 2008

Interdisciplinaridade ou corporativismo?

.
"Interdisciplinaridade" é uma palavra bonita, bastante em moda nos meios acadêmicos atualmente. Está na hora então deste conceito ser aplicado também na hora do ingresso na carreira acadêmica, em especial nos requisitos exigidos nos concursos para as universidades públicas. Como diz uma colega minha aqui da UESC, Prof. Ana Paula Brandão Lopes, os que "ousam" mudar de área são sistematicamente excluídos.

Isso me incomoda devido a minha trajetória: minha graduação foi na área de informática; no mestrado trabalhei com Geoprocessamento e Lógica Nebulosa, e estou finalizando o doutorado trabalhando com Geoprocessamento e Computação Inteligente (Redes Neurais Artificiais e Lógica Nebulosa), inclusive com o desenvolvimento e a disponibilização de um software completo para análise de dados espaciais (veja postagem aqui). Bela trajetória "computonauta", não? O problema são os títulos! Graduação em "Tecnologia de Processamento de Dados", Mestrado em "Estudos Populacionais e Pesquisas Sociais", e Doutorado em "Geografia". Pela prática atual, não dá para prestar concurso nem na Computação, nem na Geografia...

A Ana Paula publicou um texto extremamente claro e objetivo sobre esse tema no Jornal da Ciência (disponível aqui), que reproduzo com autorização da autora:

20. Leitora comenta matéria “Concurso para professor na Universidade Federal dos Vales do Jequitinhonha e Mucuri”

“É urgente a necessidade de regulamentação dos requisitos que podem ou não ser exigidos nos concursos para professor”

Mensagem de Ana Paula Brandão Lopes, da Universidade Estadual de Santa Cruz:

“Onde fica a interdisciplinaridade? Tenho acompanhado os concursos das universidades públicas brasileiras já há alguns anos e tenho visto uma exclusão sistemática daqueles que participam de programas de pós-graduação interdisciplinares ou simplesmente "ousam" mudar de área entre a graduação e a pós, mesmo que a mudança seja em áreas correlatas.

Só a título de citar alguns exemplos desse último concurso:

- Nem um doutor em Engenharia Florestal, com graduação em Agronomia, ou um doutor em Agronomia com graduação em Engenharia Florestal poderiam concorrer a nenhuma das quatro vagas disponíveis na UFVJM para essas áreas.

- Contabilistas com doutorado em Administração também ficam de fora das vagas para Administração, assim como administradores com doutorado em Ciências Contábeis.

- E para "fechar com chave de ouro", apesar da imensa carência de pessoal com pós-graduação na área de computação, uma pessoa que tivesse feito a graduação em Matemática Computacional e depois feito a pós em Ciência da Computação estaria impedida de fazer o concurso para Sistemas de Informação. O mesmo vale para egressos do doutorado no LNCC, independente da graduação de origem.

E os exemplos continuam em quase todas as vagas e não são exclusividade da UFVJM...

Essa é uma situação recorrente, e que está prejudicando muita gente. São pessoas que trabalharam tão duro quanto os demais pelos seus títulos, e, às vezes, até mais, pela necessidade de adquirir conhecimentos de outras áreas que não a da sua graduação.

Essas pessoas demonstraram competência para superar os desafios da interdisciplinaridade e agora se vêem impedidas até mesmo de concorrer àquelas que são atualmente as mais cobiçadas oportunidades de emprego para pós-graduados no Brasil.

Existe uma expectativa de abertura de um grande número de vagas nas federais para os próximos anos, e alguma coisa precisa ser feita para impedir que essas situações continuem se reproduzindo.

É urgente a necessidade de regulamentação dos requisitos que podem ou não ser exigidos nos concursos para professor, evitando que toda uma população de pós-graduados fique marginalizada desses concursos.

A sugestão é que somente a última titulação possa ser especificada nos requisitos; além disso, deve haver garantias de que egressos de programas multidisciplinares ou de áreas afins cujos trabalhos estejam relacionados à área do concurso possam participar. A partir disso, que passem os melhores.”


Bem, pelo menos a discussão começou. Já surgiu outro comentário sobre este assunto (veja aqui).

Como diz um colega do PSL-BA, "vamo que vamo!"

Grande abraço a todas e a todos!
Carlão

segunda-feira, 10 de novembro de 2008

HOMENS unidos pelo fim da violência contras as MULHERES

.
Copiado de
http://maisomeno.blogspot.com/2008/11/campanha-contra-violncia-s-mulheres.html


No dia 31 de outubro, o Governo Brasileiro, através da Secretaria Especial de Políticas para as mulheres, lançou a campanha da ONU, “Homens unidos pelo fim da violência contra as mulheres”. O objetivo do projeto é mobilizar homens de todo o mundo na luta contra a violência cometida contra as mulheres. Eles podem dar seu apoio assinando o manifesto que está disponível no site (http://www.homenspelofimdaviolencia.com.br/).

A ministra Nilcéa Freire, titular da SNPM enfatiza que "ao aderirem à campanha, por meio de assinaturas, os homens se comprometem publicamente a contribuir pela implementação integral da Lei Maria da Penha (11.340/06) e pela efetivação de políticas públicas que visam ao fim da violência contra as mulheres”. A meta é de atingir 500.000 assinaturas até 6 de dezembro. Os resultados da campanha serão divulgados em um grande evento e as assinaturas serão enviadas "on-line" ao Secretário Geral da ONU. A partir daí, os apoiadores brasileiros passarão a compor a campanha internacional.

É importante que todos os blogs, sites, ajudem na divulgação, criando links diretos para endereço onde consta a lista de assinaturas a favor do projeto.

O mico do século!

.
Cara, esse deve ser o maior mico da face da Terra....

Mas que ficou legal, ficou!!! :-)




Abraços!
Carlão

terça-feira, 4 de novembro de 2008

Seis por meia-dúzia!

.
Um colega meu do mestrado, Marcelo Acha ("todos procuram, mas só o Marcelo Acha!"), em seu blog, colocou de forma extremamente clara um pensamento com o qual concordo, e que cheguei a comentar com algumas pessoas:

É impressionante a expectativa que se criou em torno do candidato do Partido Democrata na corrida à presidência dos EUA. Aqui no Brasil, inclusive, e em vários outros pontos ao redor do globo. Estava lendo alguns jornais on line, agora, e pude perceber essa "torcida" por Barack Obama, o que me fez voltar para este post extra.
Ao que parece, o fato de Obama ser afrodescendente faz as pessoas pensarem que haverá mudanças profundas nas relações EUA-mundo. Doce ilusão... o candidato democrata passou todo o tempo de sua campanha tendo o cuidado de "descolar" sua imagem da possibilidade de oferecer uma mudança radical. Sabe que, para ganhar as eleições, precisa mostrar ao eleitorado WASP[1] que será sinônimo da continuidade. Ainda assim, corre sério risco de sofrer um atentado...
Historicamente, os presidentes do Partido Democrata são ligados aos movimentos sindicais norte-americanos. Isso significa políticas protecionistas e, por conseguinte, endurecimento nas relações comerciais com os países periféricos (including Brazil, my brother!). Neste sentido, um presidente republicano seria "menos pior".
Obama não quer se mostrar como candidato defensor das minorias, embora ninguém despreze votos de cubanos, judeus e portorriquenhos (todos, por sinal, mais simpatizantes dos republicanos que dos democratas). Portanto, nada mudará. A política externa estadunidense continuará a mesma porcaria, e nós continuaremos a ser considerados "quintal" ianque.
A propósito, não torço por ninguém. Escolher entre Obama e Mc Cain é como comparar seis com meia dúzia...

[1] White, Anglo Saxonic and Protestant, ou Branco, Anglo-Saxão e Protestante, o típico representante da classe média conservadora dos EUA.

Faço minhas as palavras dele!

Grande abraço a todas e a todos!

Carlão

[ ATUALIZAÇÃO! ]
Veja o descrito acima, de forma divertida, em
http://charges.uol.com.br/2008/11/06/barrack-obama-black-or-white/

quarta-feira, 15 de outubro de 2008

Campus Party: Caravana da Consultic (região de Ilhéus/Itabuna)

.
Direto do site da Campus Party:

Campus Party é considerado o maior evento de inovação tecnológica e entretenimento eletrônico em rede do mundo. Um encontro anual realizado desde 1997 na Espanha, que reúne durante sete dias milhares de participantes com seus próprios computadores procedentes de diversos países, com a finalidade de compartilhar curiosidades, trocar experiências e realizar todo tipo de atividades relacionadas a tecnologia, a cultura digital e ao entretenimento em rede.

Os participantes da Campus Party mudam-se com seus computadores, malas e barracas para dentro das instalações do evento. Lá encontram uma completa infra-estrutura de serviços, lazer, higiene, segurança, alimentação e, principalmente, tecnologia. Durante uma semana a Campus Party transforma-se na casa de todos.

Participam do evento estudantes, professores, cientistas, jornalistas, pesquisadores, artistas, empresários e curiosos. Todos buscam as últimas novidades tecnológicas, a troca livre de conteúdos e o compartilhamento de experiências ligadas ao mundo digital.

No Brasil, a primeira edição aconteceu em 2008 e contou com 3.300 participantes, muitos dos quais acamparam (literalmente) por sete dias no Parque do Ibirapuera, imersos no mundo da Tecnologia da Informação e Comunicação. Segundo a organização, cerca de 92 mil pessoas visitaram a área de exposições.

A Consultic e a Passos Turismo já estão organizando grupos para que um grande contingente da nossa região possa participar da CAMPUS PARTY 2009.

A idéia é que sejam organizados 3(três) grupos com as seguintes características:

GRUPO 01 – Viajando de ônibus (semi-leito, fretado) com hospedagem no próprio local do evento.

GRUPO 02 – Viajando de avião com hospedagem no próprio local do evento.

GRUPO 03 – Viajando de avião com hospedagem em hotel próximo ao local do evento.

Maiores detalhes no site http://consulticnacampusparty.wordpress.com


Grande abraço!
Carlão

quarta-feira, 8 de outubro de 2008

Momento Blues 1

.
Peço desculpas aos amigos do "Planeta PSL-BA" pelos posts não relacionados diretamente com Software Livre. Se alguém puder me ajudar a definir um "feed" filtrando pela tag "software livre", agradeço a ajuda!

De qualquer modo, uma pausa na nossa vida de computonauta é sempre bem-vinda, não é? :-)

Abraços a todas e a todos!

Carlão

terça-feira, 7 de outubro de 2008

Ainda falando sobre leis absurdas...

.
Recebi o texto abaixo na lista da SBC (Sociedade Brasileira de Computação). Olha o absurdo de regras que acho que são elaboradas só para deleite de poder de alguém... porque nexo que é bom, necas!

Abraços!
Carlão


Resolvi contar isso para todos vocês dado o absurdo que a situação me pareceu.

Na última sexta-feira, como vocês bem sabem, foram divulgados os nomes dos selecionados para o ENADE assim como a data correta do dia da realização da prova. Sim, faltando um mês para a prova o MEC divulga as informações cruciais de uma prova que pode se tornar uma barreira na sua vida. Desde setembro que eu já sondava o site do MEC/ENADE tentando descobrir a data da prova...

Agora vejam, estou inscrito em uma conferência que ocorrerá em São Paulo nos dias 8 e 9 de novembro. Estou com a inscrição paga, passagem comprada e metade das diárias pagas no hotel (reserva). Uma das poucas conferências decentes na área de Segurança da América Latina (só são duas, na verdade), com palestrantes internacionais e nacionais, da academia e da "indústria". Enfim, não é um evento pequeno.

Passei a sexta-feira, quando recebi a notícia da data da prova, ligando para o MEC (0800616161) e, como já esperava, o número passou o dia ocupado. Hoje, há menos de 10 minutos, consegui enfim falar com o "Fala Brasil". Informei ao atendente a situação e ele, com toda calma do mundo, me diz que tudo que eu tinha que fazer era mandar um email para o ENADE/MEC informando isso tudo e aguardar o retorno no Diário Oficial sobre a minha dispensa, ou não, da prova. Uma ponta de esperança.

Aí, na minha inocência, perguntei se o resultado saíria até semana que vem e obtive a grande solução do MEC. "Não senhor, isso só deverá ser divulgado em meados de Fevereiro de 2009".

Ainda sem querer acreditar que alguém estava me dizendo aquilo perguntei se era isso mesmo: eu peço dispensa da prova agora, falto a prova e vou para a conferência e só fico sabendo do resultado em Fevereiro do ano que vem !? "Sim, sim, isso mesmo."

Mas percebam o absurdo da situação, eu sou concluinte. Faltar a prova agora e não ter minha justificativa considerada válida pelo MEC implica que eu só poderei colar grau daqui a 3 anos, quando ocorrer outro ENADE. 3 anos.

Só gostaria de deixar claro que não sou contra o ENADE. Acho MUITO importante que o ensino superior do país seja avaliado. Só estou questionando o absurdo de só saber se posso ser dispensado ou não DEPOIS DA REALIZAÇÃO da prova. Nessa horas eu entendo o comportamento de alguns alunos que simplesmente resolvem boicotar essas provas, respondendo de qualquer forma. (Lembrem-se do falecido Provão do MEC).

Sei que alguns alunos podem estar passando por situação parecida aqui no CIn e por isso estou enviando esse email para a grad-l. Esse é só mais um exemplo desses que provam o quanto somos impotentes em algumas situações. Para quem eu reclamo sobre o MEC?! Para o Ministro da Educação? Mando um email para o Presidente ?

Claro que não... vou perder o dinheiro da inscrição do evento, da reserva do hotel e ficar com as passagens para usar em algum outro momento da vida. E então no dia 9 de Novembro estarei lá, calado, iniciando a prova às 13hrs, que é o que sempre fazemos no país.

segunda-feira, 6 de outubro de 2008

Leis que causam desigualdade

.
Teóricamente, as leis deveriam ser um instrumento de igualdade: "todos são iguais, perante a lei". Porém existem leis que causam desigualdade, aparentemente sem lógica.

As regras para saque do FGTS são desse tipo. Senão vejamos: imaginem duas pessoas: uma nascida em fevereiro, e a outra nascida em dezembro. As duas são funcionárias de uma empresa particular. As duas também prestam um concurso público (por exemplo, para a UESC), e são aprovadas. Elas pedem demissão da empresa particular, por exemplo, em JANEIRO.2005, e conforme as regras para saque do FGTS, terão que esperar 3 anos para poderem recuperar esse dinheiro. Até aí, tudo bem.

O problema é uma regrinha adicional: "após 3 anos (...) e A PARTIR DO MÊS DO ANIVERSÁRIO". Ou seja, o que faz aniversário em fevereiro, poderá sacar seu dinheiro em fevereiro.2008. Já o outro terá que esperar até dezembro.2008!

Qual o sentido disso? Que importância tem o mês de nascimento para definir o direito das pessoas? Notem que não é a IDADE, mas sim apenas o MÊS de nascimento!

Se alguém souber, me explique!

Abraços!
Carlão

quarta-feira, 1 de outubro de 2008

O que é Software Livre ?

.
Peço licenca aos amigos do "Planeta PSL-BA" para este post tão introdutório, mas explico o motivo: tive a alegria de ter meu blog listado no "blog dos blogs da costa do cacau", um repositório de blogs "localizados" em Ilhéus, Itabuna e cidades próximas. Como a audiência deste conjunto de blogs é formada principalmente por pessoas não técnicas da área de computação, achei que seria um momento importante para disseminar a idéia do software livre.

Então, meu amigo leitor do "blog dos blogs", gostaria de apresentar a você o conceito de Software Livre, através do video abaixo, de uma entrevista concedida pelo sociólogo Sergio Amadeo:



Se você gostou e se interessou, sugiro então que você de uma lida neste artigo, onde apresento argumentos que defendem que o uso de software livre é REQUISITO FUNDAMENTAL em um contexto educacional e de pesquisa científica:

http://starfightercarlao.blogspot.com/2008/04/software-livre-e-o-verdadeiro-acesso-ao.html

Grande abraço a todas e a todos!
Carlão

terça-feira, 30 de setembro de 2008

Nova arma contra phishing: Língua Portuguesa...

.
O pessoal que faz phishing pode até saber muito de computação, mas de língua portuguesa...

Recebi dois desses emails hoje. Vejam que pérolas:

... acredito que a verdade tem que vim (!?!) em primeiro lugar ...

... eu tava perto e consigui (argh!) fotos através de meu celular ...

... Estou mandando as fotos anexada (!!!) quero ...

Tragetoria (aff!!) de Osama Bin Laden Chega ao Fim!!!

Dá até vergonha....

Abraços!
Carlão

segunda-feira, 22 de setembro de 2008

Dica para programadores GTK: DevHelp

.
Na atividade de programação usando GTK (e qualquer outra biblioteca) é necessário uma constante consulta à documentação da API, seja na busca por um método que faça o que precisamos, seja para conferir os tipos dos parâmetros ou do valor retornado.

No caso da biblioteca GTK (e suas bibliotecas parceiras), podemos baixar um pacotão com a documentação, ou consultar online em http://library.gnome.org/devel/references.

Descobri ontem uma outra forma, offline, proporcionada pelo programa DevHelp. Instalável sem dores-de-cabeça pelo seu gerenciador de pacotes, fornece, no caso da GTK, a mesma documentação disponível online.

Para utilizá-lo, não basta instalar apenas o DevHelp. Você precisa também instalar os pacotes de documentação das bibliotecas que você vai usar. No meu caso (Ubuntu), esses pacotes terminam com "-doc" (cheque o nome correto na sua distribuição, em especial se ela não for debian-based), como por exemplo:

libatk1.0-doc
libcairo2-doc
libglib2.0-doc
libgnomecanvas2-doc
libgnomeui-doc
libgtk2.0-doc
libpango1.0-doc


Abraços!
Carlão

sábado, 20 de setembro de 2008

Roteiro para criação de uma janela no GLADE

.
Continuo ralando aqui com o GLADE. Depois de muitas cabeçadas e quase desistência, começei a gostar do bichinho. Talvez o grande problema seja a falta de um roteiro passo-a-passo, pois por mais que se leia sobre os widgets, em especial os que gerenciam o layout (vbox, hbox, table, etc.), e sobre suas propriedades, é difícil visualizar claramente qual será o efeito final.

Tentando "começar" a preencher essa lacuna, apresento este passo-a-passo. O objetivo é criar a seguinte tela:


Vou listar então todos os passos que executei para construir esta tela. O objetivo aqui é que alguém refaça esses passos e com isso possa ter um exemplo das alterações no visual causadas por cada widget ou propriedade manipulada. Ressalto ainda que muitas das escolhas que fiz nessa construção foram baseadas no meu "senso" estético, e devem ser entendidas apenas como sugestões. Como de costume, sugestões e principalmente correções são extremamente bemvindas.

Como este roteiro usa e abusa de identação, para mostrar a hierarquia entre widgets (quem vai dentro de quem, a que widget pertence tal propriedade, etc), resolvi não colocar direto aqui no post, mas sim disponibilizar um arquivo texto.

Lá pelo meio do roteiro, tem uma referência a uma figura. É esta aqui:


Gostaria de aproveitar este momento para registrar um grande agradecimento ao Bruno Boaventura, que tem me ajudado muitíssimo em diversos aspectos da programação com GTK.

Grande abraço a todas e a todos!
Carlão

sexta-feira, 19 de setembro de 2008

Como preencher uma GtkComboBox criada no GLADE

.
Penei com isso ontem um tempão. A GTK tem a função gtk_combo_box_append_text() (entre outras) com o objetivo de facilitar a criação de drop-downs de texto. Porém para usar esta função, o drop-down (GtkComboBox) tem que ter sido criado via gtk_combo_box_new_text() , o que parece não ser o caso dos drop-downs criados via Glade. Na net, encontrei muita referência disso para outras linguagens (PHP por exemplo), mas nada para o velho e bom C... Felizmente, após muita procura, encontrei um pedaço de código que resolveu meu problema. Coloco ele aqui, comentado, na esperança de ajudar outros "desesperados" como eu ... :-)

Em linhas gerais, você precisa criar uma GtkListStore, para armazenar a lista de itens que vai aparecer no drop-down. Depois, associe esta lista ao drop-down, e finalmente defina COMO esta lista vai aparecer na tela ("ser renderizada"). UFA! Bem que podia ter uma opção no GLADE para escolher como o drop-down vai ser criado na hora do uso, se via gtk_combo_box_new_text para simples drop-downs de texto, ou da forma default, para drop-downs mais elaboradas.

No código abaixo, a variável "drop_bds" é um GtkWidget*, e contém minha drop-down (GtkComboBox).

[ OBS!! Sugiro que você copie o programa abaixo e cole em um editor de texto-puro, para melhor visualização da identação e dos comentários linha-a-linha. Não sei como colocar aquela janelinha de código que se encontra em blogs por aí, se alguém puder me ajudar, agradeço! ]

// um GtkComboBox implementa a GtkCellLayout. O comando abaixo apaga este layout.
// Precisei fazer isso porque o conteúdo do meu drop-down é o resultado do click em um botão.
// Se eu não apagar o layout logo no início, cada vez que aperto o botão o drop-down vai
// crescendo, pois vai mantendo o layout anterior e adicionando o novo.

gtk_cell_layout_clear(GTK_CELL_LAYOUT(drop_bds));


// outras variaveis necessarias:

// inteiro, para ir contando os elementos que vamos inserir no drop-down
int cont;

// a GtkListStore que vai armazenar os elementos do drop-down
GtkListStore *list_store;

// o "renderizador" que vai mostrar o conteúdo da lista dentro do drop-down
GtkCellRenderer *renderer;

// um iterador, uma espécie de ponteiro que indica em que lugar da lista
// vamos inserir o novo conteúdo
GtkTreeIter iter;


// cria a GtkListStore, com apenas 1 coluna, conteúdo do tipo string
list_store = gtk_list_store_new (1, G_TYPE_STRING);


// laço que vai preencher a lista com as strings que vão compor o drop-down:

for(cont=0; cont < ...numero de elementos a inserir... ; cont++)
{

// string que vai armazenar o texto a ser inserido no drop-down
char conteudo[50];

// defina o conteudo da string acima
// no meu caso, a string seria uma combinacao de outras strings e outros dados,
// provenientes de outras partes do programa. Optei por usar a função sprintf para
// "montar" essa string. Veja o que é melhor no seu caso!

sprintf(conteudo, "%s", ...o conteudo que voce quer na string... );


// Adiciona uma linha ( VAZIA! ) na lista (list_store), e faz o iterador (variável iter)
// apontar para ela, para que depois possamos "encher" essa linha vazia de conteúdo

gtk_list_store_append (list_store, &iter);

// armazena um valor na lista, na linha apontada por iter, nas colunas indicadas.
// A lista de colunas termina com um -1. Como só tenho 1 coluna na minha lista, fica:
// 0 (primeira e única coluna) , conteudo (a string a inserir nessa linha) , -1 (fim!)

gtk_list_store_set (list_store, &iter, 0, conteudo, -1);
}


// insere a lista que acabamos de montar dentro do drop-down:
gtk_combo_box_set_model(GTK_COMBO_BOX(drop_bds), GTK_TREE_MODEL(list_store));

//
// falta agora definir como essa lista irá aparecer na tela, isto é, ser renderizada.
//

// criação de um renderizador de textos:
renderer = gtk_cell_renderer_text_new();

// insere o renderizador criado no drop-down
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(drop_bds), renderer, TRUE);

// define as propriedades (atributos) deste renderizados. Lista-se cada propriedade
// e terminamos a lista com um NULL
// Neste caso, estamos definindo a propriedade "text" e seu valor 0 (não consegui encontrar na
// documentação da API os atributos possíveis e seus valores.... alguém me ajuda nisso?)
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(drop_bds), renderer, "text", 0, NULL);

// até aqui está pronto, seu drop-down estará com o conteúdo desejado.

// no meu caso, eu quero mostrar ao usuário que agora temos dados
// no drop-down para ele escolher
// (a primeira vez que o usuário vê minha janela, o drop-down está vazio)
// Desta forma, vou usar um comando para tornar o primeiro item do
// drop-down como item ativo.

gtk_combo_box_set_active(GTK_COMBO_BOX(drop_bds), 0);



Pronto. Divirtam-se!

Grande abraço a todas e a todos!
Carlão

quinta-feira, 18 de setembro de 2008

Continue mantendo sua sanidade com o Glade

.
Pra quem está começando a trabalhar com GTK e GLADE, recomendo a leitura do excelente tutorial de Marcelo Lira, "Mantendo A Sanidade Com O Glade". Ele dá uma visão completa de todo o processo, desde o desenho da interface no GLADE até a compilação final, com exemplos em várias linguagens.

O objetivo deste texto é complementar este tutorial, mostrando alguns problemas que aparecem no desenho da interface no GLADE, e as soluções que encontrei. Infelizmente este texto não é lá muito “básico”... será preciso algum conhecimento de GTK e até do próprio GLADE. Espero que seja útil mesmo assim. Outros textos introdutórios de GTK virão por aí em algum momento no futuro.

Criaremos com o GLADE a seguinte caixa de diálogo:


Uma caixa de diálogo em GTK possui 2 áreas: uma superior, onde colocaremos nossos widgets, e outra inferior, com espaço para os botões. Podemos começar, então, inserindo no GLADE uma dialog box:


Qual gerenciador de layout colocaremos na parte superior? Vamos analisar nossa interface: ela está mais ou menos organizada “por linhas”, como, por exemplo, a primeira linha (label “tipo de servidor” e drop-down para a escolha do tipo de servidor), ou a última linha (botão “listar bancos de dados”, e drop-down para escolher o banco de dados). Para organizar em linhas, utilizaremos então uma “vbox”.

Agora, outra dúvida: quantas linhas teremos na vbox? Vemos 3 linhas óbvias (primeira, “tipo de servidor”; penúltima, “usuário e senha”; e última, “listar bancos de dados”). Mas, e quanto a localização do servidor? Serão mais 3 linhas?

Na verdade, configura apenas mais 1 linha, pois as 3 linhas que vemos ("endereço ip", "nome" e "nesta máquina") estão AGRUPADAS dentro de um único widget, chamado frame (“localização do servidor”). Precisaremos então de apenas mais uma linha, para inserir a frame. Dentro da frame, aí sim, teremos que criar 3 linhas.

Vemos então na figura abaixo, nossa interface com a vbox configurada para 4 itens:


A primeira linha possui 2 widgets, organizados horizontalmente. Logo utilizaremos uma hbox, com 2 espaços disponíveis.

Na segunda linha, como já falamos, colocaremos uma frame.

Na terceira linha teremos 4 widgets, também organizados horizontalmente. Usaremos então uma hbox de 4 itens.

Finalmente, a última linha terá 2 itens, organizados horizontalmente. Nova hbox, de 2 itens.

Nossa interface fica como apresentado na figura abaixo:


Vamos pensar um pouco como ficará o interior da nossa frame na linha 2. Podemos pensar numa organização também por linhas, mas se olharmos mais atentamente poderemos perceber a existência de linhas E colunas (temos uma coluna de radio buttons, e outra de dados extras, ligados a esses radio buttons). Assim, ao invés de usar uma vbox, usaremos uma table, com 3 linhas e 2 colunas. Nossa interface fica como na figura abaixo:


Ainda sobre esta tabela, notemos a área localizada na primeira linha, segunda coluna: aqui teremos um conjunto de 7 widgets, composto por caixas de texto e labels (pontos), organizados horizontalmente. Vamos inserir então a última hbox de nossa interface, com 7 itens.


Agora que o layout da interface está planejado, podemos inserir seus diversos widgets (labels, caixas de texto, botões, drop-down). Apenas inseri os widgets, colocando os textos corretos, sem mexer ainda em outras configurações. Nesse momento, algo estranho acontece: a janela cresce demais! Se fizermos um teste de apresentação real da janela (usando libglade), vemos que ela está longe de ser visualmente agradável:

Glade:

Programa compilado:

Vamos começar então a “arrumar a casa”. O primeiro problema é o tamanho default das caixas de texto. Na linha do “endereço ip”, cada caixa só precisa armazenar (e exibir) no máximo 3 caracteres. Para as outras, vamos definir exibição de 10 caracteres. A propriedade “maximum length” define o número máximo de caracteres que a caixa poderá armazenar, e a propriedade “width in chars” é o tamanho (em caracteres) da caixa.

Outro problema está relacionado a configuração de expansão dos widgets. Por default, está definido que cada widget vai expandir e ocupar todo o espaço livre disponível. Note na figura acima, por exemplo, a primeira linha (“tipo de servidor”). Como todo o diálogo está aumentado por causa das caixas de texto, o gerenciador de layout dividiu o espaço extra igualmente pelo label “Tipo de servidor” e o drop-down ao seu lado. Precisamos, portanto, desligar a propriedade “expand” de alguns widgets. Cada caso é um caso, mas podemos ter como regra geral fazer isso nos widgets “da esquerda”, e em especial nos labels. Se sobrar espaço na direita, deixamos as caixas de texto e drop-down ocuparem o espaço extra.

Assim, desligaremos a propriedade “expand” dos seguintes widgets:

- label “Tipo de servidor”;
- radio “endereço ip”;
- labels dos pontinhos no endereço ip;
- radio “nome”;
- radio “nesta máquina”;
- label “usuário”;
- label “senha”;
- botão “listar bancos de dados”.

Após essas alterações, o GLADE continuou mostrando o diálogo aumentado (pelo menos no meu caso). Também não consegui diminuir seu tamanho arrastando as bordas. Neste momento fechei o projeto e reabri, e aí sim, ele mostrou o diálogo no seu novo tamanho real. De qualquer modo, é sempre bom ir testando “ao vivo”, através de um programa. Como a interface é desenhada “na hora” (dinamicamente), não precisa nem recompilar, basta salvar o arquivo .glade e rodar o programa para ver o resultado. O estado atual de nossa interface é apresentada na figura abaixo:


Bem melhor, não é? Agora só precisamos passar um “pente fino”. Vamos colocar um espaço após os dois-pontos dos labels “Tipo de servidor” e “usuário”, para aumentar a separação entre eles e o widget ao seu lado. No label “senha”, vamos colocar um espaço antes da palavra e outro depois dos dois-pontos. Vamos também colocar um espaço antes e outro depois do texto no botão “Listar bancos de dados”. Vamos aproveitar e tirar os dois-pontos depois do label “nesta máquina” ( só vi o erro agora... :-) )


As “linhas” que compõem a interface estão muito apertadas, muito próximas umas das outras. Vamos então aumentar o espaçamento entre elas. Lembra da vbox que inserimos no início do processo? Vamos aumentar a propriedade “spacing” para 6:


Note que o conteúdo da frame não foi espaçado, pois está todo em apenas uma “célula” da vbox. Para espaçar este conteúdo, precisamos alterar a propriedade “row spacing” da tabela que inserimos na frame. Coloquei o valor 4. Ainda na frame, podemos ligar o contorno, para desenhar uma caixa. Para isso, vamos alterar a propriedade “frame shadow”, colocando “etched in”.


Podemos notar mais 2 probleminhas dentro da frame: o primeiro é que todos os radio buttons estão ativos! Isso acontece porque o GTK não sabe que eles pertencem a um mesmo grupo, ele acha que são 3 radios separados! Para resolver este problema é preciso estabelecer uma ligação entre eles. Para isso, alteramos a propriedade “group”. Por exemplo, vamos no radio “nome”, e na propriedade group marcaremos o radiobutton1 (“endereço IP”). Faremos o mesmo com o radio “nesta máquina”. Resumindo: radiobutton2 e radiobutton3 fazem referência a radiobutton1, e com isso, todos os 3 ficam no mesmo grupo.

O segundo problema é estético: há um espaço grande, no lado esquerdo da frame, e um espaço mínimo no lado direito (ambos por dentro da frame). Isto pode ser ajustado através das propriedades “left padding” e “right padding” do widget “alignment” (é um dos widgets que compõem a frame). Colocaremos o valor 6 tanto na direita como na esquerda.

Uma última coisa a ser feita, definir o título da janela, na propriedade “window title” do diálogo.


Prontinho! Não esqueça de definir os nomes das callback functions nos widgets correspondentes.

A propósito... tive um problema ao tentar utilizar a função glade_xml_signal_autoconnect (liga automaticamente os eventos gerados pelos widgets às funções callback que definimos no nosso programa principal), pois o programa que estou fazendo é um “híbrido” C/C++. Estou programando em C, usando GTK em C, porém também preciso usar uma biblioteca específica (TerraLib) feita em C++. Logo, estou compilando em C++, e por causa de características específicas desta linguagem acerca de nomes de funções, o autoconnect não consegue encontrar as funções callback. A solução é bem simples: basta definir as funções como “extern C”, assim:

extern "C" void bot_conct(GtkButton *bt, GtkWidget *win)
{
printf("teste...");
getchar();
}

Também precisa adicionar a opção -rdynamic ou -export-dynamic no linkeditor.

Bem, é isso aí. Não deixem de comentar com dúvidas e/ou correções.

Abraços a todas e a todos!
Carlão

terça-feira, 2 de setembro de 2008

Abraçe um programador hoje!

.
Demais!

Obs: Se você acessar o vídeo no site do YouTube, poderá ligar as legendas. Clique, no canto inferior direito, em "CC" (closed caption).

Abraços!
Carlão

quinta-feira, 28 de agosto de 2008

Motivação para trabalhos intelectuais

.
Esta é a tirinha de Calvin & Haroldo que me inspirou durante o doutorado, em especial agora na reta final - quando entrei no, como Calvin diz, "right mood"... :-)

(clique na figura para ampliar)

Abraços!
Carlão

domingo, 24 de agosto de 2008

Só pra ser chato...

.
posição - país - ouro - prata - bronze

22 - Brasil - 3 - 4 - 8
...
27 - Cuba - 2 - 9 - 11
...
33 - Argentina - 2 - 0 - 3

:-)

Abraços!
Carlão

quinta-feira, 21 de agosto de 2008

Doutorado: Geoprocessamento e Computação Inteligente: Possibilidades, vantagens e necessidades

.
[ ATUALIZAÇÃO 8.fevereiro.2009 ]
Texto e código-fonte disponíveis; correção de links;


RESUMO
As técnicas de análise de dados e de busca de soluções fornecidas pela Computação Inteligente tiveram, nos últimos tempos, um grande avanço em seu desenvolvimento. Essas técnicas têm sido utilizadas com eficácia e eficiência no tratamento de problemas complexos e/ou que possuam uma grande quantidade de dados a serem processados. A integração destas técnicas com as ferramentas computacionais de produção e análise de informações geográficas (Geoprocessamento) é, portanto, muito vantajosa, especialmente com relação à grande quantidade de dados geralmente envolvida nas questões de natureza espacial. Este trabalho apresenta dois exemplos de uso de técnicas de Computação Inteligente em procedimentos de produção e análise de informações geográficas: um Sistema de Raciocínio Nebuloso (baseado na Lógica Nebulosa) para a construção de um mapa de fertilidade de solos, e uma Rede Neural Artificial para a identificação de agrupamentos espaciais em dados sócio-econômicos. Os dois exemplos foram conduzidos utilizando-se um software especialmente construído para esta finalidade, denominado GAIA – Geoprocessamento Apoiado por Inteligência Artificial –, e que doravante está disponível como Software Livre para qualquer pesquisador interessado em utilizar estas ferramentas. O estudo conclui que o uso das técnicas provenientes da computação inteligente, em comparação com técnicas tradicionais de análise de dados, contribuiu para um aumento da qualidade dos resultados obtidos.


Texto disponível aqui


Software GAIA - Geoprocessamento Apoiado por Inteligência Artificial

Grupo de discussão:
(*inativo*) http://groups.yahoo.com/group/gaia_geoprocessamento_ia

Licença:
GNU General Public License (GPL) version 3
Licença Pública Geral GNU - versão 3
Disponível em www.gnu.org/licenses/gpl.html
Tradução não oficial para português: www.fsfla.org/svnwiki/trad/GPLv3

- Executável (GNU/linux, i386, requer GTK)

- Dados dos exemplos

- Instruções para instalação

- Tutorial passo-a-passo para os exemplos apresentados na tese: inserido no texto da tese, disponível no link apresentado no início desta postagem

- Código-fonte

ATENÇÃO! está disponível acima apenas o código-fonte (arquivos cpp e glade, além de algumas imagens). Em breve disponibilizarei aqui o makefile, junto com instruções detalhadas para compilação junto com a TerraLib.


- live-cd (GAIA, TerraView, MYSQL, tutoriais + dados)
Arquivo ISO (versão em inglês)
Leia-me !!
.

sábado, 16 de agosto de 2008

Netbeans 6.1 com C/C++ : Configurando um projeto para utilizar GTK - ATUALIZAÇÃO!! MUITO MAIS FÁCIL !!

.
Expliquei neste post como configurar o NetBeans 6.1 para compilar um programa usando a biblioteca GTK. Hoje, meio por acaso, descobri uma forma muitííííssimo mais simples!! De qualquer modo, o post original ainda merece ser consultado, pois contém algumas informações importantes e interessantes.

Vou direto ao ponto. Quem quiser ver telinhas, como já disse, consulte o post original.

Após criar o novo projeto:

1) abra a janela de propriedades do projeto;

2) No painel da esquerda, clique em "C compiler", debaixo de "Build";

3) No meio do topo da janela, no drop-down "configuration", escolha "all configurations" (a explicação deste item pode ser encontrada aqui);

4) No painel da direita, clique nos "três pontinhos" do item "additional options", localizado em "command line";

5) Na caixa "additional options", coloque:
`pkg-config --cflags gtk+-2.0`
6) clique em [OK];

7) No painel da esquerda, clique em "Linker", ainda dentro do grupo "Build";

8) No painel da direita, clique nos "três pontinhos" do item "additional options", localizado em "command line";

9) Na caixa "additional options", coloque:
`pkg-config --libs gtk+-2.0`
10) clique em [OK];

11) clique em [apply] e [OK] para fechar a janela de propriedades do projeto.

Prontinho!! Seu NetBeans está preparado para compilar usando GTK!

Abraços a todas e a todos!

Carlão

sábado, 2 de agosto de 2008

Netbeans 6.1 com C/C++ : Configurando um projeto para utilizar GTK

.
[ ATENÇÃO!! coloquei uma forma muito mais fácil neste post. Porém este post contém algumas imagens que podem ainda ser úteis ]

Siga esses passos para configurar o NetBeans 6.1 para compilar programas usando GTK. Estou admitindo que seu sistema já tem as bibliotecas necessárias instaladas (se não tiver, use o synaptic para instalar a biblioteca libgtk2.0-dev e suas dependências). Também estou admitindo que seu NetBeans tem o pacote para desenvolvimento C/C++:

1) Prepare um arquivo texto (chamei de "parametros.txt') com os parâmetros necessários (diretórios de includes e bibliotecas, e nomes de bibliotecas). Isso é feito, no terminal, utilizando o comando:

pkg-config --cflags --libs gtk+-2.0 > parametros.txt


2) Crie um novo projeto:

menu file | new project

3) Escolha C/C++ em categories, e C/C++ Application em Projects.

4) Preencha com os dados do projeto: nome e diretório onde será armazenado.

5) O projeto é criado, por padrão, para utilizar as ferramentas de debug. Para alternar entre essas formas de compilação (modos Debug ou Release), acesse:

build | set main project configuration

Escolha "release" se você não quiser informações de debug. Utilize essa opção apenas quando seu programa já estiver pronto! Para maiores detalhes sobre os modos de compilação, veja o post anterior.

6) Vamos agora definir os parâmetros de compilação específicos para uso da GTK, isto é, inserir no NetBeans os dados do arquivo "parametros.txt":

file | "nome_do_seu_projeto" properties , ou clique com o botão direito no nome do projeto, e escolha "properties".


Na janela que vai abrir, clique em "C compiler", debaixo de "build" (lado esquerdo da janela).


Neste momento, note a primeira linha da janela, tem um campo escrito "configuration: debug (active)". Isto significa que qualquer modificação só estará valendo para a compilação no modo Debug. Devemos trocar para "all configurations", ou seja, as configurações que faremos aqui valerão para qualquer tipo de compilação (Debug ou Release). ATENÇÃO! NAS TELAS ABAIXO, ESTE CAMPO DE CONFIGURAÇÃO APARECERÁ COMO "DEBUG", MAS O CORRETO É ESTAR COMO "ALL CONFIGURATIONS" !

Vamos preencher o item "include directories", dentro de "general" (clique no botão com três pontinhos a direita). Vai abrir uma janela para definição dos diretórios onde estão os includes (arquivos *.h).

7) Abra o arquivo "parametros.txt". Para cada item que iniciar com -I (traço mais letra "i" maiúscula), faça:

7.1) clique no botão "add";
7.2) copie o diretório (sem o "-i") no campo "file name" (dica: se você usar control-X, ao invés de control-C, os diretórios vão sumindo do arquivo "parametros.txt", e aí você vai controlando quais você já fez);
7.3) clique no botão "select";




Ao final, clique "OK".

8) Clique em "Apply".


9) Clique em "linker", ainda debaixo de "build". Depois, "libraries" embaixo de "libraries".


10) Clique em "add option". Na janela que vai abrir, escolha "other option".

11) Copie o resto do conteúdo do arquivo "parametros.txt" (itens que começam com "-l", traço mais letra éle minúscula) para esta janela, INCLUINDO os "-l".



12) OK ... Apply ... OK

13) Está pronto! Segue um pequeno programa GTK pra testar. Este programa gera uma janela vazia. Apesar da janela fechar quando clicamos no "x", o programa continua rodando, pois precisaríamos dotar o programa de uma resposta ao evento "fechar janela" (mas isso é papo pra depois...). Para fechar o programa, basta fechar o terminal que o NetBeans vai abrir para mostrar a janela.

#include stdio.h
#include stdlib.h
#include gtk/gtk.h
[ atenção!! colocar os sinais de menor e maior nas linhas acima!!!]

int main(int argc, char** argv)
{
GtkWidget *window;

gtk_init (&argc, &argv);

window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Alou, Mundo!!");
gtk_widget_show (window);

gtk_main ();
return (EXIT_SUCCESS);
}


Pronto! Seu projeto está preparado para compilar programas que utilizem a biblioteca GTK, tanto no modo Debug quanto no modo Release.

Grande abraço!

Carlão

sexta-feira, 1 de agosto de 2008

Netbeans 6.1 com C/C++ : A diferença entre o modo Release e o modo Debug

.
Você pode compilar seu projeto no NetBeans de duas formas diferentes: modo Debug e modo Release. A diferença entre eles é que no modo Debug seu projeto é compilado de uma forma que disponibiliza informações extras para permitir uma melhor avaliação do seu funcionamento e principalmente a caça de bugs (definição de pontos de parada na execução, verificação "on the fly" dos valores das variáveis, etc).

Vamos verificar na prática. Crie um novo projeto:

file | new project

categories: c/c++
projects: c/c++ application
[next]



project name: teste
[finish]



O NetBeans cria, por default, um diretório com o nome do seu projeto debaixo do diretório NetBeansProjects. Utilize seu navegador de arquivos e confira que dentro deste diretório "teste" só tem um único subdiretório, denominado "nbproject".

Vamos adicionar um arquivo com código-fonte em C:

file | new file

categories: c files
file types: main C file
[next]



Na próxima tela, apenas [finish]


Digite o seguinte programa:

#include stdio.h
#include stdlib.h
[nota: alguém sabe pq o blogger não deixa usar maior e menor??]

int main(int argc, char** argv)
{
int A, B, C;

A = 1;
B = 2;
C = 3;

printf(" %d - %d - %d ", A, B, C);

return (EXIT_SUCCESS);
}


A definição da forma de compilação é feita através do menu "build" :

build | set main project configuration | Debug ou Release


Escolha "release", e depois compile o projeto:

build | build main project

Utilize novamente o gerenciador de arquivos e olhe o interior do diretório "teste". Surgiram dois novos subdiretórios: "build" e "dist". No interior deste último, foi criado o diretório "release", contendo mais um subdiretório (gnu-linux-x86) e dentro dele o arquivo executável gerado por nossa compilação. O nome "release" não apareceu a toa, indica que compilamos nosso projeto no modo "release". Para finalizar esta etapa, anote o tamanho do arquivo executável que foi gerado (no meu caso, 6.3 KB).

Volte ao NetBeans, e escolha o modo de compilação "debug":

build | set main project configuration | Debug

E novamente compile o projeto:

build | build main project

Vamos olhar novamente o interior do diretório "dist". Foi criado agora o diretório "Debug", contendo o executável gerado pela compilação no modo "Debug" (novamente dentro de gnu-linux-x86). Vejamos o tamanho do arquivo executável: 7.3 KB.

Porque maior? Por que, como falei no início, no modo debug o executável é gerado com recursos extras que permitirão executar atividades de debug, tais como definição de pontos de parada, verificação do conteúdo das variáveis ENQUANTO O PROGRAMA ESTIVER RODANDO, etc.

Vamos ver isso funcionando ao vivo e a cores: Vamos definir um ponto de parada. Isso é feito clicando no número da linha onde se deseja que a execução pare. Vamos clicar na linha 8, onde atribuímos o valor 1 à variável A. Vai aparecer uma caixinha vermelha onde antes era o número da linha, e toda a linha ficará destacada em vermelho. Isso indica que a execução vai parar ANTES da execução desta linha.


Para executar o programa utilizando as informações extras de debug, utilize:

run | debug main project

A execução vai iniciar... e nada vai aparecer no terminal, porque o programa parou na linha que indicamos. Volte para a janela principal do NetBeans, e note o indicador estilo "supermáquina" ou "visor cylon" (depende da sua idade...) no canto inferior direito da janela. Isto indica que o programa está em execução, apenas está parado temporariamente. No código fonte, a linha onde o programa está parado fica verde.

Ainda olhando para o canto inferior direito da janela, note uma caixa com as variáveis A, B, C e seus valores, que devem ser os mais loucos possíveis. Isso acontece porque paramos o programa em um momento em que as variáveis foram criadas, mas nenhum valor foi (ainda) atribuído a elas, ou seja, elas estão com os valores aleatórios que toda variável em C recebe assim que é criada (na verdade, a variável não "recebe" nada; ela é associada a uma posição de memória que está com um valor qualquer, ou aleatório gerado quando o computador foi ligado, ou deixado por algum programa anterior).



Um dos recursos disponíveis para nós é a execução passo-a-passo do programa. Podemos mandar o NetBeans executar a próxima linha, e verificar as mudanças nos valores das variáveis (e desta forma, avaliar se o programa está fazendo as coisas corretamente!). Para isso, clique no botão com uma caixa azul e uma seta amarela apontando para baixo (o tooltip indica "step into"), ou vá no menu run | step into, ou simplesmente tecle F7.


A linha verde avançou para a próxima linha, isto é, ele executou o "A = 1". Isto também pode ser notado pela alteração do valor da variável A no box de variáveis.

Pode-se prosseguir assim passo a passo, ou pode-se mandar continuar a execução normalmente (teclando F5, clicando no botão com a seta "play" verde, ou menu run | continue). Note que podemos definir vários pontos de parada no programa.

Mais um teste para finalizar: mude o modo de compilação para "release":

build | set main project configurarion | release

Não precisamos recompilar, pois não mudamos o programa desde que geramos a versão release no início deste post. Vamos então tentar rodar esta versão release no modo debug:

run | debug main project

Necas! Ele ignorou nosso ponto de parada, pois o executável do tipo Release não está preparado para realizar debug.

Um último comentário, a janela de variáveis é bem interessante, pois mostra o conteúdo de membros de estruturas, valores de ponteiros, até mesmo valores de áreas alocadas dinamicamente (simulando um vetor a partir do ponteiro com o endereço inicial). Enfim, um recurso bem interessante pra quem não aguenta mais ficar colocando 'printf' no meio do programa.... (e geralmente esquecendo de tirar alguns deles no final!!)

Abraços a todas e a todos!
Carlão

quarta-feira, 11 de junho de 2008

Referências bibliográficas

.
Está naquela parte "deliciosa" do trabalho, geralmente no fim, com prazo estoura(n)do, de montagem da lista de referências bibliográficas? Aí descobriu que algumas referências você tem apenas aquela cópia xerox mal-tirada, onde esqueceu de anotar editora, cidade, ano... talvez até o título? Ou então você tem tudo isso, mas está em dúvida em como aplicar as normas?

Bem, segue uma dica: vá no Santo Oráculo (Sanctvs Googlus) e pesquise por:

+bibliografia +autor +autor2 +palavra-do-título
... ou o que mais você souber sobre o trabalho. Se for uma palavra, use "+". Se for uma frase, use "+" e aspas: +"efeitos termodinâmicos do rabo da lagartixa".

O Google provavelmente vai te retornar uma lista de trabalhos acadêmicos (ou não...) disponibilizados na Web, em especial a seção "Bibliografia" dos mesmos...

Consulte a referência desejada, e tire suas dúvidas!!

Mas por favor, faça um favor a si mesmo: não banque o esperto-chupão-mané e apenas copie a referência... gaste um tempinho pra tentar aprender como foi feita. Afinal de contas, o motivo pelo qual você está fazendo seu trabalho é o de aumentar o conhecimento... ou não é??

Se não for, está perdendo seu tempo!

E já que estamos falando sobre normas, segue um link muito bom sobre o tema.
http://www.rc.unesp.br/biblioteca/normasabnt.php

Abraços a todas e a todos!

Carlão

quarta-feira, 4 de junho de 2008

Dissertação de mestrado

.
O geoprocessamento como ferramenta para estudos sociológicos: O caso da relação de influência entre urbanização e o perfil de capital cultural dos vestibulandos da UNESP


Resumo:

A proposta deste trabalho é contribuir para uma nova forma transdisciplinar de pensamento, construindo uma interface entre a computação e a sociologia, mostrando como técnicas computacionais de análise de dados podem contribuir para auxiliar na inserção da dimensão espacial nos estudos sociológicos. Com esse objetivo, busca-se estudar a relação de influência que o grau de urbanização das cidades e regiões exerce sobre o perfil de capital cultural dos alunos ingressantes em diversos cursos de uma mesma carreira, localizados em diversos campi da UNESP, espalhados pelo interior do Estado de São Paulo.

Arquivos:

Capa
Capítulo 1
Capítulo 2
Capítulo 3 - parte 1
Capítulo 3 - parte 2
Capítulo 4
Capítulo 5 - Bibilografia - Anexo

Apresentação (slides)


Este trabalho está sendo disponibilizado pela mesma licença que governa este Blog:

Creative Commons License

quarta-feira, 28 de maio de 2008

Até o Dalai (tux) Lama sumiu...

.
Publiquei aqui anteriormente um post falando de um site muito legal, com trolhocentas imagens do TUX em várias fantasias e poses, imagens muito bem elaboradas. Para ilustrar o post, coloquei uma imagem do "dalai-tux-lama", que carregava uma bandeirinha "free Tibet".

Pois bem, olha só que coisa no mínimo esquisita.... estou eu preparando uma palestra sobre software livre, quando me lembrei desta figura para ilustrar o slide sobre as 4 liberdades. Fui no site, e para minha surpresa.... o dalai-tux sumiu!!!

Bem, teorias da conspiração a parte, consegui (re) encontrar o arquivo original (em alta resolução) do dalai-tux na net, neste link (quando acessar, vá para o fim da página, onde você vai encontrar a figura. O link que aparece em cima é o link original, o mesmo que foi exilado...).

Já baixei o arquivo, e vai ficar guardadinho aqui, para o caso dele "sumir" de novo...



link


Namastê!!

Carlão

terça-feira, 27 de maio de 2008

Resposta

.
"

Dwar Ev soldou solenemente a junção final com ouro. A objetiva de uma dúzia de câmeras de televisão se concentrava nele, transmitindo a todo o universo doze enquadramentos diferentes do que estava fazendo.

Endireitou o corpo e acenou com a cabeça para Dwar Reyn, indo depois ocupar a posição prevista, ao lado da chave que completaria o contato quando fosse ligada. E que acionaria, simultaneamente, todos os gigantescos computadores da totalidade dos planetas habitados do universo inteiro - noventa e seis bilhões de planetas - ao supercircuito que, por sua vez, ligaria todos eles a uma supercalculadora, máquina cibernética capaz de combinar o conhecimento integral de todas as galáxias.

Dwar Reyn dirigiu palavras aos trilhões de telespectadores. Depois de um momento de silêncio, deu a ordem:

- Agora, Dwar Ev!

Dwar Ev ligou a chave. Ouviu-se um zumbido fortíssimo, o surto de energia proveniente de noventa e seis bilhões de planetas. As luzes se acenderam e apagaram por todo o painel de quilômetros de extensão.

Dwar Ev recuou um passo e respirou fundo.

- A honra de formular a primeira pergunta é sua, Dwar Reyn.

- Obrigado - dissse dwar Reyn - Será uma pergunta que nenhuma máquina cibernética foi capaz de responder até hoje.

Virou-se para o computador.

- Deus existe?

A voz tonitruante respondeu sem hesitação, sem se ouvir o estalo de um único relé:

- Sim, agora Deus existe.

O rosto de Dwar Ev ficou tomado de súbito pavor. Saltou para desligar a chave de novo. Um raio fulminante, caído de um céu sem nuvens, o acertou em cheio e deixou a chave ligada para sempre.

"

BROWN, Fredric. "Resposta", in WARRICK, P.S. e GREENBERG, M.W. (org.), Máquinas que pensam - Obras-primas da Ficção Científica. Porto Alegre, L&PM, 1985. pp.364-65.

Consultado em: TENÓRIO, R.M. Computadores de Papel: máquinas abstratas para um ensino concreto. São Paulo: Cortez, 1991.

sábado, 24 de maio de 2008

Informação científica livre

.
Da série "imagine a cena": Você está trabalhando, ou na sua tese, ou na sua dissertação, ou na monografia da especialização, ou mesmo no dia-a-dia da sua pesquisa. Você vai no santo oráculo, vulgo "google", digita os termos da sua pesquisa, e aí esbarra naquele artigo científico maravilhoso (pelo menos julgando pelo título...). Clica todo contente.... e é levado para um site comercial, onde o artigo que você quer (de umas, sei lá, 10 páginas?) está A VENDA por módicos 30 ou 40 DÓLARES!!

Depois que passar a raiva, o que fazer? Sacar o cartão de crédito?

Bem, siga essa pequeniníssima dica, comigo está funcionando 95% das vezes. Pegue o título inteiro do artigo, volte a São Google, e pesquise o título, ENTRE ASPAS, assim ó:

"Geography matters: Kohonen classification of determinants of foreign direct investment in transition economies"

Garanto que você encontra numas das 3 primeiras páginas do resultado do Google ....

Salve, imprima, leia, e saboreie mais esse momento de vingança!! :-)

A propósito, aconteceu comigo uma coisa engraçada com relação a isso: Estava eu pesquisando um tema, quando encontrei um artigo que estava, como na maioria das vezes, a venda. Encontrei também o mesmo artigo citado no site da HP americana, onde dizia: "o artigo não está disponível por motivo de copyright"... Continuando a pesquisar, tive a alegria de encontrar o PDF do mesmo, inteirinho, no site da HP... da Índia!!!

Pra finalizar, deixo uma questão para reflexão: Será que Newton teve que pagar 40 dólares para poder subir nos ombros de gigantes ?

Abraços a todas e a todos!
Carlão

segunda-feira, 19 de maio de 2008

Polícia federal caçando criminosos perigosíssimos!! Quem faz legenda para seriados...

.
Foi noticiado pela Folha de São Paulo que a Polícia Federal vai realizar uma "caça" intensa contra sites de legendas de seriados.

Neste link, tem um post bem interessante sobre isso, do blog da Sandra Carvalho. Só quero enfatizar um parágrafo aqui (o resto ' cês lê no original):

"Bem, a luta contra o crime organizado, os traficantes e os corruptos deve estar indo muito bem, para a PF ter tempo de se voltar contra redes online de jovens tradutores que se unem para legendar em horas seriados baixados da internet porque demoram séculos para passar no Brasil."

Só mais umazinha:

"O que não é realista é misturar essa garotada que traduz seriados e distribui legendas gratuitamente com grupos criminosos que exploram comercialmente, aos milhões, cópias ilegais de grandes sucessos de Hollywood."

Abraços!

Carlão

quarta-feira, 14 de maio de 2008

Motivação...

.
Esta é a garrafa de água que me acompanha nos estudos...



É possível motivação melhor ?? :-) :-) :-)

Abraços!!
Carlão

terça-feira, 13 de maio de 2008

Delírios de quem está no meio-para-o-fim da tese...

.
AH! OS RELÓGIOS

Amigos, não consultem os relógios
quando um dia eu me for de vossas vidas
em seus fúteis problemas tão perdidas
que até parecem mais uns necrológios...

Porque o tempo é uma invenção da morte:
não o conhece a vida - a verdadeira -
em que basta um momento de poesia
para nos dar a eternidade inteira.

Inteira, sim, porque essa vida eterna
somente por si mesma é dividida:
não cabe, a cada qual, uma porção.

E os Anjos entreolham-se espantados
quando alguém - ao voltar a si da vida -
acaso lhes indaga que horas são...
Mario Quintana - A Cor do Invisível

Mais aqui.

Abraços rápidos, o tempo urge!!! :-)
Carlão

segunda-feira, 12 de maio de 2008

Folders no Gmail

.
Você já se perguntou alguma vez, apurrinhado, porque o Gmail não tem folders para categorizar as mensagens que você quer guardar?

Aí procurou no help, onde eles dizem que "não precisa de folders.... você pode pesquisar nas mensagens e encontrar a mensagem desejada"... ok, ok.... Mas eu quero folders, PÔ!!

Bem, a boa notícia é que.... o Gmail tem folders! Tudo bem, não são folders reais, mas o efeito final é o mesmo!

Simples, onde você criaria folders, crie LABELS (ou provavelmente "etiquetas", não sei bem, meu gmail está em inglês. Cês vê aí!). Crie um label para cada "folder" que você adoraria ter.... O próximo passo, obviamente, é associar a cada mensagem o seu label correspondente.

Aí você vai dizer: "mas elas vão ficar todas no meu inbox, misturadas!!" Calma. Agora vem o pulo do gato.... use o recurso "archive"!! Elas vão sair do seu inbox, e ficar (ainda misturadas) num itenzinho que talvez muitos não tenham percebido no menu da esquerda, chamado "all mail".

Aí você, já impaciente comigo, faz a pergunta final: "mas elas vão continuar misturadas no all mail!!" Ao que eu respondo, você não vai acessar elas pelo all mail, mas sim pelo LABEL que você criou. Basta clicar no nome do label, e o gmail vai mostrar apenas as mensagens classificadas sob aquele label!!

Finja que é um folder, e seja feliz.... :-)

Abraços a todas e a todos!
Carlão

sábado, 10 de maio de 2008

"Hello World", programas .... e classes de problemas!

.
Todo programador conhece o programa do tipo "hello world!". É um tipo de programa que ilustra a forma mais simples, numa linguagem de programação específica, de mostrar na tela a frase "Hello World!". Por exemplo, em C:

int main(void)
{
printf("Hello, World!\n");
}

Qual a utilidade de um programa tão xexelento? Simples, sua execução correta prova que o programador (geralmente aprendiz) consegue realizar os passos mínimos necessários para desenvolver qualquer programa, numa linguagem de programação específica: editar um arquivo texto com o código-fonte do programa, compilar este arquivo, linkeditar as bibliotecas e finalmente executar o programa.

Isso serve pra qualquer linguagem: Java, C++, Pascal, Fortran, Cobol, Basic, PL/1, PHP, Python... até Assembler! (clique aqui para uma coleção completa)

Mas não é só relativamente a linguagens de programação que encontramos programas "hello world"... Tenho encontrado na Internet uma referência a programas desse tipo relativos a uma classe de problemas específicos! A analogia seria "o programa mais básico, que resolve a forma mais básica do problema em questão".

Dois exemplos que encontrei:

- "hello world" para redes neurais: treinar uma rede para aprender a porta lógica XOR;

- "hello world" para redes neurais auto-organizáveis (Kohonen): agrupar por similaridade um conjunto de cores aleatórias.

Você conhece outros "hello world" aplicados a problemas específicos? Se sim, deixe seu comentário, e vamos atualizar esta lista!

Abraços a todas e a todos!
Carlão

PS: essa história toda de "hello world" me lembrou de uma piadinha.... :-)

Como os programadores matam um dragão?

Java:Chega, encontra o dragao. Desenvolve um framework para aniquilamento de dragoes em multiplas camadas. Escreve varios artigos sobre o framework mas nao mata o dragao.

.Net:Chega, olha a ideia do Javanes e a copia, tenta matar o dragao, mas e comido pelo reptil.

C:Chega, olha para o dragao com olhar de desprezo, puxa seu canivete, degola o dragao. Encontra a princesa, mas a ignora para ver os ultimos checkins no cvs do kernel do linux

C++:Cria um canivete basico e vai juntando funcionalidades ate ter uma espada complexa que apenas ele consegue entender ... Mata o dragao mas trava no meio da ponte por causa dos memory leaks

COBOL:Chega, olha o dragao, pensa que ta velho demais para conseguir matar um bicho daquele tamanho e pegar a princesa e, entao, vai embora.

Pascal:Se prepara durante 10 anos para criar um sistema de aniquilamento de dragao...Chegando la descobre que o programa so' aceita lagartixas como entrada.

VB:Monta uma arma de destruicao de dragoes a partir de varios componentes, parte pro pau, pra cima do dragao e, na hora H, descobre que a espada so funciona durante noites chuvosas...

PL/SQL:Coleta dados de outros matadores de dragao, cria tabelas com N relacionamentos complexidade ternaria, dados em 3 dimensoes, OLAP, demora 15 anos para processar a informacao. Enquanto isso a princesa virou lesbica.

Ruby:Chega com uma p*t* fama, falando que e o melhor faz tudo, quando vai enfrentar o dragao mostra um videozinho dele matando um dragao ... O dragao come ele de tedio.

Smalltalk:Chega, analisa o dragao e a princesa, vira as costas e vai embora, pois eles sao muito inferiores.

Shell:Cria uma arma poderosa para matar os dragoes, mas, na hora H, nao se lembra como usa-la.

Shell(2):O cara chega no dragao com um script de 2 linhas que mata, corta, stripa, empala, pica em pedacinhos e empalha o bicho, mas na hora q ele roda o script aumenta, engorda, enfurece, e coloca alcool no fogo do dragao.

ASSEMBLY:Acha que ta fazendo o mais certo e enxuto, porem troca um A por D, mata a princesa e transa com o dragao

Fortran:Chega desenvolve uma solucao com 45000 linhas de codigo, mata o dragao vai ao encontro da princesa ... mas esta o chama de tiozinho e sai correndo atras do programador java que era elegante e ficou rico.

FOX PRO:Desenvolve um sistema para matar o dragao, por fora e bonitinho e funciona, mas por dentro esta tudo remendado, quando ele vai executar o aniquilador de dragoes lembra que esqueceu de indexar os DBF.

ANALISTA DE PROCESSOS:Chega ao dragao com duas toneladas de documentacao desenvolvida sobre o processo de se matar um dragao generico, desenvolve um fluxograma super complexo para libertar a princesa e se casar com ela, convence o dragao que aquilo vai ser bom pra ele, e que nao sera doloroso. Ao executar o processo ele estima o esforco e o tamanho do estrago que isso vai causar, a assinatura do papa, do buda e do Raul Seixas para o plano, e entao compra 2 bombas nucleares, 45 canhoes, 1 porta avioes, contrata 300 homens armados ate os dentes, quando na verdade necessitaria apenas da espada que estava na sua mao o tempo todo.

CLIPPER:Monta uma rotina que carrega um array de codeblocks para insultar o dragao, cantar a princesa, carregar a espada para memoria, moer o dragao, limpar a sujeira, lascar leite condensado com morangos na princesa gostosa, transar com aprincesa, tomar banho, ligar o carro, colocar gasolina e voltar para casa. Na hora de rodar recebe um "Bound Error: Array Access" e o dragao come ele com farinha.

sexta-feira, 9 de maio de 2008

Gerando uma saída gráfica... sem complicações!

.
Imagine a cena: Você está estudando algum algoritmo, por exemplo o método de aprendizado de alguma rede neural. Resolveu programar o dito cujo na sua linguagem preferida, pra treinar e ver "na real" os resultados. Lá pelas tantas deu aquela vontade de gerar uma saída gráfica...

[ modo naftalina ON ]
Leitores com menos de 30 anos não precisam ler esse trecho - Nessa hora deu aquela saudade do velho BASIC do TK2000 ( clone do Apple ][ ), onde comandos como HGR, HCOLOR, HPLOT e HLIN resolviam sua vida? :-)
[ modo naftalina OFF ]

Soluções possíveis:

- usar um toolkit gráfico, tipo GTK, QT, WxWidgets... porém você não tem tempo pra isso!

- usar uma biblioteca gráfica mais simples: futucando na net, encontrei a EZXDISP. Me pareceu bem facinha. Mas... mesmo assim, não estava afim de gastar tempo estudando outra API.

Sobrou então....

- gerar um arquivo no formato HPGL! O formato de saída gráfica HPGL foi inventado para controlar as plotters da HP, nos idos de lá-vai-fumaça. O legal deste formato de arquivo é que ele é do tipo texto, ou seja, você não precisará de nenhuma biblioteca especial no seu programa para gerar a saída gráfica... basta gerar um arquivo texto, e inserir dentro dele alguns comandos de desenho.

O pequeno problema desta solução é que você vai ter que pensar como um ploter, ou seja, pra desenhar uma linha reta você vai precisar:

- mover a caneta para a posição inicial
- abaixar a caneta
- mover a caneta para a posição final
- levantar a caneta

Vejam um pequeno "hello world" em HPGL (arquivo extensão .plt):

IN;
inicializar a trapizonga

IP;
define o ponto de origem do desenho (0,0)
SC0,100,0,100;
define a escala do desenho
SP1;
select pen 1
PU0,0;
move a caneta para o ponto inicial
PD100,0,100,100,0,100,0,0;
abaixar a caneta ("Pen Down") e mover para varios locais, desenhando uma caixa
PU50,50;
levantar a caneta ("Pen Up") e mover para 50,50
CI25;
desenha um circulo de raio 25
SS;
seleciona a fonte padrao
DT*,1;
define o asteristico como limitador de texto
PU20,80;
levanta a caneta e move para 20,80
LBHello World*;
escreve Hello World

Faça o teste! copie o texto acima em um arquivo com extensão .plt.
Obviamente, os comentários não fazem parte do arquivo... :-)


Como visualizar o resultado? Infelizmente o visualizador de imagens padrão do Ubuntu/Gnome não entende este formato diretamente. Vamos precisar então converter para JPG ou PNG. Encontrei no repositório o programa HP2XX. Basta então, no seu programa em C, fazer uma chamada a este programa via system:
system("hp2xx -m jpg telecoteco.plt");
... para gerar o arquivo "telecoteco.jpg" , com a saida gráfica do seu programa.

Depois disso tudo, talvez você esteja pensando... "mas, mesmo assim terei que aprender como funcionam alguns comandos do HPGL ..."

É verdade .... tem sim .... mas você não está querendo moleza demais não?? :-)

Abraços!
Carlão