Brunildz - Tecnologia, Software e Besteiras Gerais

Feijoeiro - Do grão aos ovos de ouro

noreply@blogger.com (Bruno Moreira Guedes) — Mon, 23 Jan 2012 04:58:00 +0000

Palavras-Chave: Feijoeiro

Pessoal, como este é um blog bem mais pessoal do que profissional, e com um público composto principalmente pelos públicos de Tecnologia e Estudantes (descobri que tenho milhares de visitas ao texto de minha redação do ENEM), decidi criar um outro blog para um outro perfil de público. Este blog permanece no ar e eu sigo postando, no mesmo ritmo (devagar quase parando) de antigamente.

Mesmo assim, vou convidar todos a conhecerem, e seguirem se desejarem meu novo blog, sobre negócios, que trata de assuntos como dinheiro, empreendedorismo, gestão e mercado. Quem quiser conhecer, é só clicar no link abaixo:

Feijoeiro - Do grão aos ovos de ouro: Feijoeiro - Do grão aos ovos de ouro

Brasil: Ineficiente e Ineficaz na Gestão das Energias

noreply@blogger.com (Bruno Moreira Guedes) — Sun, 20 Nov 2011 16:11:00 +0000

Palavras-Chave: Belo Monte, Brasil, Energias, Sustentabilidade, Lâmpadas Fluorescentes

O título deste artigo poderia muito bem ser 'mais outra crítica a Belo Monte', ou 'uma das cem milhões de melhores críticas ao horário de verão', mas eu sempre prefiro ser mais abrangente no que escrevo. O Brasil tem um grave problema de gestão (que novidade...), e vim apontar neste artigo mais um exemplo deles: a gestão energética. Sei que eu poderia falar muito do ponto de vista da sustentabilidade (para o caso de Belo Monte), ou sobre os danos à saúde (sobre o horário de verão), mas falo hoje do aspecto comum destes dois paradigmas: dinheiro e economia. Claro que os cálculos que apresento aqui são "grosseiros", e não foram estudados fatores que podem intervir neles, até porque não sou nenhum técnico da área.

Vivemos em um país com aproximadamente 60 milhões de domicílios (segundo o IBGE). Tomando como base dados que li em uma pesquisa de Carla da Costa Lopes Achão, em 2007 nossas residências consumiam 90TWh de energia elétrica.

Segundo esta pesquisa, a simples troca de lâmpadas incandescentes por fluorescentes nas residências gera uma economia de cerca de 35% no domicílio. Se aplicarmos 35% de metade do consumo residencial, é muito mais que os 5% que economizamos às custas de nossas mudanças de hábitos causadas pelo horário de verão, e é muito mais do que a produção de Belo Monte.

Para quem não sabe, Belo Monte custará aos NOSSOS BOLSOS cerca de R$ 3,5bi para ser construída, e mais R$ 2bi para as linhas de transmissão - e eu estou IGNORANDO o impacto ambiental nestes números. Vamos a uma conta prática: ao preço final (que chega ao consumidor que compra 1 ou 2 unidades), uma lâmpada fluorescente custa cerca de R$ 6,00 - dependendo da potência. Com R$ 5,5bi daria para comprar - a este preço, cerca de 916 milhões de lâmpadas fluorescentes - ou seja, 15 lâmpadas fluorescentes PARA CADA DOMICÍLIO BRASILEIRO.

Mas claro, assim não teríamos empreiteiras trabalhando, licitações, e tantas outras coisas. Mas supondo que não existisse corrupção no Brasil, e que a obra custasse tudo isso de fato, o governo de nosso país está aumentando a produção de energia quando poderia simplesmente reduzir o consumo. E isso é um problema GRAVE, dado o quadro insustentável de consumo em que nosso planeta se encontra.

E já que o governo adora dar assistencialismos, qual o motivo de não criar um "bolsa lâmpada fluorescente" com esse dinheiro??

Nada mais a declarar.

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Nossa Língua Portuguesa

noreply@blogger.com (Bruno Moreira Guedes) — Sun, 12 Jun 2011 14:15:00 +0000

Palavras-Chave: Idioma, Erros, Preconceito Linguístico, Reforma Ortográfica

OBS: ESTE TEXTO NÃO PASSARÁ PELO CORRETOR ORTOGRÁFICO PROPOSITALMENTE, PARA ASSEGURAR QUE MEUS ERROS APAREÇAM. OBRIGADO PELA COMPREENSÃO. ALÉM DISSO, O MESMO NÃO SEGUE UM FOCO DEFINIDO E NÃO TEM UMA MENSAGEM OBJETIVA A DEIXAR.

Vivemos um momento caótico em nosso idioma. Comparo o cenário de nosso idioma ao que ocorreu com o latim nos séculos distantes anteriores, quando os plebeus não conseguiam falar e muito menos escrever corretamente, de tão complicado que o idioma era. Claro, a complexidade do latim era muito maior que a do nosso Português, mas vale relacionar.

Estamos na era do "preconceito linguístico", mas temos que achar o sensível equilíbrio entre as coisas. O fato é que sim, nós brasileiros em geral somos preconceituosos. Sim, nós gostamos de criticar os erros dos outros, e não gostamos quando os nossos são criticados, é um defeito típico do principal ser que habita nosso planeta. Agora percebam que a situação é muito mais complexa do que aparenta. Criticamos aqueles que estão em níveis "próximos" ao nosso, e nunca aqueles que estão "acima". E, ainda por cima, alguns brigam pela continuidade dos erros, não identificando a estreita linha entre tolerar o erro e incentivá-lo. E, infelizmente, justo estes estão à frente da educação de nosso país.

Não é a primeira vez que algo vindo do governo incentiva a perda de nosso idioma. "Vem pra caixa você também!". O slogan de um banco do governo fere nosso idioma há tantos anos, sob a justificativa de que a forma errada "soa melhor", e ninguém nada fala. Agora se teu próximo for um mero mortal e trocar um simples "s" por "z", tenha a certeza de que este será criticado e visto como ignorante.

Mas quem pode verdadeiramente falar e apontar os erros dos outros de forma vexatória? Nós, brasileiros, provavelmente não. A população de um país onde 99,9% (dados que não foram obtidos de pesquisa nenhuma) cometem erros como conjugar verbos na forma da terceira pessoa quando falamos à segunda pessoa não tem moral alguma para caçoar dos erros alheios. Ou o leitor nunca ouviu alguém dizendo "Fulano, SEU carro é o máximo" em lugar de "Fulano, TEU carro é o máximo"? Agora, penso que haja também uma diferença grande entre caçoar do erro, e notificar aquele que o cometeu, afinal, este muitas vezes desconhece o equívoco. E como fazê-lo de forma elegante? Muitas vezes somos (estou incluso) rudes ao comunicar este tipo de coisa.

E não é nada fácil deixar de ser rude neste aspecto, apontar um erro sempre toca na ferida, e cada pessoa reage a isso de uma diferente forma. Porém, se não o fizermos permitiremos que o próximo permaneça na ignorância, o que também é difícil de aceitar. E no fundo é isso que aparentam querer aqueles que dizem que protegerão as pessoas do "preconceito linguístico", ensinando que o errado é certo.

E, como se isso não bastasse, poucos anos atrás vem um "novo acordo ortográfico", sob o pretexto de "unificar o idioma", e trata de desunificá-lo entre os brasileiros. São pessoas que não tem noção do que é fácil e do que é difícil. O Brasil possui 78,58% dos falantes de língua portuguesa. São 190 milhões de pessoas que terão que mudar parte de sua forma de escrever para unificar sua língua com a de 51 milhões de outras pessoas. E o detalhe mais complicado da história, é que estes 190 milhões já não escreviam de forma exatamente padronizada, não conheciam nossa escrita - e os grandes representantes de nosso idioma, que parecem desconhecer esta realidade, ainda propõem mudanças internas?

Não seria muito mais fácil reconhecer que falamos idiomas simplesmente "similares" aos destes outros países, e que são idiomas diferentes?

Afinal, o que quero com este artigo? Defender uma posição em relação a escrever de forma culta ou não? Criticar o acordo ortográfico? Assinalar que todos nós cometemos erros? Muitas perguntas para resposta nenhuma. Escrevo apenas para "mapear" o cenário de nosso idioma, e para que cada leitor conclua o que bem entender.

Aproveito para terminar o texto desta forma, deixando "interrogações" no ar, além de uma sensação de que o texto foi começado com profundidade e finalizado às pressas. Sim, é isso mesmo. Com os filmes de Hollywood funciona e todo mundo gosta...

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

O Futuro do Trabalho (minha Redação do ENEM)

noreply@blogger.com (Bruno Moreira Guedes) — Sun, 21 Nov 2010 17:17:00 +0000

Palavras-Chave: Trabalho, ENEM, Tecnologia a Favor do Brasil, Futuro, Tecnologia

Esta foi minha redação escrita no ENEM deste ano(2010). O tema era O Trabalho na Construção da Dignidade Humana, e na proposta de trabalho eram citados dois trechos de texto, que falavam sobre o trabalho escravo e sobre a forma como a tecnologia tem mudado o trabalho. Este texto reflete opiniões pessoais minhas, e foi adaptado à partir do rascunho, e não é necessariamente idêntico ao texto que foi submetido. A qualidade do texto não é exemplar, uma vez que o tempo era bem limitado, e eu preciso de muitas horas para escrever um texto bem fundamentado e de qualidade. Mesmo assim, aí vai!

A forma como trabalhamos, juntamente com os sistemas produtivos, têm sofrido mudanças cada dia mais drásticas e aceleradas. Infelizmente, a adaptabilidade da sociedade a este novo paradigma ainda não acompanha esta evolução, que ocorre tão rapidamente. A maior prova disso é a frequente constatação de que o abominável trabalho escravo ainda existe. Mas as mudanças na tecnologia e na estrutura social dão a esperança de que haverá, um dia, um alinhamento entre os dois. O trabalho moderno e a alocação do ser humano no trabalho pensante tendem – inclusive – a erradicar de vez a escravidão.

O ser humano, portador de cérebro inteligente, não é feito para trabalhos braçais ou autômatos. Um ser pensante existe para pensar – para programar, controlar e otimizar as máquinas que tendem a substituí-lo no trabalho mecanizado. Não há mais espaço para a utilização de seres humanos como peças.

O trabalho à partir de casa – que já é realidade em segmentos como a Tecnologia da Informação – é uma das chaves para a qualidade de vida do trabalhador, bem como uma economia financeira às empresas. É o funcionário no conforto de trabalhar de onde bem entender, as empresas com menor necessidade de espaço físico, e de brinde a menor utilização dos poluentes meios de transporte.

Para acabar com a escravidão, é preciso – além de conscientizar e punir os exploradores de mão-de-obra – oferecer uma alternativa mais barata: máquinas. E com boa educação para todos, e a ascensão das máquinas, será viável multiplicar e ocupar postos de trabalho pensante.

E o dia do real fim da escravidão chegará somente com o ser humano deixando de ser utilizado como peça. O dia em que o valorizado ser humano fizer algo digno de seu potencial teremos um novo mundo, com dignidade para o trabalhador.

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

War! Geração Ultra-Sensível Às Palavras e a Censura Moderna

noreply@blogger.com (Bruno Moreira Guedes) — Sun, 21 Nov 2010 16:52:00 +0000

Palavras-Chave: War, Guerra Civil, Política, Desordem, Exageros

"War! The Republic is crumbling under attacks by the ruthless Sith Lord, Count Dooku. There are heroes on both sides. Evil is everywhere.

In a stunning move, the fiendish droid leader, General Grievous, has swept into the Republic capital and kidnapped Chancellor Palpatine, leader of the Galactic Senate.

As the Separatist Droid Army attempts to flee the besieged capital with their valuable hostage, two Jedi Knights lead a desperate mission to rescue the captive Chancellor...."

(Star Wars Episode III Opening Crawl - Fonte/Propriedade: StarWars.com)

Começo este post com esta citação da introdução do episódio III de Star Wars. Não sei por que, mas sempre achei aquele "War!" no começo muito impactante para referenciar conflitos. E é sobre conflitos, justamente, que estou escrevendo neste exato momento. O ano de 2010 foi um trágico período para a civilização, uma vez que senti um clima de "polarização total" do país. E não estou falando apenas de política e certas redes de TV não. Mas, confesso, que a "guerra" em torno das palavras de Luiz Carlos Prates me deu um "empurrão" para começar a escrever este post.

Como se não bastasse a polarização, um novo modelo de ditadura - que está em alta no mundo todo - vem sendo empregado no Brasil. Não é a ditadura da violência e do autoritarismo, onde o governo usa seu poder militar para controlar as pessoas na marra, mas sim a ditadura dos estereótipos sociais. É uma forma de poder imperceptível a olho nu. Já vamos falar sobre isso.

Histórico

Quando eu era pequeno, mas já grandinho o suficiente para entender o futebol, eu fui pressionado pela população de minha também pequena cidade natal a escolher: Sport Club Internacional ou Grêmio Footbal Porto-Alegrense. Parece irrelevante - e até confesso sentir orgulho de ter optado por ser colorado - mas aquilo já foi um sinal de que há uma tendência humana à polarização em certas situações.

Os anos foram passando, e eu crescia, mas sempre observava as pessoas e a sociedade, e já percebia que algumas pessoas manipuladoras tinham uma tendência a criar barreiras à aceitação de ideias opostas. Barreiras estas que eram disfarçadas em palavras cheias de sensatez e conhecimento.

Chegamos aos tempos atuais com uma revolução cultural causada pela Internet e pelas redes sociais. Agora a onda do momento é ser "cult". Ou seja, ser uma pessoa aberta, que ouve as opiniões dos outros e tem o poder de expressar a sua livremente. E todos querem entrar nesta onda. Agora vamos entender melhor o cenário a ser analisado.

O Cenário

O fenômeno é muito simples. O ser humano - cheio de receios, preconceitos(especialmente contra si mesmo), valores futilizados, necessidades sociais, medos bestas e vontade de "se enturmar" a todo custo - prega toda esta filosofia falsa que mencionei no último parágrafo do histórico do quadro. No entanto, alguns grupos um pouco mais espertos, perceberam que com estratégias de manipulação mais inteligentes pode ser possível manipular os formadores de opinião: as pessoas que pensam criticamente, e que apresentavam tendência a opor-se à manipulação no passado.

Afinal, se eu manipular a camada pouco interessada da sociedade, com estes meios de comunicação todos, fica fácil para as pessoas mais críticas expressarem sua oposição e abrir os olhos da maioria. Agora, o que dizer sobre a estratégia de manipular - de forma deliberada e bem planejada - aqueles que têm a opinião respeitada por muitos, que são as pessoas de histórica capacidade e interesse crítico? Afinal, se eles comprarem a ideia, eles farão o trabalho sujo de disseminá-la.

E um dos pontos chave para esta estratégia deliberada de manipulação das massas, foi a Censura Moderna: o ataque covarde ao orgulho do cidadão para evitar a oposição. O mais engraçado é que isso é feito de forma tão subliminar e oculta, que este ato encontra-se disfarçado de prova de sensatez ou até mesmo bondade. É a mais pura obra da engenharia social - utilizada para os mais perversos fins de pessoas de más intenções. Alguns poderão até chamar-me de louco, mas os conceitos de vício e virtude da literatura do fim da idade média estão renascendo.

Manipulabilidade

As pessoas se mostram cada vez mais manipuláveis. O gado, que se comporta conforme o desejo do boiadeiro. Não é uma crítica, apenas um feedback - apesar de sabermos que culturalmente o brasileiro não é aberto a receber feedbacks, pois os considera uma vergonha, ofensa ou crítica.

O segredo da manipulação é muito simples. Uma das técnicas muito utilizadas é chegar com a maior cara de boas intenções, e alertar as pessoas sobre alguém que anda falando falcatruas sobre xyz. "Alguns boatos estão ofendendo a nossa causa/política/filosofia/luta/imagem, dizendo que . Mas, vocês podem ver que ".

Outra técnica, daquelas que mais ferem o orgulho do ser humano, é uma evolução daquele velho argumento fraco de "Todo mundo sabe que". É simples: em vez de dizer "Todo mundo sabe que", tente fazer parecer obvio sem usar frases manjadas. O ser humano é orgulhoso demais para manifestar discordância a coisas obvias. E se manifestar, todas as demais pessoas te olharão esquisito e chamarão de louco - afinal, é tão obvio que você está errado.

Já sei: alguém vai me dizer que seria inviável disseminar massivamente a obviedade de uma ideia. Agora eu já penso diferente. Pensando agora como investidor, se eu tiver um bom laranja(pessoa de suposto renome), uma quantidade de 7 casas decimais em reais(para veicular uma reportagem na Veja, por exemplo), e um potencial de ganhar - em um determinado prazo - 8 casas decimais em reais com o não-questionamento disso, será que eu não consigo? Afinal, quem vai questionar algo que saiu na Veja, e que mencionava estudos do Sr. Fulano de Tal, que dizia na reportagem ser Dr. em Prosopopeias Flácidas para Acalentar Bovinos(Conversa mole para boi dormir) pela Universidade da Conxinxínia?

Ahh, e os cientistas? Claro. O que um cientista publica sempre é lei - a não ser que ele contrarie algo que "todo mundo sabe" e ganhe um Prêmio Ignóbil por isso. Um grupo limitado de "seres acima de nossa capacidade" estuda evidências e sai escrevendo artigos - que podem até, em inúmeras vezes, serem fruto de um estudo sério - como se eles fossem verdades absolutas . E quem for capaz de questionar é um "ignorante", que acha que conhece mais que os cientistas que estudam a coisa há tantos anos. Foi assim que acreditou-se por tantos séculos que Aristóteles estava certo ao afirmar que corpos de pesos diferentes caem em velocidades diferentes, e que o Sol girava em torno da terra.

Este movimento da ridicularização que mencionei, começa por um comportamento em sala de aula nos primeiros anos de estudo, através daquelas falhas que mencionei antes relacionadas ao orgulho do ser humano. "Questionar o que um professor diz é 'mico' demais para eu fazer. Prefiro fingir que concordo e ser burro". E quem não pensa desta forma vira motivo de piada entre os colegas de aula.

E ai do aluno que disser que não consegue acreditar no evolucionismo. Existem ridicularizações "enlatadas", que já vem prontas para serem usadas através de estereótipos. Um exemplo típico é o caso deste dogma marcante na sociedade ocidental, que criou a ideia de que se você não acredita em evolucionismo, você NECESSARIAMENTE acredita em criacionismo e faz parte do "clero".

-Professora, eu não acredito no evolucionismo.

-Tudo bem, se você tem suas crenças religiosas nós não vamos feri-la aqui, respeitamos sua religião blá blá blá...

Agora temos outra força de manipulação: A distorção. Segundo o dicionário, distorcer significa "mudar o sentido(Fonte: http://www.dicio.com.br/distorcer/). Só para esclarecer, uma única palavra, em frases e contextos distintos, pode significar coisas necessariamente diferentes - e nisso eu acho que não escrevi nada além do obvio. Agora imagine uma oração, em textos distintos, de quantas maneiras pode ser compreendida?

Se alguém tem dúvida de que textos e palavras PODEM SER(e de fato são) distorcidos, me envie qualquer texto um pouco maior para ver se eu não distorço. Já até me preparo para os comentários depois da publicação deste texto:
-Lá vem o Bruno novamente com suas teorias conspiratórias!

Como se o ser humano não tivesse capacidade, habilitação, e participações históricas em sistemáticas sociais para uso a seu próprio favor. As pessoas acham que só porque vivemos em um regime TEÓRICAMENTE democrático(porque para o poder ser de todos, todos precisam participar, e isso NUNCA ACONTECEU), significa que não podem existir complôs de minorias para tirar proveito de situações. Claro, nunca existiram cartéis, esquemas de corrupção, fraudes feitas por quadrilhas, etc. Nunca leremos sobre este tipo de coisa nos noticiários, ninguém faria isso!

Esta máquina de preconceitos sociais do ser humano é uma forte arma usada - por alguém ou por um conjunto de coincidências - para criar este clima de polarização e irracionalidade que tomou conta de nosso país neste ano. Eu não vou falar que estou de fora, não, pelo contrário, eu também faço parte - pelo menos parcialmente - desta situação. Mas é preciso reconhecer o problema para poder agir e solucionar, e estou tentando despertar essa problemática para todos. Digo ainda que muitas pessoas já haviam percebido um, alguns, muitos ou todos estes problemas que mencionei. Mas o fato é que é preciso enxergá-lo como um "superset" de problemas sistematizados e estruturados que geram essa situação social toda.

"Satisfação garantida
Obsolescência programada
Eles ganham a corrida antes mesmo da largada
Eles querem te vender, eles querem te comprar
Querem te matar de rir, querem te fazer chorar
Quem são eles?
Quem eles pensam que são?

Vender, comprar, vendar os olhos
Jogar a rede... contra a parede
Querem te deixar com sede
Não querem te deixar pensar
Quem são eles?
Quem eles pensam que são?"
(Engenheiros do Havaí - 3ª do Plural. Fonte: http://letras.terra.com.br/engenheiros-do-hawaii/747530/)

A Guerra

Agora quem começou a ler esta introdução deve estar com um "nó" na cabeça: Bruno, porque tu começou falando de guerra e agora apresentou tudo isso? Nós estamos no meio de uma única guerra, que é dinâmica e nos usa ora para um lado, ora para outro. Servimos aos dois, e o pior de tudo é que todos perdemos de um jeito ou de outro.

Alguns exemplos que polarizam o país:
"Partido T" x "Partido S"
"Rede de TV G" x "Rede de TV R"
"Norte/Nordeste" x "Sul/Sudeste" (esta está na moda)
"Ricos" x "Pobres"

São todos temas polêmicos e cheios de estereótipos por trás. A manipulação através da ideologia está cada vez mais dividindo a sociedade, e fechando sua mente contra as "terceiras opções". Estamos bipolarizando o mundo em nossa volta, de forma manipulada. Comecei este texto falando que o "Caso Prates" me motivou a escrever este texto. Uma vez que um comentário que - tenho que admitir, com palavras um pouco ambíguas e com seu tom "ideologicamente apaixonado" - soou um tanto agressivo(ainda mais para quem não é acostumado a ouvir os comentários dele), precisamos analisar a forma como ele foi manipulado e transformado em "bandeira do preconceito".

E aí? Agora os preconceituosos usam o discurso dele para embasar seus preconceitos, e os "anti-preconceito" radicais distorcem-no(eu disse DISTORCEM, porque recortar e exibir só os trechos que parecem ofensivos é um atentado COVARDE à dignidade de uma pessoa).

Deixando o polêmico caso de lado, já que não é o objetivo, vou mencionar outras coisas. As pessoas estão "ultra-sensíveis" às palavras, especialmente aquelas que enquadram-se em estereótipos e elementos de manipulação utilizados em guerras bipolares. Um exemplo disso é o racismo, cujos processos foram "moda" por muito tempo.

Eu não posso concordar que alguém possa ferir a dignidade de outrem com preconceitos por cor ou qualquer outro tipo de fator social, cultural ou genético. Mas a situação tornou-se complicada, estamos estimulando o ódio racial através da própria lei. Vou dar um exemplo: existem centenas de processos por racismo em situações que não houve má fé ou maldade em algum ato. Agora o vivente mal intencionado distorce as palavras de quem disse algo que possa ser interpretado como racismo, processa-o, e ganha - como a pessoa que foi processada não sustentará um receio contra o negro depois de uma experiência dessas?

Hoje em dia existe um grande vitimismo explorado por pessoas aproveitadoras. Lado hipofavorecido é defendido pela justiça. Acho que a intenção disso é certa, mas a forma como vem sendo aplicado não. Já disse outras vezes, COITADO de quem é BRANCO, HOMEM e HETEROSSEXUAL hoje em dia! Vamos lá, quantos brancos ganham causas processando negros por racismo? Quantas Delegacias do Homem e Leis Mário da Penha existem para proteger os homens? Quantos projetos de lei para garantir direitos aos heterossexuais existem?

Agora vou falar uma coisa muito séria: Todo mundo está preocupado com o heterossexual que discrimina o homossexual falando alguma coisa, mas ninguém preocupa-se com o que alguns(claro, não todos) homossexuais fazem as vezes. Um hetero chamando um homo de "bixinha" não pode, mas um homo chamando um hetero de "gostoso" em público pode? Um homo esbarrando propositalmente em um hetero e dizendo "aii, desculpa" com a única intenção de encostar-se, pode? E enganar um hetero travestindo-se de mulher, sem sequer dar um aviso antes: "olha, eu sou homem também"?

Existem muitas outras coisas para falar sobre a proteção ao hipofavorecido, mas este não é o tema central. O que quero dizer é que sempre aparece alguém para distorcer o que nós falamos. Eu tenho um defeito que considero similar ao do polêmico Luiz Carlos Prates: não tenho papas na língua. Falo o que penso e exerço meu direito à liberdade de expressão. Mas a "tendência ultra EMOtiva" da população está em alta, e sempre aparece alguém pra polemizar e dizer que se sentiu ofendido. Ora bolas, hoje em dia as pessoas ofendem-se por qualquer coisinha. Uma palavrinha infeliz no meio de um texto já é suficiente para a pessoa ignorar o sentido(aquilo que o emissor da palavra tinha a intenção de passar) e levar para o lado pessoal!

Sei que muitos não gostarão do que escrevo, mas o fato é que se nos importarmos tanto assim com o que alguém fala, e continuarmos levando todo tipo de feedback como ofensa, chegará um dia onde só existirá falsidade. Afinal, se um amigo meu tem um defeito e eu não sou macho para dizer isso a ele, o que eu sou? Uma pessoa verdadeira? E se algo está errado e eu me calo para não ofender ninguém? Afinal, a ultra sensibilidade às palavras me impede de emitir uma carga de emoção junto às minhas palavras para evitar o atrito, então mesmo que eu diga o que quero dizer, não estou traduzindo meu sentimento junto às palavras. Isso é cercear a liberdade de expressão.

E nisso estamos impondo uma censura às pessoas. Não me digam que a pessoa tem liberdade para falar e que esta reação é mera consequência do que se fala - com a qual temos que arcar pela liberdade de falar. Porque se me disserem isso, vou responder que na ditadura militar, ser preso, morto e executado também é só uma consequência com a qual temos que arcar pela liberdade de dizer o que quer. Afinal, os militares não colocavam esparadrapos na boca das pessoas para impedi-las de falar; mas sim puniam-no fisicamente DEPOIS delas terem falado. E a punição moral, através da ridicularização da pessoa ou da aplicação de estereótipos como "preconceituoso", "arrogante", entre outros, muitas vezes pode ser ainda pior do que uma punição física.

E agora eu fico mais em dúvida ainda quando reflito: Quem aplica estereótipos nos "preconceituosos", o que é? Afinal, um estereótipo é uma "generalização" de uma pessoa por falta de conhecê-la. Se não a conhece, é pré, e se é generalização é conceito. E o ser humano tem, sim, isso que ele tanto repudia.

Sobre a crítica, ou o feedback como prefiro dizer, as pessoas são incapazes de vê-las de forma positiva. Aplicam novamente o estereótipo: Quem critica é arrogante, quer ver o criticado mal, etc. Participei este ano de um seminário, o EMPRETEC, no qual aprendemos uma valiosa lição com nossos facilitadores: quando recebemos um feedback de alguém, a pessoa que quer crescer só pode agir de uma forma: agradecendo; e filtrando a parte que considera aplicável dele para transformar em ações para melhorar. Foi ofensivo? Você não gostou? Responder algo à pessoa, teimar, argumentar, discutir, ridicularizar... não trará nada de positivo pra ti.

O cenário de sensibilidade à palavra tornou-se tão forte que utilizarmos uma palavra X virou sinônimo de enquadrar-se no estereótipo Y. Se eu falo a palavra "miserável", sou um rico que tem preconceitos contra o pobre. Só posso utilizar a palavra afrodescendente para referir-me a um negro: se falo "negro" sou racista. Afinal, tudo que alguém fala precisa ser levado para o lado da ofensa?

Volto a dizer que cada um procura o que quer e é responsável pelo resultado obtido. Se eu passar a vida toda procurando chifres em cabeça de cavalo, mais cedo ou mais tarde eu vou encontrar, de uma forma ou outra. Se tenho o preconceito contra mim mesmo dentro de mim, é obvio que vou encontrar meu próprio preconceito no que o próximo fala.

E quando fazemos parte de um lado em um conflito bipolar, nossa tendência é de sempre encontrarmos estes preconceitos no lado oposto, e - curiosamente - nunca no nosso. É muito mais fácil ir a um colégio e xingar o professor do meu filho, do que admitir que meu filho é uma peste e que preciso fazê-lo mudar. A pimenta nos olhos dos outros é colírio.

É mais fácil chamar o Prates de babaca, preconceituoso, sem respeito pelos pobres, etc - do que reconhecer que fazemos "porcarias" no trânsito(e eu digo fazemos porque se muitos fazem a culpa é de TODOS). E ele ainda usou palavras-chave que levam ao clichê e ao estereótipo, tornando-se um prato cheio para aqueles que não querem enxergar a verdade - a parte positiva do feedback que é: existe gente demais fazendo "merda" com seus veículos, e precisamos tomar alguma providência enquanto sociedade(desculpem a palavra de baixo-calão). Aliás, ninguém importou-se com a necessidade de RESOLVER O PROBLEMA, só com o fato dele ter utilizado termos que PODEM, subjetivamente, ser interpretados por alguns como "ofensa ao pobre".

A consequência deste movimento todo, que é agravado sempre que temos anos de coisas polêmicas(eleições, por exemplo), é uma humanidade com pessoas cada vez mais isoladas umas das outras, menos unidas e capazes de trabalhar em conjunto. É por isso que todos agem tanto para deixar um mundo melhor para nossos filhos, e quase ninguém age para deixar filhos melhores para o nosso mundo.

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Critérios Estratégicos Para Voto

noreply@blogger.com (Bruno Moreira Guedes) — Wed, 29 Sep 2010 16:52:00 +0000

Palavras-Chave: Política, Eleições, Dicas, Estratégia

As eleições estão chegando, e como sempre neste período, vejo que a maioria das pessoas não tem nem uma definição de critérios para escolher quem vai governá-la por 4(ou 8) anos. Admira ainda mais saber que algumas não tem nem noção da função exercida por cada cargo e de como funciona o processo eleitoral. Bom, se você [e-]leitor for uma destas pessoas, vou falar um pouco sobre estes temas.

O Processo Eleitoral E a Função Exercida - Para Leigos

Primeiramente, minha entrada no assunto dos critérios requer um entendimento básico das funções dos cargos e do processo. Não vou detalhar muito o assunto, mas sim explicar resumidamente o suficiente para entender-se o tema. Aos que conhecem o processo, pulem este tópico.

Cargos Executivos(Presidente e Governador). São os cargos responsáveis por operacionalizar o governo. Efetuam a gestão OPERACIONAL do governo. Em outras palavras, o Presidente e o Governador vão mais FAZER as coisas do que DECIDIR elas(executor, por isso o termo "executivo"). Ainda assim, possuem funções decisórias no sentido de vetar parcial ou totalmente as decisões do legislativo, bem como criar Medidas Provisórias com efeito de Lei. Ambos os cargos possuem mandato de 4 anos, sendo prorrogáveis por mais 4 através da re-eleição. Também possuem um vice, que assume o cargo em primeira instância no caso de afastamento temporário ou permanente do mesmo.

O critério da eleição é a maioria(50%+1) dos votos válidos, sendo que se esta não for obtida, é realizado um segundo turno de votação com apenas dois candidatos(os dois mais votados no primeiro turno), aonde vence o candidato que obtém a maioria dos votos, ou o mais velho assume em caso de empate(minha gente, alguém acha que um dia vai haver empate em um país de 190 milhões de habitantes?).

Deputados(Estadual e Federal). São cargos legislativos que compõem a Assembléia Legislativa de um estado(Deputado Estadual), e a Câmara dos Deputados(Deputado Federal). Tem por finalidade principal legislar representando SEU PARTIDO. O período de mandato é de 4 anos, mas o cargo é pertencente ao partido e não ao candidato.

Como a função deste cargo é representar O PARTIDO, e existem um determinado número de vagas ao cargo para cada estado, é aplicada uma proporcionalidade de vagas a cada partido de acordo com os votos obtidos a este para o referido cargo(através de um cálculo complexo que vocês podem pesquisar sobre no Google, chamado Quociente Eleitoral ou algo assim). Entenda ao menos a idéia do Quociente Eleitoral e evitarás os chamados "votos de protesto"(votar no Tiririca só porque ele é palhaço e você está indignado, por exemplo).

Senadores. São cargos legislativos que compõem o Senado Federal. A finalidade do senador, diferente da finalidade do deputado(representar o partido), é representar as Unidades da Federação(Estado ou Distrito Federal) no processo legislativo. Cada estado possue sempre 3 senadores o representando, e o mandato de um senador - ao contrário de todos os demais cargos - dura 8 anos. O Senador possui, também, um primeiro e um segundo suplentes para substituí-lo temporaria ou permanentemente.

São eleitos os senadores mais votados em cada estado, de acordo com o número de vagas a serem preenchidas no Senado(nestas eleições são 2 senadores por estado). Ao contrário do deputado, o cargo é pertencente à chapa(Senador+2 suplentes), e não ao partido.

Estratégia e Critérios

Vou demonstrar meu modelo de estratégia e critérios para as eleições, sem pedir que concordem comigo, uma vez que cada um possui uma visão. Apenas estou demonstrando os meus procedimentos como um exemplo, e implorando a todos para que TENHAM ESTRATÉGIA E CRITÉRIOS, seja qual for o modelo utilizado.

O primeiro passo é definir os seus objetivos como eleitor. Que Brasil eu quero? Em que setores eu quero melhorias? E, é claro, colocar números quando possível para depois avaliar se os objetivos foram atingidos ou se estão caminhando mesmo para este rumo. Afinal, dizer que quer um Brasil com uma saúde melhor é abstrato demais, e você nunca vai se dar por satisfeito se o "melhor" for "mínimamente melhor".

Para ilustrar, são estes os meus objetivos para os próximos 4 anos:

1-Redução de 30% da carga tributária para as médias e grandes empresas, e 40% para a micro e pequena empresa.

2-Redução dos tipos de imposto a apenas 1.

3-Criação de um indicador padrão da qualidade da educação com acompanhamento anual de cada estudante.

4-Reduzir em 50% o desmatamento no país.

5-Reduzir 5% da emissão de poluentes no país.

6-Proporcionalizar as aposentadorias em "número de salários mínimos" para não defasar a receita dos aposentados

7-Incluir disciplinas de Direito e Cidadania, Finanças Pessoais e Lógica no curriculum dos ensinos Fundamental e Médio.

8-Reduzir em 30% o tempo médio dos atendimentos nos hospitais públicos, e em 40% o número de atendimentos(através da prevenção).

9-Reduzir em 10% as ocorrências policiais em todo o país.

Definidos os objetivos, temos que definir as prioridades. Ordene seus objetivos do mais relevante para o menos relevante. Por que? Simples: quem tenta fazer tudo faz tudo mal feito. E se todos os teus objetivos forem iguais, e um candidato disser que os objetivos dele são fazer tudo que você definiu como objetivo, provavelmente este candidato também não sabe priorizar as coisas e obtê-las na ordem de prioridade - e então tentará abraçar o mundo, acabando por não fazer nada direito.

A minha ordem pessoal de prioridades, de acordo com a numeração acima, é: 8, 9, 4, 6, 7, 1, 2, 5, 3.

Com as prioridades definidas, o próximo passo é definir de acordo com seus princípios quais são as características inaceitáveis dos candidatos para a política e para aquele cargo. Por exemplo, um presidente ou vice com problemas de saúde, por mais competente que seja, será tão inefetivo quanto um senador currupto(sim, inefetivo, atos desonestos dispendem tempo e energia que deveriam ser aplicadas para governar). Novamente, vou usar meus critérios para exemplificar as características gerais que não aceito nos candidatos:

1) Ficha suja ou forte suspeita popular de currupção.

2) Vivência profissional insuficiente(políticos acadêmicos vivem em um mundo teórico em outra dimensão, não podem governar no nosso mundo que é prático e real).

3) Desconhecimento das atribuições do cargo.

4) Históricos de ações controversas ao discurso eleitoral ou de falhas ao atingir objetivos propostos.

Agora, meus critérios de rejeição dos candidatos à Presidência da República e Governo do Estado são:

1) Conhecidos problemas de saúde ou similares que possam afastar a pessoa do cargo.

2) Sexo e idade que aumentem a probabilidade de licenças para afastamento(licença maternidade, para ser mais específico - nada contra as mulheres que ainda não chegaram na menopausa, mas governar o país e ficar gravida pode causar sérios problemas).

Meus critérios de rejeição dos candidatos à Senador ou Deputado:

1) Difícil acessibilidade(como vou eleger um cara a quem não terei acesso para fiscalizar e cobrar?).

Definidos estes critérios, busque no seu meio preferido candidatos que respeitem integralmente seus critérios, e que estejam o mais alinhados possível com teus objetivos - sempre lembrando de respeitar a ordem de prioridade dos objetivos, uma vez que alguns políticos defendem mais algumas causas do que outras! Por fim, ordene os candidatos localizados de acordo com a proximidade obtida nos teus critérios.

Com os candidatos ordenados, verifique mais a fundo nos mais próximos dos teus critérios se eles realmente estão de acordo com teus critérios de rejeição. Faça testes práticos quando possível. Um exemplo de teste é enviar um e-mail ou ligar para o candidato ou seus acessores para testar a acessibilidade do mesmo, e aproveitar para questionar e se certificar de que entendeu os objetivos do mesmo, e de que este parece confiável/sincero.

Para os cargos de Presidente, Governador e Senador, não deixe de fazer todas estas verificações também para os suplentes. Já para os cargos de Deputado Estadual e Deputado Federal, é preciso fazer uma avaliação um pouco mais profunda. É preciso incluir na avaliação o partido, de acordo com minha explanação sobre estes cargos no começo do artigo(O Processo Eleitoral).

Ao votar em um deputado, você não só vota nele, mas também vota para o partido dele ter mais vagas. Sendo assim, antes de votar em um deputado, verifique também se os candidatos do partido dele se encaixam nos teus critérios, e procure pesar isto no teu voto - uma vez que um pequeno número de votos a mais para um partido pode fazer com que tal partido tenha uma vaga a mais,que será aberta para alguém deste partido.

Bom pessoal, era isso que eu tinha a escrever sobre o tema em um primeiro momento. Desejo boa sorte para nós brasileiros. Não preciso nem comentar que o trabalho de eleitor não é só dia 03 indo votar.

Classificação do conteúdo: SÉRIO - UTILIDADE NACIONAL
Sobre mim:
Curriculum Vitae
Site Pessoal

A Reforma Política Segundo Eu Mesmo

noreply@blogger.com (Bruno Moreira Guedes) — Mon, 23 Aug 2010 02:23:00 +0000

Palavras-Chave: Política, Brasil, Tecnologia a Favor do Brasil

Toda hora vemos alguém falando em reforma política. É um tema que "pipoca" muito na cabeça das pessoas, nas propagandas do horário eleitoral, nos butecos de esquina e na casa da sogra. Mas o ponto que ninguém parece perceber, é que este tipo de reforma não deve ser liderada pelos políticos partidários - imparciais e, muitas vezes, sem visão do que o povo precisa - mas sim pelo povo, principal parte interessada na mudança. As idéias que venho defender neste texto são a participação popular nos poderes legislativo e executivo, o governo orientado a planos, e as eleições mais justas de candidatos reconhecidamente capazes.

Penso que o governo deve funcionar de forma similar a uma Sociedade Anônima, aonde todos os sócios podem participar do processo "legislativo" e "executivo". Defendo a criação de um Conselho Popular, do qual qualquer cidadão possa participar quando bem entender, sendo que o processo legislativo precise passar por este conselho. E, para simplificar as coisas, este conselho deveria ter poderes maiores do que o Senado e o Congresso.

Mas Bruno, você surtou? Isso seria uma loucura!! Bom, em uma primeira olhada eu até concordo. Mas penso que a maior loucura é eleger uma pessoa, e logo após precisar ficar 4 anos "mudo" aguardando passivamente que o indivíduo faça aquilo que eu acreditava-se que este faria. E isso não é apenas loucura: é passividade.

O referido conselho teria plenos poderes para aprovar leis e emendas constitucionais(com certas medidas de segurança, é claro) sozinhos. E este conselho participaria, em conjunto com as entidades atuais, do poder executivo. Esta participação se daria através da escolha, por votação, dos membros participativos do processo legislativo que tenham interesse em participar de uma "comissão executiva" - com poderes de veto de medidas oriundas do Senado ou da Câmara, ainda que sancionadas pelo Presidente da República.

Mas como viabilizar uma coisa dessas? As pessoas que quisessem participar do processo teriam que dirigir-se todos os dias a uma câmara? Não. Desta maneira não funcionaria. Temos que utilizar os avanços tecnológicos a nosso favor. A idéia é criar um mecanismo seguro, aonde as pessoas digitalmente certificadas e com direito a voto poderiam votar nas propostas deste conselho. E, além disso, um sistema de Wiki criaria, participativamente, o texto das leis e emendas a irem para votação. Obviamente, precisaria de um determinado número de interessados para permitir que este texto fosse para aprovação. Mas acredito que com um bom estudo, seja totalmente possível viabilizar isso.

Mas o que quero dizer com governo "Orientado a Planos"? Bom, eu acredito sinceramente que eleger apenas os candidatos não serve para nada. Afinal, nós elegemos eles, e eles fazem o que a plena vontade deles permitir. O que proponho aqui é que o país tenha um planejamento - como estes "planos de governo" que as coligações propõem no horário eleitoral, ou como o planejamento estratégico de uma empresa, mas que isso seja devidamente registrado e escolhido.

Deveríamos, antes de eleger o candidato, eleger um plano de governo - que deveria ser proposto por um partido político ou coligação, e assinado por um "Administrador Responsável". Logo após a eleição do plano de governo, os candidatos que considerarem-se capazes de assumir funções dentro deste plano de governo poderiam candidatar-se para os cargos que julgar conveniente. E não pararia por aí: caso o plano de governo não fosse cumprido devidamente, todo o "conjunto governamental" eleito responderia de alguma forma pela falha - tendo que justificar de forma concreta as razões para o plano não ter dado certo.

Finalmente, precisamos de eleições da qual somente os interessados devam participar, e que ocorram de forma justa - sem prejudicar ou beneficiar ninguém. Acredito que tudo deva ser orientado ao candidato, e não à coligação ou o partido político. Quem tem um tempo no horário eleitoral é o CANDIDATO. Quem tem o cargo é o CANDIDATO. Afinal, é nele que as pessoas votam - e não no partido dele.

Este candidato precisa ter plena competência para exercer o cargo. É preciso estabelecer, primeiramente, uma formação necessária para exercer cada cargo político. Precisamos que somente candidatos capacitados possam assumir seus postos. Mas muitos vão me falar: "isso é injusto, pois vai privilegiar os que tem condições de formarem-se?". Bom, isso é um problema muito simples de se resolver: basta criar uma capacitação obrigatória a ser oferecida gratuitamente aos candidatos que forem eleitos pelo povo. Algum curso, que não seja tão extenso, e que seja oferecido gratuitamente ao candidato eleito pelas universidades, para que ele só exerça o cargo após a formação.

Acredito que toda esta visão que tentei passar possa parecer futurista, pouco praticável, irrealista ou qualquer coisa que alguns possam dizer. Mas acredito que a viabilização desta seja só uma questão de deixarmos de pensar "não dá", e pensarmos da seguinte forma alternativa: "como fazer isso?". Com a participação da sociedade tenho certeza de que juntos encontraremos uma forma de viabilizar tudo isso. Afinal, precisamos urgentemente de mecanismos para o povo governar.

Eu escrevo este artigo, que prometi em meu artigo anterior concluir até hoje(22-08), para propor uma visão de algo que deve ser comum a todos, indiferente ideologia e/ou posição política defendida por cada um - e gostaria de uma participação de todos que o lerem - pedindo apenas a gentileza de ser o mais "políticamente ecumênico" possível, sem mencionar síglas, candidatos ou qualquer coisa similar. Acredito que muitos concordarão com minha visão, e peço muito o apoio destes para fazer a idéia amadurecer.

Quero ler muitos comentários construtivos, que me ajudem a criar um "esboço de projeto" de como fazermos isso. Obrigado a todos pela atenção: o Brasil precisa de nós.

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Código Eleitoral, Eleições e Vigarices

noreply@blogger.com (Bruno Moreira Guedes) — Tue, 17 Aug 2010 18:21:00 +0000

Palavras-Chave: Política, Eleições, Brasil

Ano de eleições denovo. As eleições vindo, "novos" candidatos, "novas" propostas, agora tudo é novidade. Mas dia 01/11/2011 tudo volta ao normal, as "novidades" são esquecidas e todos concentram-se em justificar o que não acontecerá. É assim desde antes de eu nascer, e creio que continuará assim até bem depois do meu falecimento - ainda que eu viva todo tempo que eu quero viver(me contento com 500 anos).

O problema das eleições é que temos sempre os mesmos candidatos, embora seus nomes sejam outros. Fernando, Tupetudo, Fernandois, Luizinho, agora a briga entre Zezinho e Mariazinha, que defendem a mesma coisa, e por aí vai... Enfim, tenho a sensação de que desde meu nascimento o Brasil foi governado por duas pessoas diferentes - e isso só porque mudanças econômicas ocorreram quando eu era pequeno, pois se não fosse isso eu teria a sensação de que foi uma pessoa só.

Recentemente o TSE ~~cagou~~ entendeu que satirizar um candidato, por exemplo, é prejudicial à democracia(vide nesta matédia do Danilo Gentili). É bem compreensível: vamos fazer a democracia impedindo a livre manifestação das pessoas - muito similar às democracias da China e de Cuba. Que idéia genial do TSE, afinal, a decisão do povo acontece quando este se cala no conceito desta palavra em nosso país. O mais curioso que notei na referida matéria é a dolorosa verdade de que alguns candidatos possuem um enorme tempo, e outros possuem tempo "bilau de japa".

Isso até não me revoltaria tanto se o tempo fosse bem utilizado, e se houvessem regras RESTRITIVAS de como utilizar o tempo de cada candidato. Afinal, se eles tivessem que usar o tempo somente para CONTEÚDO ELEITORAL DE VERDADE, certamente alguns candidatos não conseguiriam preencher mais do que 2 ou 3 minutos. Mas, graças a esta "liberdade total" para usar o horário eleitoral(financiado pelos nossos bolsos), vemos candidatos contando a história de suas vidas, colocando musicas para agradar o público de determinadas regiões do país(não vamos citar quais), contando das dificuldades da infância, do quanto batalharam na vida - vida esta que é dramatizada como nas novelas, sem falar no lero-lero de apresentar família e outras baboseiras do gênero.

Isso não só é desperdiçar dinheiro público, mas é, também, fazer o eleitor devidamente instruído sentir-se um palhaço por ter que assistir aquilo. E, o que é pior, utilizar de artefatos publicitários exagerados para causar emoção e comoção no povo menos instruído, o que me parece ferir o Art. 242 do código eleitoral ao meu modesto e leigo entendimento(eu precisaria compreender o que o claríssimo legislador entende por "estado emocional artificial"). E este tipo de coisa, que eu juro que não estou vendo pela primeira vez, é a maior de todas as sujeiras.

A razão de meu repúdio a esta atitude não é só por abusar do lado emocional do eleitor - esta é a parte menos grave. O que acho lamentável é que alguns possam fazer isto e outros não. Afinal, como você vai causar impacto e emoções, e ainda falar algo complementar, com 1 minuto de tempo? Se for para causar falsas emoções/comoções no povo, então que todos possam ter o direito de fazer isso. Eu preferiria que NENHUM pudesse, mas antes TODOS do que APENAS ALGUNS.

Agora vejam a incoerência das coisas. Os cargos de Senador, Deputado Estadual e Deputado Federal - aqueles que realmente legislam, e que possuem um número muito maior de candidatos/opções - possuem alguns segundos para manifestar-se. Os coitados precisariam transformar-se em narradores esportivos para falarem 10% do que provavelmente teriam a dizer. Agora, apesar do pouco tempo e da quase impossibilidade de perceber o potencial destes candidatos no horário gratuito, são das mãos deles que saem todas as decisões que afetam nossas vidas.

E o que acaba acontecendo? Aquele candidato de maior poder econômico consegue o destaque neste momento, com propagandas diferenciadas das dos demais candidatos, além de possuir "recur$$os" para utilizar de divulgação em outros meios. Nada contra isso também, desde que TODOS TENHAM ACESSO IGUAL a todos os meios - o que de fato não ocorre.

Em contra-partida, o candidato a presidente e a governador, que não é menos importante - uma vez ele executará as decisões que os demais aprovarem, além de vetá-las se necessário - terá um tempo muitas vezes maior do que o de todos os demais cargos somados. Eu considero isso uma tremenda incoerência.

E, finalmente, um item que faz parte da política e eu discordo mais do que tudo neste mundo: a entidade partidária como "balança" da política. Já ocorreram enormes polêmicas no país porque alguns cargos são "do partido". Não tenho muito o que opinar aqui sobre a fidelidade partidária, mas acho que o cargo pertencer ao partido é outra incoerência que entope as veias de nossa sociedade. Algum eleitor aqui, alguma vez na vida, votou no PT ou no PSDB para deputado estadual? Ou então no PSOL para deputado federal? Eu não conheci ninguém, em toda minha vida, que tenha votado em uma sigla - conheço apenas pessoas que votaram em candidatos, e estas eu conheço aos montes. Então que palhaçada é essa de "o mandato é do partido"?

Agora retomando o raciocínio original do texto, eu acho uma palhaçada esta história de que cada partido tenha um tempo, e que as coligações possuem o tempo dos partidos somados. Não. Não pode ser assim de modo algum, isso é um erro absurdo, uma incoerência com a democracia. Minha humilde opinião é a de que o tempo deveria ser por candidato - indiferentemente do cargo(ou seja: candidato a deputado tem o mesmo tempo do candidato a presidente, a única diferença que posso concordar é em relação a abrangência do cargo, entre um cargo federal e um estadual, caso seja realmente justificável por razões de viabilidade). E, é claro, cada candidato só poderia falar sobre sí mesmo e sobre suas idéias, sem CITAR O NOME DE OUTRO CANDIDATO para não gerar qualquer tipo de vínculo.

Bom pessoal, esta é a pura manifestação de minha idéia. Outra hora, com mais tempo, vou escrever um artigo sobre minha idéia de "NOVA ESTRUTURA LEGISLATIVA" para o país. Vou aproveitar que estou escrevendo para lançar o convite a todos para ler no próximo fim de semana(dia 22-08) o artigo que estou preparando sobre o tema. Vou lançar, não tendo a mínima idéia do sucesso ou fracasso disso - e contando com a contribuição de todos os interessados, um abaixo-assinado para a criação de um plebiscito discutindo o tema. Acredito que as entidades da política partidaria sejam "parciais" demais para fazer alguma coisa em relação ao avanço da política no país, e que a responsabilidade seja nossa.

Vamos utilizar agora o que a tecnologia nos oferece para fazer o que foi inviável no passado e melhorar nosso país. Tenho certeza de que todos gostarão de minha proposta.

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Porque não vou mais ao FISL?

noreply@blogger.com (Bruno Moreira Guedes) — Thu, 01 Jul 2010 04:42:00 +0000

Palavras-Chave: Software Livre, Liberdade, Libertinagem, The Pirate Bay, Peter Sunde, ASL

Para variar, hoje vou ser polêmico - e como sempre, tentar sem sucesso não ser ofensivo. O FISL - Fórum Internacional de Software ~~Livre~~ Libertinoso é um evento do qual participei três vezes e achei muito interessante. Até ano passado, quando cheguei até a pagar a inscrição mas não compareci. Me revoltei sériamente.

Sempre me considerei de certa forma um "militante" so software livre. Quem duvida que pergunte aos meus colegas de aula do segundo grau o quanto eu falei a todos sobre o perigo que seria para todos as patentes de software. O problema é que - apesar do nome - o FISL e as pessoas por trás dele deixaram de defender o software livre. Passaram a defender as idéias abusivas e libertinosas. E isso chegou a um extremo inaceitável quando o FISL do ano passado utilizou como principal atração Peter Sunde - um dos fundadores do The Pirate Bay(site que publicava links de torrents piratas).

Não que eu concorde com a maneira como o dito vivente foi injustiçado. Afinal, ele não violou copyright algum até onde eu fiquei sabendo do caso.Ele apenas criou um web-site aonde as pessoas publicavam torrents de conteúdos não necessariamente piratas. E ainda acho, sim, que o julgamento dele não teve nada de justo e que as gravadoras deixaram a ética de lado e certamente cederam algum benefício aos juízes envolvidos na condenação.

Mesmo assim, o tom que isso gerou na comunidade de software livre - especialmente nas pessoas que estavam tendo os primeiros contatos com ela - foi de que defender software livre é defender pirataria e coisas gratuitas para todo mundo. Quando me posicionei a favor do software livre o conceito era outro.Vi a maioria das pessoas "vestindo a camisa" dessa idéia de associar software livre à pirataria.

E o que as pessoas do movimento do software livre - em geral - faziam? Adivinhem? Aproveitavam a situação e a mídia que isso deu ao FISL e ao movimento - ao invés de posicionarem dizendo a toda esta multidão que eles estavam errados, e que a pirataria é nociva à liberdade. Eu achei tudo isso um lance de oportunismo puro - muito nocivo à imagem do movimento.

Agora vou dizer para vocês aonde as pessoas pecam com esta visão. Software proprietário impede o usuário de ser livre com ele. Mas o usuário ainda é livre para escolher optar por um equivalente livre ao invés de utilizar o software proprietário. Ou para desenvolver o seu software e licenciá-lo sob GPL depois. Agora a liberdade do usuário é o que mais conta sempre?

E a liberdade do produtor do software, da música, do livro ou do "seja lá o que for"? Afinal, não foi ele quem tomou litros de energético para fazer a coisa funcionar? Não foi ele quem ralou, pesquisou um monte, abdicou de tempo da vida dele e até de dinheiro as vezes para desenvolver o troço? Então o mínimo que ele tem é o direito de escolher o que fazer com a criação dele.

Eu acho legal a idéia de software livre. Produzi bastante coisa com licença GPL, apesar delas geralmente terem ficado pouco ou nada conhecidas e talvez só terem servido para mim mesmo. Agora meu último projeto que eu iria publicar com licença GPL virou meu ganha-pão, minha fonte de sustento. E com excessão de empresas como a Microsoft, que lucram com a pirataria que dissemina amplamente seus softwares, a maioria das pequenas empresas deixa de ter uma receita que faz falta devido à pirataria.

Acho violar a licença de um software proprietário comparável a violar a própria GPL ou outra licença livre similar. Temos empresas brasileiras que violam a GPL. Tivemos uma grande rede de IRC no Brasil que violava. E se a idéia fosse a de que software livre significa violar licenças, a comunidade de software livre estaria se auto-contradizendo.

Por último, focando novamente no FISL - tema deste post - eu gostaria de saber algo que até hoje ninguém me respondeu: O que diabos Peter Sunde fez pelo software livre que trouxe a ele este status de destaque no FISL? Esta pergunta permanece um mistério - e até que seja dada uma resposta coerente eu me recuso a participar de qualquer coisa relacionada ao movimento de software livre no Brasil. Isso porque é injusto dar todo este destaque a um cara que não fez nada pelo movimento, enquanto tantas pessoas vem fazendo um trabalho sério neste meio e não tem seu devido reconhecimento.

Por hoje é só isso pessoal.
---
Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Ultra-Feminismo Exagerado

noreply@blogger.com (Bruno Moreira Guedes) — Sat, 19 Jun 2010 06:10:00 +0000

Palavras-Chave: Ultra-feminismo exagerado, vida moderna, sociedade, mulheres, estereótipos

Hoje resolvi criar polêmica. E que ninguém diga que estou fugindo do assunto original do meu blog, uma vez que este assunto pode ser classificado como parte das "Besteiras Gerais" que você vai ler na barra de títulos. Como tudo que escrevo de polêmico, estou falando sério, mas isso não significa que vocês leitores precisem levar tão a sério. E talvez eu escreva em vão, já que mulher nenhuma lê este blog também.

As diferenças entre os sexos são muito complexas de entender, e muitas vezes chatas. Mas ainda bem que existem, porque eu é que não ia querer beijar ou casar com alguém que parecesse comigo ou que tivesse comportamentos masculinos. Mas falando sériamente, alguns e-mails destes que as pessoas mandam para todo mundo e insistem em me mandar(que confesso, nos últimos tempos tenho até lido de tanto insistirem em me mandar) - além de mensagens que vemos em blogs, perfís de orkut, mensagens no twitter ou MSN, ou no que mais você imaginar - que contém mensagens superficiais e pouco reflexivas, revelam ter sido criadas pelo pior tipo de mulher: as hipócritas que não aceitam a realidade que elas mesmas confirmam(olha o estereótipo denovo). É claro que você, minha amiga que eventualmente esteja lendo isto, não faz parte desta realidade, uma vez que procuro manter a distância mínima de 1km de mulheres que percebo fazerem parte deste gênero.

Este é um exemplo do tipo de texto ao qual me refiro(a blogueira-autora que me desculpe, mas é o primeiro resultado-exemplo do Google). Agora eu peço que leiam o texto(é curto). Me digam: pelo texto, ela quer um homem ou um animal de estimação? Um homem que te ligue de volta mesmo quando você desligar na cara dele? Isso é um homem ou é um idiota candidato a corno? A mulher que espera isso de um homem quer realmente um homem? Pois está parecendo que ela quer um satélite girando em órbita dela. Agora vamos ser bem sinceros, ainda que um homem seja babaca o suficiente para disfarçar-se de satélite e orbitar nessa mulher, certamente ela não aguentaria 7 dias. É grude! Um cara não se auto-aguentaria se ele fosse assim.

Outro exemplo comentável é essa piada que é, diga-se de passagem, engraçada, mas que revela outro ato ultra-feminista que tenta fazer a mulher ser "superior" ao homem. Vejam, leitores, que o artigo retrata nós homens como auxiliares de serviço geral. E ainda tenta criar na cabeça do homem um "conformismo", tentando insinuar que se não nos submetermos a esta condição seremos trocados por algum idiota que se submeta.

Agora, pessoal, este texto é de um homem que perdeu as características masculinas(e agora femininas) que ele próprio aponta e aparenta admirar nas mulheres. Esta parte do texto é direcionada aos homens que perderam o amor próprio e a auto-estima a ponto de achar que precisam ser "modelados ao gosto das mulheres" para se relacionarem com mulheres legais, como o texto mencionado aponta. Você homem também não precisa ter medo de nada, e nem das "ameaças" que o ultra-feminismo vem colocado em suas cabeças(entenda como quiser). Sabe porque? Porque se uma mulher não te deu valor, você não é obrigado a continuar com ela. Você com certeza vai achar uma mulher a altura - e enquanto não achar poderá divertir-se com as que são como a tua ex que te colocou as coisas na cabeça. Agora não ligue para estas histórias de "o mar não está para peixe".

E você, mulher, finja que foi para você também o parágrafo anterior. Ninguém, seja homem ou mulher, deve reprimir seus conceitos e princípios somente pelo medo de ficar sozinho ou de perder alguém. Valorizem-se, seres humanos.

Claro que nestes parágrafos de críticas aos textos falei o essencial da mensagem que quero passar. Não quero dizer que o homem tenha que ser relapso no relacionamento e menos ainda que a mulher tenha que aceitar. Mas sim que, em um relacionamento adulto e maduro, não devemos ficar com medinhos do tipo "ela vai me deixar", "ela vai me chifrar", "ela vai me trocar por outro", etc - e nem que as mulheres devam repassar este tipo de mensagem colocando elas como "as donas da bola", que se o jogo não for com as regras dela ela pega a bola e vai jogar em outro estádio.

Ahh, claro, antes que eu esqueça de falar, também existem também as ultra-feministas princesas. São aquelas que difundem a idéia de que homem não presta, não se acha um homem decente, etc. Aí um cara legal que não tem os defeitos que elas apontam como inaceitáveis se interessa por ela. E aí? Ahh, ele não, ele é legal mas é só amigo porque ele é feio. Aquele ali também é legal, mas é só amigo porque ele é um pobre coitado. Aquele outro também não, porque ele . E, por fim, ela vai acabar saindo com os que tem logo os defeitos que elas consideram inaceitáveis, pois como não encontra o "homem perfeito" dela ela prefere se divertir com imperfeitos. E ainda sai repetindo por aí que homem não presta, etc.

Bom, primeiramente a "lista de exigências" de mulheres deste gênero é impossível de ser atendida, por mais que elas queiram. Mas, agora vamos analisar a indivídua que quer exigir tudo isso de um homem. Será que ela parou para olhar para o próprio humbigo? Ela tem espelho em casa? Ela não o quer porque ele não é bonito, mas é uma baranga. Ela não o quer porque ele não é um homem "culto e inteligente", mas ela não sabe falar 2 minutos sobre algo que não seja fútil e idiota. Ela não o quer porque ele é pobre, mas além de ser mais pobre ainda ela deve até as calcinhas para comprar as merrecas que tem, além de ser interesseira o suficiente para pensar desta maneira.

E a pior parte desta última espécime de mulher é a síndrome de "eu não sou assim". Este tipo de mulher vai ler este texto, dizer que concorda comigo - e talvez até acreditar que realmente concorde, mas na prática ela é totalmente diferente. Afinal, o mundo tá cheio de mulheres assim, mas nenhuma delas age de tal forma.

Agora, todos os problemas do ultra-feminismo exagerado que mencionei tentam moldar os homens, torná-los o que eles não são e reprimí-los. E isso não está certo, e as principais prejudicadas com isso são as próprias mulheres. Querem saber porque? Bom, você mulher vai pra balada e conhece um gostosão certificado pelo INMETRO como homem perfeito. E você também tenta ser uma mulher perfeita certificada. Então vocês são dois mascarados se beijando.

"Mas Bruno, porque você está falando isso"? Porque 99,9% dos relacionamentos começam de modo análogo. A balada pode ser um evento, uma sala de aula ou qualquer outro lugar. O fato é que estas mascaras podem perdurar muito tempo - e o pior é que perduram. Então elas vão descascando aos poucos, quebrando um pedaço aqui e outro ali da máscara, e então bum. Cinco anos passaram-se e as pessoas não são mais aquelas do começo do relacionamento. "Ele mudou, ele não presta mais, etc". E aí os pretextos são inúmeros. Na TV agora passa o programa da Universal, e segundo eles o que causa isso é um encosto, um espírito maligno. Enfim, cada um deve acreditar no que prefere.

Mas, para mim, o "encosto" é esta tentativa de "padronizar príncipes encantados" que não existem no mundo real. Por isso eu digo pra todo mundo, seja homem ou mulher: seja você mesmo(a). Você não vai ser aceito hoje? Não é o príncipe ou a princesa de ninguém? Ok, uma hora essas pessoas cairão na real e saberão valorizar uma pessoa de verdade e não um estereótipo. Enquanto isso você curte a vida, cresce profissionalmente, estuda, etc. Atividades para dedicar-se não faltam. Bancar o príncipe ou a princesa agora é ser rebaixado a sapo em 12 meses.

Acreditem, dá certo. Eu não sou um príncipe encantado. Sou pobre(claro que isso é temporário), não tenho ensino superior nem carro, sou grosso/estúpido as vezes, estressado quase sempre, e apesar de apresentável não sou nenhum bonitão. E mesmo com tudo isso estou casado. Achei, e nem demorei tanto, uma pessoa que me aceita. E enquanto ela continuar me aceitando, sem exigir nenhum disfarce de mim, meu casamento continuará existindo.

Agora, temos que estabelecer algumas realidades aqui. Não quero generalizar, mas o que vejo é meio generalizado mesmo, e só estou relatando. As mulheres adoram conquistar novos direitos e a dita "igualdade com os homens", mas só no lado interessante. Elas querem trabalhar, mas querem começar e estar sempre em cima pré-maturamente. Querem dirigir, mas não querem conhecer a mecânica do veículo(irresponsabilidade total com elas mesmas). Pensam que os homens devem parar na faixa para elas, mas no entanto eu NUNCA VI UMA MULHER PARANDO NA FAIXA PARA UM PEDESTRE.

Espero ter conseguido fazer as pessoas chegarem a uma reflexão sobre o assunto. Nem vou comentar sobre este blog que eu ouvi falar no programa do Jô ontem, pois acredito que as meninas lá estejam de onda. Porque se estiverem falando sério, elas são as espécimes às quais me referia com "ultra-feminista princesa". E não duvido mesmo que possa ser sério, uma vez que de acordo com elas o homem é que tem que pagar o motel e isso é regra.

Espero que minhas amigas continuem sendo minhas amigas. Respeito muito as mulheres, até porque foi uma que me aguentou na barriga por incríveis nove meses, e como trata-se de mim isso é um record. Só escrevi algumas palavras com conselhos para o próprio bem delas. Afinal, homem pode não prestar ou "ser tudo palhaço", mas se não houvesse um homem para acasalar com as mães delas elas sequer existiriam.

---
Classificação do conteúdo: SÉRIO
Sobre mim: Curriculum Vitae Site Pessoal

Dia da Toalha e Orgulho Nerd? O cacete!

noreply@blogger.com (Bruno Moreira Guedes) — Tue, 25 May 2010 15:00:00 +0000

Palavras-Chave: Nerdismo, Modismo, CabeçaDeTv

Dia do Orgulho Nerd? Dia da Toalha? Para mim, nerd profissional, o Dia da Toalha deve ser um dia para se abraçar as toalhas de rosto ou banho ou outra babaquice assim. Nunca havia ouvido falar do tal "Guia do Mochileiro das Galáxias" antes. Adoraria ser um mochileiro, mas não vejo aonde isso se encaixa com "ser um nerd".

Bom, com os conceitos televisivos de hoje em dia e essa pirralhada EMO crescendo, vi na TV a "Mary Moon" se dizendo Nerd um dia. Pergunto-me o que ela sabe sobre ser nerd.

Para manter acesa a honra do NERD DE VERDADE, e para você testar se você é um NERD MESMO, ou se é apenas um POSER BABACA se dizendo nerd porque está na moda, vou colocar abaixo uma lista de coisas que quase todo nerd teria feito na vida:

1) ABRIR brinquedos durante a infância para ver como funcionam. Esta é clássica. Alguém que nunca tenha feito isso NUNCA será um Nerd.

2) Montar transmissores de rádio, TV, etc. Qualquer tipo de engenhoca bem inventiva ou copiada daquelas revistas de eletrônica ou similares(mecânica, ou qualquer outra coisa, também vale) substitui este item, mas ele é indispensável para um sujeito que se diz nerd.

3) Nerds não aceitam regras. Se você nunca criou métodos engenhosos para burlar alguma regra ou imposição física, psicológica, social ou mental, você NUNCA será um nerd.

4) Nerds de verdade já tentaram, ainda que tenham falhado, inventar objetos de vôo ou navegação automáticos(aviões, helicopteros, barcos ou similares movidos por baterias/pilhas e preferencialmente com controle remoto). Se você nunca tentou e tem mais de 16 anos, é tarde demais para tentar ser um nerd.

5) A maioria dos nerds conhece pelo menos um pouco de assembly. Ou alguma outra linguagem de programação. Mesmo que não sejam programadores. Se você não conhece, dificilmente é um nerd.

6) Se você não sabe porque o 256º dia do ano teria muito mais razões para ser o "Dia do Orgulho Nerd", ao invés do tal "Dia da Toalha" que os posers propagam por aí, você SEM DÚVIDA ALGUMA é um POSER BABACA e não um NERD.

7) Se você não gosta de ficar tentando entender o Universo durante horas e mais horas, ou de ficar filosofando sobre a sociedade - ou ainda pensando por horas e horas em problemas de física complexos(pelo menos para você) por puro prazer e pela vontade de entender o funcionamento das coisas, VOCÊ muito provavelmente NÃO É NERD.

Agora vejam a lista das coisas que muitos nerds gostam, mas que levam os POSERS BABACAS a crerem que são nerds apenas porque também gostam:
1) Star Wars - fãs do Darth Vader. OBS: Só significa ser nerd os enquadrados neste item que já tentaram fabricar um sabre de luz.
2) CSI/Cold Case/similares. Muitos nerds curtem seriados sobre investigação criminal. É o perfil do nerd de "tentar entender as coisas".
3) Computadores e Internet. Esse nem precisamos discutor.
4) Heavy Metal.
5) Piadas técnicas sobre sua área profissional ou de estudo.
6) Piadas complexas que a maioria das pessoas não entende.
7) Filmes e músicas que te deixam em constante pensamento.
8) Quebra-cabeças e jogos como o Cubo Mágico, por exemplo.
9) Xadrez.
10) Armadilhas para sacanear os amigos.

Então, leiam e tirem suas conclusões. Mas não me venham com modinha!

Classificação do conteúdo: SEMI-SÉRIO
Sobre mim: Curriculum Vitae Site Pessoal

umask, mistérios e lendas

noreply@blogger.com (Bruno Moreira Guedes) — Thu, 04 Jun 2009 21:56:00 +0000

Palavras-Chave: Linux

Pessoal, primeiramente peço perdão a Alah por não ter postado neste blog por muito tempo... Continuarei neste rítmo uma vez que a correria tá braba!!

Eu tava me preparando pra escrever isso há dias mas não sobrava tempo. O que ocorre é que existe um recurso nem tão freqüentemente utilizado em ambientes UNIX, chamado de umask. O umask nada mais é do que uma "mascara" utilizada para definir as permissões padrões de novos arquivos e diretórios. Mais ao fim eu explico o "espírito" da umask, mas por enquanto vamos contar um pouco da aventura.

No tempo que eu era um "gurizote", nem tão barrigudo quanto sou hoje, eu aprendi, com repetidores de lendas, que a tal da umask era um "número", que subtraído de 777 nos dava a permissão que ia ser utilizada para novos diretórios, e que subtraído de 666 nos dava a permissão que ia ser utilizada para novos arquivos.

Quando eu comprei alguns livros para estudo, como o "Certificação Linux", do Uirá Ribeiro(recomendo, propaganda grátis hehehe), que me confirmavam o que eu havia lido(e nunca havia testado tão a fundo). Nos exemplos que sempre são passados por estes repetidores de informação(me incluo neles) temos sempre a típica umask que coincide com o cálculo errôneo, e que é a umask padrão de todos os sistemas: a umask 022.

Na minha vida prática, só precisei utilizar outra umask, DURANTE MUITOS ANOS, quando trabalhei com SVN sobre SSH. O que acontecia neste caso é que os novos arquivos do repositório SVN precisavam ter permissão de escrita para o grupo também, senão nenhum outro usuário alteraria o conteúdo criado por outro no repositório. Para isso ser possível, alterei de 022 para 002 a umask do sistema. Com esta umask, também havia a dita coincidência com o "lendário cálculo"(os números '0' e '2' são 'mágicos' em certas operações matemáticas binárias).

Esses dias estava com uma turma de alunos, aonde, como muito ocorre com todo mundo, fui um repetidor de informações no que se refere à umask. Normalmente eu não falava dela em aulas, pois para mim aquilo parecia inútil até o recente episódio do SVN+SSH. Resolvi passar ela para o pessoal, que foi fazer uns testes e achou alguns casos que não batiam. Desde então, fui pesquisar e achei 50% das informações na internet falando da "lenda da subtração de umask". as outras 50% eram outras informações semelhantes que não batiam também. As man pages umask(2), open(2), creat(2) e mkdir(2) também não foram muito úteis na tarefa, pois não pareciam estar escritas de maneira clara.

Então, lá fui eu ler os fontes do kernel. No diretório 'fs' dos fontes nós encontramos a informação. Lendo os arquivos Procurando pelas funções das system calls(sys_mkdir, sys_open e sys_creat), achei o arquivo namei.c, aonde haviam 2 repetições de um trexo bem interessante do código:
if (!IS_POSIXACL(nd.dentry->d_inode))
mode &= ~current->fs->umask;

Então percebi que as man pages, apesar de pouco claras, estavam 100% certas. O cálculo da permissão se dá por uma operação AND(binária, bit a bit) entre o modo passado. Claro que para tudo há um porém.

Concluí em alguns testes que a umask só é aplicada quando os valores default são passados para as system calls que utilizam a umask(as system calls creat, open, mknod e mkdir, que criam nodos no sistema de arquivos, e os valores default são 777 para diretório e 666 para arquivo). Fica a promessa para mais adiante eu investigar aonde essa condição de verificação da umask é aplicada e mandar para todos a informação completa.

Como falei lá em cima, entendi o "espírito" da umask, que é basicamente você definir os bits que você quer que NÃO sejam ativados para arquivos e diretórios novos. Simples assim.

Para quem não é acostumado com matemática binária, segue a referência para entender as operações envolvidas na umask(AND e NOT):

Lembro a todos ainda que isso tudo depende muito de como os programas fazem a chamada, uma vez que se o programa requisitado passar na system call o modo diferente do padrão, a umask não será aplicada. Um caso aonde isso ocorre é quando passamos ao mkdir a flag '-m' indicando um modo diferente.

Fico devendo ainda uma explicação melhor sobre essa excessão, pois ainda não localizei aonde esse tratamento é feito. Estou analisando a libc também para encontrar o "caminho completo". Se alguém tiver uma sugestão ou resposta antes, comenta aí!!

OBS: Saindo em breve do forno um artigo sobre uso de NAT no user-space através das libs do netfilter. Esperem e verão!

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

PuTTY: Utilizando Chaves RSA e DSA no SSH

noreply@blogger.com (Bruno Moreira Guedes) — Mon, 10 Nov 2008 16:21:00 +0000

Palavras-Chave: SSH, PuTTY

Primeiramente peço desculpa aos inúmeros leitores(cerca de 2 ou 3 incluindo eu mesmo) deste blog por ficar alguns dias sem postar. As coisas andam um tanto corridas ultimamente.

Mas deixando o blá-blá-blá sobre o blog, agora vamos ao blá-blá-blá sobre o que vou escrever. Mas antes, para os apressados, informo que podem procurar pelo subtítulo "Finalmente..." logo abaixo para "meterem a mão na massa" logo. Muita gente, mas muita gente mesmo, durante minha vida profissional me fez essa bendita pergunta: eu uso Windows. Como posso acessar um servidor Linux via SSH estando no Windows??

Para esta pergunta, de início eu recomendava a utilização do OpenSSH para Windows(minha predileta, apesar de eu não utilizar o sistema do tiu Bill quase nunca). Os problemas que tiram a aceitação de muita gente à minha recomendação normalmente são algo como resolução ruim do prompt de comando do Windows(a Microsoft podia caprichar mais no cmd, não podia?), problemas com configuração de tipo de terminal, usuários que não querem iniciar o programa em linha de comando, entre muitos e muitos outros.

Tive mais sucesso quando passei a recomendar a eles o uso do PuTTY, que é mais "win-user friendly", gera menos transtornos para configuração de tipo de terminal/mapa de teclas, etc. Nosso amigo PuTTY só tem um pequeno problema: Incompatibilidade com chaves SSH2-RSA e SSH2-DSA geradas pelo utilitário ssh-keygen, do OpenSSH.

Estive fazendo algumas revisões de políticas de segurança em um cliente. Durante o processo, foi definida a adoção de chaves RSA para acesso via SSH. O problema logo apareceu: algumas pessoas acessam o servidor via PuTTY.

Sendo assim, vi que este velho problema precisava ser eliminado. Googlei por algum tempo e achei este link aqui(em inglês), que explica como proceder nesta situação. Abaixo estarei explicando em Português o procedimento e a idéia.

Finalmente...

Agora que já expliquei o contexto aonde utilizei, vamos para a parte que todos gostam. Eu prezumo que todos tenham conhecimento de como configurar o SSH no servidor e adicionar a chave na lista das chaves autorizadas para os usuários, então não vou entrar neste detalhe(fica para outro artigo).

Primeiramente, precisaremos de um software que pode ser obtido no site do PuTTY: o puttygen .exe. Este é o software que trabalha com as chaves em um formato próprio do PuTTY, diferente do formato SSH2.

O Primeiro Caminho

O primeiro modo para fazermos o PuTTY utilizar as chaves, é o mais simples: gerar a chave no próprio PuTTY. Para isso, abra o puttygen(faça o download apartir do link que eu coloquei acima).

Abaixo, selecione(em Parameters) a opção "SSH-2 RSA" ou "SSH-2 DSA", dependendo do algoritmo desejado. Não recomendo a opção "SSH-1", pois ela é para o protocolo versão 1 do SSH, que hoje está praticamente em desuso.

No campo de texto com rótuno "Number of bits in a generated key", você pode manter o valor 1024, ou aumentar(normalmente 1024bits é mais que o suficiente) para 2048 por exemplo(se o servidor contiver, por exemplo, fotos de uma bebedeira sua, tornando muito válido perder um pouco o desempenho para incrementar a este ponto a segurança).

Agora que está tudo parametrizado, clique em Generate. Segundo a mensagem da interface, a randomização da chave é de acordo com o movimento do mouse(que coisa não?)... Sendo assim, procure executar movimentos bem estranhos com o mouse nesta hora(é o que o software diz, não li os fontes para conferir).

Pronto... Após uma espera de cerca de 30 segundos, sua chave está "na mão", bastam algumas informações de como será salva a chave. Você pode definir um comentário(que sempre será visto no momento que o PuTTY envia a chave). E, você pode(e deve) definir um passphrase para a chave.

No campo "Key Passphrase", xingue sua sogra. No campo "Passphrase Confirm", xingue-a novamente(da mesma maneira). Ali valem espaços e caracteres especiais, então pode xingar a vontade.

Pronto, sua chave está gerada. Abaixo da barra de menus aparece um campo somente leitura, com a chave pública pronta para você adicionar no seu ~/.ssh/authorized_keys (ou outro arquivo de chaves autorizadas que esteja definido no /etc/ssh/sshd_config).

Você PODE salvar sua chave pública clicando no botão "Salve public key", e DEVE salvar sua chave privada através do botão "Save private key".

O Segundo Caminho

Este é para aqueles que já tem uma chave gerada no OpenSSH, e precisam utilizá-la no PuTTY. Somente para ilustrar, o procedimento básico para gerar uma chave no OpenSSH é a execução do comando:

$ ssh-keygen -f nome-do-arquivo -t rsa -b 1024

No exemplo foi usado RSA, de 1024bits, e o arquivo "nome-do-arquivo", mas estes parâmetros podem ser trocados. O comando de exemplo gera um arquivo chamado "nome-do-arquivo", contendo nossa chave privada, e outro chamado "nome-do-arquivo.pub", contendo a chave pública. A Passphrase será perguntada em um prompt.

Agora vamos importá-la para uso no PuTTY. Abra o PuTTYGen novamente, e clique no botão "Load". Selecione o arquivo, digite a senha(se houver). Se necessário, redefina o comentário e/ou o passphrase.

E, finalmente, salve sua chave. Agora na hora de usar o PuTTY, quando aparecer a tela de configurações dele, expanda na esquerda o item "Connection", e logo após o subitem "SSH". Clique no subitem "Auth".

Aparecerá um campo com o label "Private key file for authentication", com um botão "Browse..." ao lado. Clique no botão, procure a chave, e ela estará pronta para ser usada.

Espero que o artigo tenha sido útil!!

[]'s

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

OBhrama vence eleições, mas AAntartica ainda é a preferida

noreply@blogger.com (Bruno Moreira Guedes) — Wed, 05 Nov 2008 12:55:00 +0000

O candidado à presidência da república dos Estados Unidos da Almôndega, Barata OBhrama, se elege Presidente. No seu discurso após eleito, ele diz que irá mudar a américa.

O presidente tem diversos poderes capazes de mover as placas tectônicas, planejando utilizar estratégias de guerra melhores que as do antigo presidente, Jorge War Bucha. Ele diz que o primeiro lugar a ser invadido será a Russia, devido à proximidade e a tendência geografica. Devido a isso, anunciou que a américa irá mudar-se para acima da Azia, o que foi chamado de "movimento sal de frutas" pelos defensores de OBhrama.

Informou Bruno.

[]'s

Classificação do conteúdo: ~~DES~~CONFIAVEL
Sobre mim:
Curriculum Vitae
Site Pessoal

Desenvolvimento de Módulos Para o Kernel do Linux II

noreply@blogger.com (Bruno Moreira Guedes) — Tue, 28 Oct 2008 13:20:00 +0000

Palavras-chave: Linux, C, Kernel

Após o "incrível sucesso" do primeiro artigo, decidi transformá-lo em uma "série" de artigos, e este será o nosso segundo. Primeiramente gostaria de agradecer ao pessoal que me incentivou. Eu imaginava ter uns 100 acessos, mas o primeiro artigo teve aproximadamente 900 visualizações, fora o pessoal que comentou me incentivando.

Só prestando um esclarecimento, eu nem imaginava que este tema seria de tanto agrado do publico. Imaginei que isso fosse alvo de interesse apenas dos meus amigos mais nerds :-) Mas vou aproveitar que me interesso bastante pelo tema e vou procurar escrever com freqüência(ou nem tanta assim) sobre o tema, tudo dependerá de como andam as coisas para mim(fim da semana passada e esta agora estão corridinhas!!).

Agora chega de lero-lero e vamos ao que interessa: eu deixei muita coisa "em aberto" no primeiro artigo. Uma pessoa deixou(anonimamente) o comentário dizendo que faltava comentar o código. Bom, quando eu enviei aquele post eu estava com um pouco de pressa(como agora hehehe), mas agora vamos explicá-lo melhor!!

Primeiramente, um pouco do "geral" sobre as bibliotecas do kernel. Obviamente, um sistema operacional requer "rotinas diversas" para uso interno do próprio kernel. São rotinas básicas que usamos em diversos diferentes locais. Um destes exemplos é o printk(), que é um "analogo" ao printf() da libc.

Antes de mais nada, alguns podem ter a dúvida: e porque não utilizar as funções da libc mesmo, que são padronizadas com a linguagem, mais completas e de utilização mais fácil?? Bom, a resposta é simples: o kernel não faz a mínima idéia de que exista uma libc. Quando você está no kernel space só existe o kernel. Bibliotecas, para o ver do kernel, são meros arquivos em formato ELF, referenciados por outros meros arquivos também em formato ELF. A única coisa que o kernel sabe é executar system calls[1] nestes arquivos.

Estas bibliotecas são documentadas naquela API do kernel, cujo link coloquei no outro artigo. Retomando o foco do assunto, no post anterior eu não havia escrito muitos detalhes do código. Revirando meus links, encontrei o link do 'The Linux Kernel Module Programming Guide', que eu não me recordava, mas havia sido minha inspiração na escrita daquele código de exemplo. Todos os detalhes que menciono aqui são semelhantes aos do guia, que é uma das fontes deste artigo, juntamente com os fontes do kernel.

Primeiramente, na estrutura do código, temos nossos dois arquivos: errcon.h e errcon.c. Prezumo que todos que estejam lendo este arquivo conheçam razoavelmente os padrões que comumente são adotados para a divisão de códigos entre arquivos de cabeçalho(.h, com declarações) e arquivos de implementação(os .c ou .cpp no caso de C++). Caso não conheçam, recomendo "googlar" sobre o assunto

Em nosso header, primeiro incluimos alguns headers com declarações de símbolos que utilizaremos. Logo após, definimos algumas "macros úteis". São apenas para concentrar o valor de algumas coisas ali ao começo. Nesta época eu não era tão "avesso" ao uso de macros.

Depois temos nossaas variáveis globais e funções. Quero que atentem bastante às funções 'ec_dev*' e à estrutura 'opers', do tipo file_operations. Elas são as responsáveis pelo funcionamento da parte do arquivo de dispositivo(a entrada no /dev) que nosso módulo nos disponibiliza.

Como vocês podem notar, registramos em uma estrutura file_operations todas as operações relacionadas a arquivo que nosso módulo realiza. Mas neste módulo não utilizamos todas as possibilidades. Mesmo assim, quero que vocês conheçam a declaração da estrutura para verificar as operações disponíveis para manipulação:

struct file_operations {
 struct module *owner;
 loff_t (*llseek) (struct file *, loff_t, int);
 ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
 ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 int (*readdir) (struct file *, void *, filldir_t);
 unsigned int (*poll) (struct file *, struct poll_table_struct *);
 int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
 long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
 int (*mmap) (struct file *, struct vm_area_struct *);
 int (*open) (struct inode *, struct file *);
 int (*flush) (struct file *, fl_owner_t id);
 int (*release) (struct inode *, struct file *);
 int (*fsync) (struct file *, struct dentry *, int datasync);
 int (*aio_fsync) (struct kiocb *, int datasync);
 int (*fasync) (int, struct file *, int);
 int (*lock) (struct file *, int, struct file_lock *);
 ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
 ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
 unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
 int (*check_flags)(int);
 int (*dir_notify)(struct file *filp, unsigned long arg);
 int (*flock) (struct file *, int, struct file_lock *);
 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
};

Então, basicamente, registramos as funções que iriamos utilizar(ec_devopen, ec_devclose, ec_devread e ec_devwrite) nos ponteiros de função(open, close, read e write) da estrutura.

Agora, reparem também, ainda no noso arquivo de cabeçalho, que temos um ponteiro para uma declaração do tipo proc_dir_entry. Ela é uma "análoga", se é que podemos dizer isso, da estrutura file_operations. Mais adiante compreenderemos porque ela é declarada na forma de um ponteiro aqui em cima. Por enquanto, adianto apenas que as funções ec_procread e ec_procwrite serão associadas a ela, juntamente com algumas outras informações. Veja declaração da estrutura:

struct proc_dir_entry {
 unsigned int low_ino;
 unsigned short namelen;
 const char *name;
 mode_t mode;
 nlink_t nlink;
 uid_t uid;
 gid_t gid;
 loff_t size;
 const struct inode_operations *proc_iops;
 const struct file_operations *proc_fops;
 get_info_t *get_info;
 struct module *owner;
 struct proc_dir_entry *next, *parent, *subdir;
 void *data;
 read_proc_t *read_proc;
 write_proc_t *write_proc;
 atomic_t count;  /* use count */

 int deleted;  /* delete flag */
 void *set;
};

Repare que nesta estrutura temos diversos elementos além de ponteiros de funções, diferentemente da file_operations que tinha apenas ponteiros de função(exceto pelo owner, ponteiro que nem utilizamos manualmente).

Agora vamos finalmente ao nosso arquivo de implementação(errcon.c). A primeira coisa que vemos(após a inclusão do cabeçalho errcon.h) é implementação da função ec_devwrite. O que ela faz, basicamente, é implementar a operação write no dispositivo. Simplesmente lê o buffer de leitura(localizado no user-space, por isso lido com get_user e não diretamente) e o salva em nossa lista dos ultimos 4 erros.

Quanto ao local para onde os ponteiros de nosso array de ponteiro apontam, entenderemos mais tarde. De momento saiba apenas que é para um buffer de dados. Repare que como este módulo é apenas um teste, NENHUM TIPO DE PREVENÇÃO CONTRA BUFFER OVERFLOW FOI TOMADO. Para ocorrer um buffer overflow, basta escrevermos um número de bytes maior do que o tamanho do buffer. E, para este buffer overflow ser mais grave, basta que isso ocorra no ultimo dos 4 buffers, ou então que seja grande o suficiente para passar do fim do ultimo buffer no caso dos outros 3 buffers. Isso tudo se deve a grande preguiça que o autor tem de implementar um contador de caracteres(int i=buf_limit e buf_limit-- dentro do loop :-) hehehe).

Agora prosseguindo, temos nossa função ec_procread, que responde à operação read do arquivo de dispositivo. Ela basicamente escreve os dados do buffer do módulo(com a mensagem do ultimo erro recebido pelo módulo) no buffer do user-space(lá aonde o processo está fazendo a leitura. A "idéia" do put_user é a mesma do get_user, com diferença apenas operacional(um coloca no usuário e o outro pega do usuário, :-) entenda este comentário como quiser).

Agora vamos para a ec_open. Ela é responsável pela abertura do arquivo (citação de Dr. Obvio). Para evitar multiplos processos efetuando I/O no módulo, fazemos um "controle de abertura". No mais, a função também reseta o buffer de leitura. Como vocês viram, na ec_read nós apenas liamos apartir do buffer. Mas aí ficava no ar a pergunta: daonde vinha a posição correta do buffer?

É simples. Imagine que o processo não leia todos os dados de uma vez só. Suponhamos que nós tenhamos uma string de erro "hahehihohu". O tamanho de buffer utilizado pelo processo que lê o dispositivo é 2. Acompanhe a seqüência:

Processo efetua open() no dispositivo;
Processo lê 2 bytes;
Processo "trabalha" os 2 bytes lidos;
Processo lê mais 2 bytes;
Processo "trabalha" mais 2 bytes lidos;
Processo lê mais 2 bytes;
...

A posição do buffer deve ser trabalhada na função da operação read, incrementando os bytes que são enviados para o user-space. Também devemos apontar, na primeira chamada à read, para o início do buffer. Mas como vamos saber quando é a primeira chamada?? Simples: na chamada da operação open realizada no arquivo, nós setamos o ponteiro para NULL, e verificamos se ele é nulo no momento da operação read.

Só para constar, vejamos a linha aonde fazemos a chamada:

try_module_get(THIS_MODULE);

Nesta chamada simplesmente incrementamos o contador de uso do módulo, gerenciado pelo kernel. Não confunda com nosso contador interno(ec_openc), que é para uso dentro do módulo. Ao executarmos um comando lsmod no shell, veremos uma tela similar a esta:

bruno@bw1:~$ lsmod
Module Size Used by
parport_pc 27812 0
parport 34760 1 parport_pc
yenta_socket 27148 1

Repare no terceiro campo(Used By), aonde vemos um número, algumas vezes seguido de uma lista de módulos. Este número é o contador de usos. Os módulos listados são outros módulos que utilizam recurso do listado. Isso significa que o try_module_get não serve apenas para indicar quantas vezes o arquivo de dispositivo foi aberto, mas para n outras coisas.

A função ec_devclose dispensa comentários. Apenas esclareço que o try_module_put decrementa o contador de uso do módulo. Na função ec_procread, simplesmente escrevemos no buffer uma mensagem formatada, dizendo o número de erros e o ultimo erro que foram registrados. Na ec_procwrite, utilizamos a função copy_from_user para ler 1 caractere do buffer recebido. Caso este caractere lido seja 'c', é efetuado um loop percorrendo o buffer de mensagens de erro e apagando seus dados.

Bom, agora que todos já entenderam "cada pedaço" da coisa, vamos ao "ponto de junção", aonde a gente "junta toda essa cosia e faz virar uma só". É o nosso "main 1", o init_module. Como eu já havia citado anteriormente, este "cara" é o responsável por disponibilizar aquilo que o módulo fornece, e inicializar o "serviço" do módulo.

A primeira coisa que ele faz é preparar os nossos buffers. Como você pode ver no código, de acordo com minha explicação sobre ponteiros, criamos um array global, de 16386 bytes(de acordo com a macro EC_PROCFILE_BUFF_SIZE) apontado por ec_errors, ainda no nosso header(errcon.h). Agora nós dividimos a área apontada por ec_errors em 4 partes, cada uma com seu início apontado por um dos ponteiros do array de ponteiros apontado por ec_error(esta frase é meio confusa, mas tente reler umas 2 vezes, ou se tiver raciocínio visual e precisar, não tenha vergonha de desenhar num papel ao longo da leitura para entender a frase - e se ainda não entender, recomendo ler novamente a explicação sobre ponteiros). Observe que temos 2 poréms nesta história: o primeiro é que ao longo do programa não utilizamos nenhuma mensagem além da ultima. Isso foi uma falha minha, pois na época eu não tinha noção alguma do que significava "requisito de software".

O segundo porém, é um pequeno errinho meu. Se vocês acompanharem o loop aonde é feita essa divisão da área, vocês vão ver que todos os 4 ponteiros apontam para a mesma área, que seria "a segunda posição" das 4 na qual dividimos. Apartir de agora, quando vocês olharem o código ele estará atualizado, e o valor:

(EC_PROCFILE_BUF_SIZE / 4)

será multiplicado por i.

Após dividirmos o nosso array em 4 buffers "distintos", criamos nossa entrada no sistema de arquivos proc. Fazemos um tratamento de erro, e caso ocorra realmente algo errado, nós efetuamos a tentativa de remoção da entrada recém criada(ou não criada, não temos como ter certeza, removemos para evitar uma entrada desagradável e permanente no /proc).

Logo depois, criamos nossa entrada no /dev. Só para constar, caso o retorno do register_chrdev seja negativo(erro) em vez do major, temos certeza de que o device não foi criado(diferentemente da entrada no /proc). E, então, removemos a entrada.

Em ambos os tratamentos de erro, retornamos negativo. Ou seja: indicamos pro kernel que ocorreram erros e ele deve cancelar o carregamento do módulo. O kernel, por sua vez, informa o modutils disso, e este por sua vez joga uma mensagem de erro para o usuário. É vital fazermos isso para evitar problemas!

Observem a diferença entre as abordagens da criação do arquivo de dispositivo e da criação da entrada no /proc. No primeiro caso, criamos a estrutura com as informações das operações de arquivo, e depois chamamos a função responsável "registrando" esta estrutura. No segundo, criamos apenas um ponteiro e utilizamos uma função que retorna a área da estrutura. Nesta função, passamos apenas o nome do arquivo a ser criado.

Uma vez registradas, estas estruturas podem ser modificadas a qualquer momento. É o que fazemos com a estrutura do nosso arquivo no /proc. Ao remover, passamos como parâmetro o endereço de proc_root. A entrada proc_root nada mais é do que outra estrutura proc_dir_entry, que representa a raiz do /proc.

Veja que depois nós modificamos nossa entrada no /proc acessando diretamente a estrutura. Logo após isso, o restante do código é apenas complementar: imprimimos com printk as mensagens informando alguns detalhes do módulo.

Retornamos 0(o valor de SUCCESS) para indicar sucesso na operação. Valores negativos indicam erro e cancelam o carregamento do módulo.

Quase no fim, temos nosso cleanup_module. Basicamente, ele desregistra nosso dispositivo de caractere, e remove nossa entrada do /proc.

Ao fim do código, utilizamos algumas macros para registrar algumas informações sobre o módulo: sua licensa, seu autor, o nome de seu dispositivo, e sua descrição. Você pode visualizar suas informações com o comando:

$ modinfo errcon.ko

Finalmente, peço desculpas pela demora a postar algo novo. É que esta semana está corrida!! Espero que gostem, em breve mais conteúdo sobre o kernel!!

OBS: se alguém quiser que eu escreva sobre algum tema específico, e estiver ao meu alcance, é só dizer que se tiver no meu domínio e se encaixar no meu "time" eu escrevo.

Agradeço a atenção de todos os meus leitores. Caso não saibam, tem um milhão lendo agora esse blog. E em seguida esse milhão vai ser cozido :P

[1] System Calls, ou chamadas de sistema, são "funções" disponibilizadas pelo sistema operacional aos aplicativos. Geralmente bem básicas. Vide man page for syscalls(2)

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

DICA: Eliminando Warnings de Seus Programas

noreply@blogger.com (Bruno Moreira Guedes) — Sat, 25 Oct 2008 12:01:00 +0000

Palavras-chave: C/C++, GCC, Dicas

Constatei vendo meus diversos amigos(colegas e ex-colegas de trabalho, colegas de faculdade, conhecidos diversos) programando: a esmagadora maioria dos programadores IGNORA os warnings do compilador.

As razões disso parecem ter duas origens. A primeira delas é a 'omissão', aquela idéia de "ahh, compilou, não dá nada". Neste caso, o indivíduo deveria se auto considerar desleixado, e dependendo do que ele estiver desenvolvendo, irresponsável. Quando falamos de C ou C++, aonde lidamos com mais elementos de "não tão alto nível assim" - como ponteiros e assembly inline, essa omissão se torna mais grave ainda.

Agora todos que leram até aqui, se ainda não eram concientes agora são(eu espero). Sendo assim, vamos para a segunda causa. Você está na correria. Seu programa gerou alguns warnings. Apenas por mal costume(e todos nós temos), você 'deixa para depois' corrigir aquele warning. Aí o dia que você vai corrigir os warnins deixados para depois, você se surpreende: apenas 800 warnings para corrigir. Nada que 3 meses de trabalho não resolvam, pouquinha coisa!!

E lá vai o dito programador corrigindo warning por warning, e contando eles novamente... 800... 799... 798... ... ... 0. Terminou, warnings zerados. Aí você pensa: agora eu não deixo mais para depois. Aí o primeiro momento de "correria com prazos" você deixa 1 pra depois. E ainda diz para sí mesmo: é só 1, os outros não vou deixar.

Nós, seres humanos, insistimos nessas coisas. Mas é fato, não adianta você dizer para sí mesmo que vai deixar só aquele para depois. Sempre aparecem outras excessões.

Sendo assim, aqui vai uma dica para quem utiliza o GCC. Se não funciona por nossa própria consciência, então o compilador que nos obrigue!! Existem diversos parâmetros do compilador relacionados a Warnings, mas eu só vou falar de dois.

O primeiro é o -Wall, que manda o compilador registrar e exibir todos os warnings. O segundo é o -Werror, que faz com que warnings sejam tratados como erros. Com esses dois parâmetros juntos você não tem escapatória: terá que corrigir seu warning, ou o programa não compila. Veja a linha de comando de exemplo:

$ gcc -Wall -Werror -o binario source.cpp

Pronto. Assim seu código é mais confiável, e você não paga nada a mais por isso. Espero que todos gostem deste artigo!!

[]'s

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Teste Nerd

noreply@blogger.com (Bruno Moreira Guedes) — Fri, 24 Oct 2008 11:41:00 +0000

Olá povo!!

Raras pessoas já disseram me achar nerd durante toda a minha vida... Mesmo assim, aí vai a prova de que eu não sou nerd:

Agora desafio meus amigos a fazerem(em especial o Samuca, que eu sei que terá 100% de score)

Classificação do conteúdo: INÚTIL
Sobre mim:
Curriculum Vitae
Site Pessoal

DICA: Instalando Programas Em Servidores Web Sem Ter Senha de Root

noreply@blogger.com (Bruno Moreira Guedes) — Thu, 23 Oct 2008 18:56:00 +0000

Palavras-chave: Linux, CGI, Edição de Binários

Fica a dica para quem tiver alguma necessidade parecida...

Comecei a escrever um CGI, bem simplesinho, em Bash[1]. Ele é muito simples(outra hora eu posto ele pra vocês), e rodava, entre outras coisas, o executável do enscript. Só tinha um pequeno porém: eu precisava saber se o servidor web do meu webhost tinha o enscript. E lá vou eu, com o seguinte teste:


#!/bin/sh

echo -e "Content-type: text/html\r\n"

if [ ! -f sample.cpp ]; then
 echo "
#include <iostream>

using namespace std;

int main()
{
  cout << \"Ola Mundo\" << endl;
  exit(0);
  return 0;
}
" > sample.cpp
fi

if [ ! -f sample.cpp.htm ]; then
 echo "Enscript..."
enscript --color --language=html -Ecpp -o sample.cpp.htm sample.cpp
fi

cat sample.cpp.htm

Enfim... Descobri que não tinha o dito cara instalado!! E agora?? Bom, vamos usar um pouco do nosso "censo de improviso"!! O sistema do servidor tem tudo para ser um RH Enterprise ou semelhante(eu supus). Infelizmente eu não tenho acesso ao shell via SSH.

Utilizei uma máquina com o CentOS e peguei o binário. Executei um ldd nele, e só tinha a libc linkada. Aí muito feliz, joguei ele no diretório cgi-bin do meu servidor web. Mudei o script, para executar "./enscript" em vez de "enscript"(executar do diretório local). Tentei rodar meu CGI e nada.

Estava 1 x 0 para meu servidor web, mas eu não me entrego. Coloquei no meu CGI uma mensagem com a saída de erros(adicionei um 2>&1 no final da linha de comando). E lá estava a mensagem: "/usr/share/enscript/enscript.cfg: no such file or directory". E então eu me lembrei: bah, lembrei do binário mas não lembrei dos arquivos de configuração e outros que ele possa ler!

Eis então o cenário: eu não tenho permissão de escrita no /usr/share. O binário do enscript depende desse diretório 'enscript' que está lá. Logo, eu não poderei rodar o enscript lá!

Mentira!! Como eu não me entrego nunca, acessei minha máquina virtual com o CentOS novamente. Análisei o binário com o comando 'strings'. Ele tem uma string com o diretório e uma com o nome do arquivo. Então, meu diretório no servidor é '/home/bruno', e o diretório daonde ele lê atualmente é '/usr/share/enscript'. Então lá vou eu:

$ cat /usr/bin/enscript | sed 's/\/usr\/share\/enscript/\/home\/bruno\/nscript/g' > enscript.new

Então tinhamos um 'novo enscript'. Antes que perguntem porque mudei o caminho para '/home/bruno/nscript' e não para '/home/bruno/enscript', eu já aviso: conte os caracteres e entenderás!!

Ok, as coisas estavam se encaminhando. Antes de criar o diretório 'nscript' no meu diretório home, eu resolvi fazer um teste. Ainda na máquina com o Centos, criei o diretório no meu home dali, e rodei um strace:

chmod 755 enscript.new
strace ./enscript.new --color --language=html -Ecpp -o sample.cpp.htm sample.cpp 2>strace.out
grep 'open(' strace.out

E então a surpresa: ele ainda estava executando 'opens' no diretório /usr/share/enscript. E mais, ele na verdade lia o enscript.cfg do /etc, e não do /usr/share/enscript. E agora?? 2 x 0 pro servidor web!!

Mas eu não desisto. Supus que ele tivesse uma lista de caminhos para procurar o enscript.cfg. Removi ele experimentalmente do /etc e confirmei minha suspeita: ele deu a mesma mensagem que no servidor web. Então foi simples, criei ele em '/home/bruno/nscript'. 2 x 1 pro webserver, nessa eu fui melhor. Mas ainda havia o outro problema que tinhamos detectado: ele lia alguns arquivos do antigo caminho. E agora?? Havia um fantasma do binário antigo nele??

Dando uma "fuçada" percebi que era do arquivo de configuração que ele tirava aquele caminho. Finalmente, coloquei no servidor web os arquivos de configuração com o caminho novo, e executei denovo o CGI: mais problemas!! Agora ele não achava um executável chamado 'states'.

Primeiro rodei um 'strings' denovo no 'enscript', e filtrei 'states' na saída. Nada foi encontrado. Mas como assim?? Suspeitei direto do arquivo de configuração, e "BINGO!!". Estava definido lá o caminho do states. Aí, para minha sorte, o 'states' só dependia da libc também. Lá vamos nós, rodando um strace, agora com -f, no enscript. O -f segue forks, fazendo o trace dos processos filho também, e não apenas do processo principal.

Ao confirmar que ele não lia arquivo algum, postei na hora o executável, atualizei o parâmetro do caminho dele no arquivo de configuração do enscript, e fui lá testar. Funcionou.

Quem nunca fez uma gambiarra?? Chuck Norris deve estar morrendo de inveja de mim agora!!

[1] Para os que não são do "mundo Unix", Bash é um shell. Eu escrevi um Shell Script, semelhante aos '.bat' do DOS, porém com muito mais flexibilidade e utilidade. Sim, Shell Script também pode ser usado como CGI!

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Desenvolvimento de Módulos Para o Kernel do Linux

noreply@blogger.com (Bruno Moreira Guedes) — Thu, 23 Oct 2008 12:30:00 +0000

Palavras-chave: Linux, C, Kernel

Introdução

A pedido de muitos fãs e leitores deste blog(muitos fãs e leitores = 2 pessoas, o Havacci e o Filipe), vou escrever um pouco sobre desenvolvimento de módulos para o Kernel do Linux aqui.

Neste primeiro artigo(se eu for escrever tudo num artigo só eu morro escrevendo) eu vou apenas começar a introduzir o assunto. Pretendo mostrar pro pessoal que não tem segredo nem macumba nisso, e o caminho para o pessoal começar esta "jornada ao centro do Linux". Futuramente colocarei diversos outros conteúdos.

Primeiramente vou responder a pergunta que certamente alguns farão: o que é possível desenvolver como módulo do kernel?? Pra que servem eles?? Vejamos uma lista das principais respostas a essas perguntas:

Device Drivers(o primeiro que vem na mente de todos);
Extensões aos diversos frameworks e subsystemas do kernel;
Desenvolvimento de novos modelos de segurança;

Falando de maneira introdutória, o Linux é um sistema operacional com um Kernel Monolítico, totalmente modularizado[1]. Um ambiente com Linux pode ser dividido em duas partes isoladas, ligadas por meio de alguns artifícios: o espaço do kernel(kernel space) e o espaço do usuário(user space).

A ligação entre as duas partes ocorre principalmente através de system calls. Outros instrumentos que fazem esta ligação são o sistema de arquivos virtual /proc, o sistema de arquivos virtual /sys, e os arquivos de devices(no /dev).

Não vou entrar em detalhes sobre os utilitários de módulo do kernel, ou mais conceitos de módulo. Para maiores informações leia neste link sobre o conceito de módulo e como utilizá-los.

Agora, a próxima sessão vai falar um pouco mais dos módulos mesmo, além de começar a comprovar que módulos para o kernel são códigos triviais como quaisquer outros, e não há nada que necessite ser um gênio da computação para que possa ser desenvolvido.

Estrutura Básica de Um Módulo

Quando carregamos um módulo com insmod(ou modprobe), ele é inserido numa região de memória reservada para o kernel space. Logo quando descarregado, com rmmod, as referências a esta região de memória e seus conteúdos são retiradas. Mas isso você provavelmente já viu ou pode ver em mais detalhes no link que eu coloquei ali em cima.

Podemos dizer de maneira simples que um módulo é apenas um "programa"(não como os do user-space, mas computacionalmente falando não deixa de ser um programa, ou seja, um conjunto de instruções do processador) que possui um código a ser executado quando este é carregado, e outro a ser executado quando este é descarregado. De maneira bem "grosseira", para quem é acostumado com o user-space, podemos dizer que o módulo tem "dois mains": o de inicialização e o de finalização.

Normalmente, a idéia é que o primeiro deles, o init_module(), seja responsável pelo carregamento das estruturas de dados do módulo, bem como o registro de suas funcionalidades perante o kernel. Em outras palavras, você carrega o modulo e ele informa ao kernel o que ele faz e quando ele faz, para que o kernel passe a ele "a parte dele do serviço".

O "segundo main", cleanup_modules(), é a parte do modulo responsável pela sua descarga. Ela simplesmente "desfaz" o que o init_module() fez, desregistrando suas estruturas e desalocando eventuais regiões alocadas de memória.

Finalmente o Desenvolvimento dos Módulos

Primeiramente é importante saber algumas coisas antes da "aventura" começar. A mais obvia dela é que durante os testes com os módulos que você estiver escrevendo, caso haja algo de errado nos módulos, sua máquina pode ficar instável ou até travar(experimente criar um módulo que tenha um loop infinito dentro dele pra você ver o que acontece com o sistema).

Ao contrário de programas convencionais, o módulo do kernel não está e nem pode estar linkado a biblioteca nenhuma, de forma que você não poderá fazer uso nem mesmo da libc. As suas únicas bibliotecas são os frameworks do kernel.

Todo módulo do kernel deve ser desenvolvido em C. Até é possível desenvolver módulos em C++, Objective-C, Assembly, ou, inclusive, outras linguagens. Mas, infelizmente, a estrutura do kernel não foi feita para isso. Além de dar muito mais trabalho, pois desde a compilação e a linkedição, você já terá que criar suas próprias rotinas de compilação, ao invés de simplesmente reutilizar as existentes. Além do mais, os recursos do C++, por exemplo, são todos na sua maioria recursos de biblioteca. Você perderia já de cara a STL e o tratamento de excessões. Além disso, você teria que lidar com programação estruturada, pois as estruturas do kernel são estruturas estruturadas. E lá se vão as vantagens de se programar em C++ para o kernel, só restando o trabalho árduo para insistir nisso.

O uso da API do kernel é o único recurso com o qual trabalhamos nos módulos. Sendo assim, este link aponta para uma página contendo documentação de parte da API do kernel. Recomendo dar uma atenção aos capítulos 1 e 3 inicialmente. Lá temos, respectivamente, funções básicas do kernel e algumas funções de interface igual ou semelhante às principais da libc. Já o capítulo 2 fala de algumas estruturas de dados que são implementadas pelo kernel para serem utilizadas por módulos. Elas podem ser importantes em determinadas situações, de acordo com a necessidade do desenvolvedor(atualmente esta frase estaria no singular, pois só temos listas duplamente encadeadas lá).

No capítulo 5, temos a descrição dos recursos de gerenciamento de memória. Lembre-se, o gerenciamento de memória não serve apenas para a alocação dinâmica(kmalloc e kfree), mas também para acesso a buffers de memória do user-space, que se fazem necessários para trocar dados com este. Nos capítulos 9, 10 e 11, temos a manipulação dos principais sistemas de arquivos virtuais do kernel(procfs, sysfs e debugfs respectivamente).

Nos capítulos 23 e 24, temos respectivamente a parte de utilização de dispositivos de bloco e de caractere.

Eu espero ter explicado pelo menos por cima o que era o que, e o que serve pra que. Recomendo a quem não está familiarizado com o que eu falei, ler este artigo que fala um pouco sobre configuração e compilação do kernel. Ele está um tanto até desatualizado, mas serve como ponto de partida.

Como defendo muito a idéia do "aprenda com exemplos", não teria nada melhor do que um exemplo para mim colocar aqui. E como exemplo, utilizarei um código que eu mesmo desenvolvi para testes, como uma espécie de "brincadeira". Falando bem a verdade, não tenho vergonha de dizer que meu conhecimento acerca do desenvolvimento do kernel não passa de conhecimento teórico. Ainda não cheguei a precisar utilizar este conhecimento na minha vida profissional. Mas, mesmo assim, acho que ele é um complemento que faria falta para meu conhecimento de como o sistema operacional funciona.

O meu "brinquedo" é apenas uma espécie de "console de erros". Daí seu nome, 'errcon'. Ele simplesmente cria um dispositivo de caractere de major 254 e minor 0, no qual seriam escritas mensagens de erro. Na leitura do arquivo, ele mostra o ultimo erro. Sendo assim, vamos aos arquivos do meu "brinquedo".

errcon.h - o header:


/********************************************************************
* Parte responsavel pela leitura do erro...                         *  
* Autor: Bruno Moreira Guedes <bruno@bruno.inf.br>                  *
* Aproveitando o momento para atualizar o e-mail..                  *
* Atualizado em 2007-07-06, Criado em algum dia qualquer de 2006... *
*********************************************************************/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>

#include <asm/uaccess.h>

#define EC_PROCFILE_BUF_SIZE 16386
#define EC_PROCFILE_NAME "errorconsole"

#define EC_MODULE_AUTHOR "Bruno Moreira Guedes <bruno@bruno.inf.br"
#define EC_MODULE_LICENSE "GPL"
#define EC_MODULE_VERSION "0.1.0"

#define EC_DEVICE_NAME "error"

#define SUCCESS 0

static const char ec_lf = '\n'; /* Line-feed necessario para limitar   *
          *  a mensagem de erro a uma linha...  */

char *perr;
char **p;

unsigned long long int ec_error_ct = 0; /*Contagem de erros registrados... */

static int ec_openc = 0; /* Processos lendo device(nunca passara de 1)... */

char ec_errors[EC_PROCFILE_BUF_SIZE];  /* Ponteiro para a sequencia de
    * ponteiros
                                      * para strings aonde os erros estão
                                      * armazenados...*/

char *ec_error[4];


static struct proc_dir_entry *ec_procfile;


static ssize_t ec_devwrite (struct file *f,
      const char __user *buf,
      size_t len,
      loff_t *offset);


static ssize_t ec_devread (struct file *f,
     const char __user *buf,
     size_t len,
     loff_t *offset);

static int ec_devopen(struct inode *i,
       struct file *f);


static int ec_devclose(struct inode *i,
        struct file *f);

static struct file_operations opers = {
.read = ec_devread,
.write = ec_devwrite,
.release = ec_devclose,
.open = ec_devopen
};


int ec_major;

int ec_procread(char *buf,
 char **where_buf,
 off_t offset,
 int buflen,
 int *eof,
 void *dt);


int ec_procwrite(struct file *f,
  const char *buf,
  unsigned long cnt,
  void *dt);


int init_module(void);
void cleanup_module(void);

errcon.c: a implementação


/********************************************************************
* Parte responsavel pela leitura do erro...                         *  
* Autor: Bruno Moreira Guedes <bruno@bruno.inf.br>                  *
* Atualizado em 2008-10-22, Criado em algum dia qualquer de 2005... *
* Agora tambem disponivel no blog http://brunildz.blogspot.com      *
*                                                                   *
* CHANGELOG:                                                        *
* 2008-10-22 Bruno Moreira Guedes:                                  *
*  -Correcao de violacao de const                                   *
*  -Dado um aspecto "decente" para a sintaxe                        *
*********************************************************************/

#include "errcon.h"

static ssize_t ec_devwrite (struct file *f,
      const char __user *buf,
      size_t len,
      loff_t *offset)
{
char *ps = NULL; //Ponteiro para string

        char *pb = NULL; //Ponteiro para o buffer...
 unsigned int i;

ps = ec_error[ec_error_ct % 4];
pb = buf;

for (i = 0; i < len && i < (EC_PROCFILE_BUF_SIZE / 4) -1; i++) {
 /* Percorre os buffers copiando um para o outro,
  * obtendo os buffer de origem do user space
  */

 get_user(*ps, pb++);

 if (*ps == 0 || *ps++ == ec_lf) {
  break;
  }
        }

*ps = 0; //Adiciona fim da string...
 ec_error_ct++;

return i+1;
}

static ssize_t ec_devread (struct file *f,
     const char __user *buf,
     size_t len,
     loff_t *offset)
{
int read = 0;
      char *tm_buf = buf;

if (!p) {
 /* Se a leitura nao tiver iniciado previamente... */

 p = ec_error;
 perr = *p;
 }

if (!*perr) {
 return 0; /* Indica o EOF quando terminar de mostrar os *
            * buffers...                                 */
 }

while(p - ec_error < 4 && len && *perr) {

 while (*perr && len) {
  put_user(*perr++, tm_buf++);
  len--;
  read++;
  }

 p++;
}

return read;
}


static int ec_devopen(struct inode *i,
       struct file *f)
{

if (ec_openc) {
 return -EBUSY; /*Evita que device seja escrito por dois
   *processos ao mesmo tempo. Isto terá que
   *ser futuramente aperfeicoado, de modo que
   *somente retorne o erro quando o device for
   *aberto para escrita.*/

 }

ec_openc++;
p = NULL; //Reseta os ponteiros...

try_module_get(THIS_MODULE);

return SUCCESS;
}

static int ec_devclose(struct inode *i,
        struct file *f)
{
ec_openc--; //Pronto, o dispositivo ja pode ser usado...

 module_put(THIS_MODULE); //E o modulo descarregado!
 return SUCCESS;
}

int ec_procread(char *buf,
 char **where_buf,
 off_t offset,
 int buflen,
 int *eof,
 void *dt)
{
return sprintf(buf, "Registered Errors: %llu\nLast Error: %s\n",
        ec_error_ct, ec_error[(ec_error_ct - 1) % 4]);
}


int ec_procwrite (struct file *f,
   const char *buf,
   unsigned long cnt,
   void *dt)
{
char opt;
char *pe = NULL;

if (copy_from_user(&opt, buf, 1)) {
 return -EFAULT;
 }

if (opt == 'c') {
 /* escrevendo 'c' no arquivo proc apagamos os erros*/

 pe = ec_errors;

 while (pe - ec_errors < EC_PROCFILE_BUF_SIZE) {
  *pe++ = 0;
  }

 ec_error_ct = 0;
 }

return 1;
}

int init_module(void)
{
int i;

for (i = 0; i < 4; i++) {
 ec_error[i] = ec_errors + (EC_PROCFILE_BUF_SIZE / 4);
 }

ec_procfile = create_proc_entry(EC_PROCFILE_NAME, 0644, NULL);

if (ec_procfile == NULL){
 /* Algo deu errado, arquivo nao criado... */

 remove_proc_entry(EC_PROCFILE_NAME, &proc_root); /* Remove */

 printk(KERN_ALERT "FATAL: Error creating /proc/errorconsole\n");

 return -ENOMEM;
 }

ec_major = register_chrdev(0, EC_DEVICE_NAME, &opers);

if (ec_major < 0) {
 printk(KERN_ALERT "FATAL: Registering device failed\n");
 remove_proc_entry(EC_PROCFILE_NAME, &proc_root); /* Remove... */

 return ec_major;
 }

ec_procfile->read_proc = ec_procread;
ec_procfile->owner = THIS_MODULE;
ec_procfile->mode = S_IFREG | S_IRUGO;
ec_procfile->uid = 0;
ec_procfile->gid = 0;

printk(KERN_ALERT "errcon: Starting Error Console\n");
printk(KERN_ALERT "errcon: Device Major: %d\n",ec_major);
printk(KERN_ALERT "errcon: Device Minor: 0\n");
printk(KERN_ALERT "errcon: Proc File: %s\n", EC_PROCFILE_NAME);

return SUCCESS;
}


void cleanup_module (void) {
int ret = unregister_chrdev(ec_major, EC_DEVICE_NAME);

if (ret < 0) {
 printk(KERN_ALERT "FATAL: Error unregistering device\n");
 }

remove_proc_entry(EC_PROCFILE_NAME, &proc_root);
}


MODULE_LICENSE(EC_MODULE_LICENSE);
MODULE_AUTHOR(EC_MODULE_AUTHOR);
MODULE_SUPPORTED_DEVICE(EC_DEVICE_NAME);
MODULE_DESCRIPTION("Error Console Device and Statistics");

Makefile - rotinas de compilação


###############################################################################
# Criado: Na epoca do errcon.c                                                #
# Autor:  Bruno Moreira Guedes                                                #
# Changelog:                                                                  #

#                                                                             #
# 2008-10-22 Bruno Moreira Guedes:                                            #
#  -Adicao de targeta htmlcode, para gerar HTML dos arquivos                  #
###############################################################################

obj-m += errcon.o

ENSCRIPT = /usr/bin/enscript
ENSCRIPT_FLAGS = -i 3 --color --language=html
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean


htmlcode:
$(ENSCRIPT) $(ENSCRIPT_FLAGS) -Ec -o errcon.h.html errcon.h
$(ENSCRIPT) $(ENSCRIPT_FLAGS) -Ec -o errcon.c.html errcon.c
$(ENSCRIPT) $(ENSCRIPT_FLAGS) -Emakefile -o Makefile.html Makefile

Bom, agora acho que todos já tem diversão por um bom tempo!! Qualquer dúvida postem aí... É um assunto complexo, não sei se expliquei bem... Mas não se acanhem gente!!

Confiram também o Próximo Artigo da Série

[1] Modularizado ou não, você também pode compilar ele sem suporte a modulos, mas isso normalmente acontece apenas em sistemas embarcados, pois costuma ser desvantajoso em grande parte dos casos

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Google Abre os Fontes do Android

noreply@blogger.com (Bruno Moreira Guedes) — Wed, 22 Oct 2008 22:44:00 +0000

Palavras-chave: sdk, ferramentas de desenvolvimento, open source

Eu não tenho muito o objetivo de focar em notícias aqui no meu blog, mas algumas das notícias que mais causam impacto no "mundo virtual" não podem ficar sempre de fora.

Para os que não conhecem, o Androide é um SDK(Software Development Kit) de desenvolvimento para celulares, criada pelo Google. A novidade é que o Google ~~finalmente~~ abriu o jogo: liberou os fontes do SDK para a comunidade.

Os fontes já estão disponíveis no repositório git do Google. Veja a notícia original: Google Open Sources Android.

[]'s

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Prioridade de Processos

noreply@blogger.com (Bruno Moreira Guedes) — Tue, 21 Oct 2008 06:07:00 +0000

Palavras-chave: Linux, UNIX, Sistemas Operacionais, Processos

Escalonamento de processos é um assunto que muitas pessoas desconhecem. Um administrador de sistemas normalmente não precisa ser um "expert" no assunto. Porém, existe uma parte deste assunto que todos precisam conhecer: o tratamento de prioridades.

Este é mais um modelo computacional que segue alguma coisa aplicada pela humanidade em outras áreas. O conceito, não computacionalmente falando, é extremamente simples: algumas coisas são necessárias agora, outras podem ser deixadas para depois.

Um exemplo, é que algumas pessoas dão prioridade para comprar a casa em vez de comprar um carro. Algumas dão prioridade para o trabalho e não para a família. Na computação o mesmo ocorre: temos um número fixo de processadores no hardware, e possuimos um número de processos rodando bem maior que este número de processadores.

Os sistemas operacionais, em especial o Linux, possuem um scheduler responsável por gerenciar uma fila de processos e definir quem está na vez. O scheduler é extremamente complexo e utiliza uma série de fatores para definir "quem está na vez" entre os processos em execução no sistema. Mas a parte que nos interessa mesmo é a parte que está ao nosso alcance controlar: o nice.

Basicamente, um processo possui uma escala de nice de -20 até 19 atribuida a ele, indicando o quão "legal"(nice) ele é. Neste post, utilizaremos o termo "gentil" para falar disso. Podemos dizer que os processos com nice de 19 são caras extremamente "gentís". Já os processos de nice 0 não são "gentís". Os de nice negativo, por sua vez, acho que nem precisa entrar em detalhes: são os processos do tipo "sai da frente".

O funcionamento basicamente é que quanto mais gentil o processo for, mais ele espera os outros "passarem" pelo processador antes dele. Fazendo uma analogia ao trânsito, por exemplo, imagine que tenhamos basicamente 3 tipos de motorista: os normais, os apressados e os lerdos. Se em uma rotatória um motorista normal cruzar com um apressado, o apressado irá tentar "burlar a vez" do normal. O normal, por sua vez, vai pensar "vixi, que cara apressado, tá bom, passa logo".

Agora, se o normal cruzar com o lerdo, o lerdo irá deixar o normal passar. Quando dois normais se cruzam, eles simplesmente seguem a regra, que no caso do trânsito: quem veio primeiro passa. O mesmo acontece com dois lerdos e com dois apressados(a não ser que eles se choquem).

Mas claro, não pense que o motorista lerdo é "bobo", por exemplo. Chegará um momento que ele não cederá a vez, pois senão ele ficaria 2 anos na rotatória caso ela fosse movimentada.

Computacionalmente, o conceito é o mesmo. A única mudança é que não temos apenas 3 níveis de processos, mas sim uma grande escala de -20 até 19. As regras seguidas quando dois processos concorrentes possuem nível igual de gentileza são um tanto mais complexas do que simplesmente "quem veio primeiro passa", mas em condições normais elas são irrelevantes(e mesmo que não fossem, não temos como interferir nelas).

Ao iniciar, todo processo recebe por padrão, se não especificado, o nice 0(normal, nem gentil nem apressado). Este valor pode ser definido na hora de iniciar o processo e/ou alterado durante a execução. Usuários normais podem definir valores entre 0 e 19, sendo que valores negativos são exclusivos para o root.

Agora que você já está familiarizado com o conceito, vamos ver como isso funciona na prática. Em um derivado UNIX, como o Linux, temos dois comandos que ajustam o nice dos processos: nice e renice.

Veja seus usos básicos:

$ nice -n ajuste comando
$ renice ajuste -p lista-de-pids

Basicamente, o comando nice inicia um segundo comando(passado por parâmetro na linha de comando) com prioridade definida pela opção -n. O comando renice, por sua vez, redefine a prioridade de processos já existentes listados após a opção -p.

Executando um ls com nice 10:
$ nice -n 10 ls

Mudando para 15 o nice de um processo já iniciado de PID 12333:
$ renice 15 -p 12333

Bom pessoal, acho que dá pra ter uma boa compreensão do assunto. Lembrem-se de que uma definição boa de prioridades pode otimizar o sistema. E lembrem-se também que, apesar de não ser bom que o sistema chegue a esse ponto, em casos de instabilidade grande e grande consumo de processamento por algum processo, vale redefinir sua prioridade como uma "gambiarra provisória" para "aliviar" a máquina até que ela possa ser parada e substituida por uma que dê conta do recado.

Só complementando, me empenharei futuramente em escrever sobre o and(auto nice daemon), um serviço que monitora processos e define automaticamente os níveis de nice. É uma coisa que muitos procuram mas não sabem como fazer.

OBS: deixo o espaço aberto para quem quiser sugerir novos temas/assuntos/questões para mim escrever sobre. Mande como comentário ou me procure ;)

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Diagramas UML Genéricos Para Qualquer Sistema

noreply@blogger.com (Bruno Moreira Guedes) — Tue, 21 Oct 2008 03:24:00 +0000

Palavras-chave: UML, diagrama de classe, diagrama de seqüência, diagrama de caso de uso, inutilidades, besteiras, porcarias

Está cansado de desenvolver diagramas de sistemas levando horas para fazer isso?? Está cansado de ficar arrastando Bonecos Palito pra lá e pra cá??

Então você PRECISA é dos novos diagramas genéricos para QUALQUER SISTEMA da POG Corporation!!

Confira!! Estão disponíveis AQUI, para qualquer ~~idiota~~ indivíduo que queira utilizá-los, sem nenhum custo e totalmente de grátis!!

Classificação do conteúdo: INUTILIDADES(não leve a sério conteúdos com esta classificação)
Sobre mim:
Curriculum Vitae
Site Pessoal

Desmistificando os Ponteiros em C/C++

noreply@blogger.com (Bruno Moreira Guedes) — Mon, 20 Oct 2008 00:30:00 +0000

Tags: ponteiros, processadores, C, C++

Programadores C/C++ iniciantes, professores de faculdade, alunos de faculdade, programadores de outras linguagens... Muitas pessoas destas "categorias" tem uma coisa em comum: a "síndrome de pânico de ponteiros".

Os programadores iniciantes pela pouca familiaridade com a arquitetura de computadores em geral; os alunos de faculdade da área técnológica porque geralmente começam a dar os primeiros passos na programação antes de conhecer razoavelmente a arquitetura de um processador; os professores, por sua vez, morrem de medo de ter que explicar algo complexo para quem talvez não esteja ainda preparado para compreender o assunto; os programadores de outras linguagens por acharem que estão livres deles.

Escrevi este artigo para explicar como utilizar ponteiros, quais são seus possíveis problemas, e em que situações seu uso pode ser interessante.

O destaque é dos programas feitos em C/C++ por serem as linguagens de alto nível que mais utilizam estes recursos(por isso alguns autores as chamam de linguagens de "médio nível", mas não vamos entrar nesta discussão).

Como meu amigo David, que me sugeriu este post, havia me pedido para mostrar as utilidades dos ponteiros, então vou começar com uma lista de situações(a nível de programação em C/C++) aonde os ponteiros são FUNDAMENTAIS:

O trivial: na alocação dinâmica
Em seqüencias de dados alocados
Quando precisamos passar ou retornar a referência a um objeto de memória(em C, pois o C++ possui a passagem de referência)

Agora vamos falar sobre outras situações aonde temos os tais dos "ponteiros". Além dos relógios, medidores de combustível, velocímetros, e outros aparelhos analógicos, alguns aparelhos - que por sinal não possuem nada de analógico - também tem ponteiros. É o caso dos computadores: diversos registradores de um processador são apenas ponteiros. Por exemplo, BASE POINTER, STACK POINTER, INSTRUCTION POINTER, etc. A computação é baseada em ponteiros.

Precisamos conceituar um ponteiro. Tanto no relógio da cozinha, quanto no marcador de gasolina, e até nos ponteiros do processador, um ponteiro é algo que APONTA para alguma coisa. Podemos fazer uma analogia do relógio a um "ponteiro para endereços de tempo". É isso mesmo, quando definimos a forma como o nosso tempo "anda" organizando-a em Horas, Minutos e Segundos, criamos um sistema para endereçamento das fatias de tempo.

Da mesma forma funcionam os ponteiros dos processadores: a única diferença é que estes apontam para endereços de memória. Mas como assim "endereço de memória"?? Para que isso serve?? Bom, explicando para o pessoal de nível técnico menor, a memória do computador é muito grande. Para organizar tudo isso, ela é dividida em "blocos". Imagine a memória como uma parede de tijolos a vista. Cada tijolo é um bloco, ou segmento de memória. Cada um destes tijolos, é dividido em muitos bytes, além de ter o seu "número de identificação".

Agora, imaginem que criamos em nosso programa uma variável chamada 'a', do tipo inteiro(em uma arquitetura de 32bits normal e com SO que a utiliza devidamente, 4bytes). Como o nosso programa acha o local da memória aonde o valor de 'a' está armazenado?? Quando nosso programa inicia, o SO reserva segmentos de memória para ele. Apartir daí, o programa possui um endereço de seu "tijolo inicial", armazenado em um registrador. Mas ainda não é suficiente para acharmos 'a'. Precisamos saber em qual byte de um destes tijolos 'a' está.

Em linguagens de baixo nível, aonde trabalhamos com paginação de memória(especialmente em ambientes DOS, por exemplo, aonde temos acesso a manipular a memória diretamente), normalmente trabalhamos com 2 ponteiros: o ponteiro que indica o segmento de memória que estamos trabalhando, e o ponteiro que indica o offset dentro deste segmento(o número do byte procurado dentro daquele segmento).

Mas como esse post foca em C/C++, mais especificamente para sistemas operacionais completos, vamos deixar os detalhes de baixo nível "de lado", pois o compilador e o SO são nossos amigos e trata de fazer este trabalho para nós. Mas aí como fica?? Bom, imagine que todos esses blocos estão "mapeados"(entre aspas mas é isso mesmo, quem quiser entender melhor leia sobre a system call mmap dos sistemas POSIX). Para nosso programa tudo é um bloco único de memória, só precisamos indicar o byte aonde o objeto de memória se encontra.

Agora vamos para a parte prática. Quando trabalhamos com strings em C, qual é a melhor maneira para armazená-las?? Simples: PONTEIROS. "Mas como assim?? Eu armazendo elas em arrays(vetores) de caracteres!!"

Quando temos um array(vide exemplo abaixo), não temos nada mais que um ponteiro. É isso mesmo, apesar de muita gente imaginar que são duas coisas bem distintas. Quando declaramos um array, uma área de memória é definida na imagem do executável do programa para aquela variável(carregada na STACK, um segmento estático de memória, quando o programa inicia). O símbolo(variável) declarado como array é apenas um ponteiro para esta região de memória. Por outro lado, quando declaramos um ponteiro simples, nenhuma região de memória é pré-atribuida a ele.

Em C/C++ os ponteiros são tipados, e quando os acessamos, ele fará a leitura do número de bytes do tipo de dado ao qual ele pertence. Existem duas maneiras de acessar uma área de memória guardada por um ponteiro. A primeira é a derreferência normal, que ocorre quando utilizamos um '*' antes da variável do ponteiro. A segunda é a derreferência por índice, aonde colocamos um offset de deslocamento entre colchetes após o nome da variável.


int *ponteiro = funcao_que_retorna_um_ponteiro_de_int();
printf("%d\n", *ponteiro); //derreferência simples
printf("%d\n", ponteiro[0]); //derreferência por índice

Graças a tipagem dos ponteiros que a linguagem nos trás, podemos trabalhar com aritmética de ponteiros. Apesar de limitada, permitindo apenas adições e subtrações, ela nos ajuda em muitas situações. Seu uso normalmente é através da incrementação ou da decrementação de ponteiros. Vejamos o exemplo de derreferência por indexação abaixo:


int *ponteiro = funcao_que_retorna_um_ponteiro_para_um_array_de_int();
for (int i = 0; ponteiro[i] != 10; i++) {
    /*Percorre um array até encontrar um número 10 nele*/
    ...
    }

O código acima percorre um array de inteiros até aonde tiver um número '10'. Agora veja como isto poderia ser feito utilizando a aritmética de ponteiros:


int *ponteiro = funcao_que_retorna_um_ponteiro_para_um_array_de_int();
while(*ponteiro++ != 10) {
   ...
   }

Quando somamos 1 a um ponteiro, ele soma, na verdade, o número de bytes do tipo de dado do ponteiro. Por exemplo, em um ponteiro de int, ao somarmos com "ponteiro++", estamos somando sizeof(int) ao ponteiro. O mesmo vale para a subtração. Por este motivo a tipagem de ponteiros é extremamente importante. Com a fraca tipagem do C temos que ter este tipo de cuidado sempre!!

Muitos iniciantes, porém, de certa forma se 'iludem' ao fazer isso. É preciso ter um certo cuidado ao escolher entre as duas opções. Neste caso, por exemplo, temos um convite para um memory leak("vazamento" de memória, quando temos uma área de memória dinamicamente alocada e não possuimos uma referência a ela para efetuar a sua liberação) caso o array retornado pela função seja dinamicamente alocado. Quando a área retornada pelo array for estáticamente alocada(e isso podemos nem ter como saber), ainda temos um possível problema: o o conteúdo retornado poder ser local da função chamada. Por isso, nunca retorne um array local em uma função.

Observe agora o exemplo abaixo:


int ponteiro[10]; //array alocado estaticamente
... /* algum código preenchendo valores no array */
while(*ponteiro++ != 10) {
   ... /*a nossa "busca" do exemplo anterior*/
   }

Neste exemplo, corremos o risco de perder a referência à área estaticamente alocada. Isto pode causar uma série de confusões e dores de cabeça. Imagine por exemplo, que algo depois deste loop utilize o acesso por índice ao ponteiro. As chances de não sabermos se o offset acessado está dentro do array original é muito alta, a menos que façamos um controle rígido de quantas posições o ponteiro foi incrementado. Porém, neste tipo de situação o esforço para usar a aritmética de ponteiros de forma segura é grande demais, não compensando o trabalho e fazendo ser mais válido utilizar o acesso por índice em um ponteiro fixo.

Normalmente, o uso de ponteiros com derreferência simples combinado à aritmética de ponteiros se dá mais em funções, ou quando o ponteiro é uma "cópia", ou seja, um ponteiro igualado a um já existente. Veja o programa de exemplo abaixo:



#include <stdio.h>

int tamanho_string(const char *string);

int main() {
 int ponteiro1[10]; /* ponteiro p/ area estatica,
         aritmetica nao recomendada */

 int *ponteiro2; /* ponteiro nao inicializado, recomendavel
      para aritmetica */
 ponteiro2 = ponteiro1;
 printf("%d %d\n", *ponteiro2++, *ponteiro2);
 /* Exibe os 2 primeiros itens do array, usando a aritmetica
    de ponteiros */
 printf("%d %d\n", ponteiro1[0], *(ponteiro1+1));
 /* Mesma coisa, porem usa a aritmetica de ponteiros de uma
    maneira que eh segura mesmo com o ponteiro1 */

 ponteiro1++; /* Acabamos de perder a referencia para
                 o primeiro item do array!!! */
 ponteiro1[0] = tamanho_string("Ola Mundo");
 /* Estamos definindo este valor para o segundo item do array,
    pois o ponteiro aponta para o segundo apos seu incremento!! */
 printf("%p: %d\n", ponteiro1, *ponteiro1);
 return *ponteiro1;
}


int tamanho_string(const char *string) {
 /* Exemplo de uso de aritmetica de ponteiros em funcoes */
 /* Eh importante manter a referencia inicial, pois podemos
  * precisar dela ao longo da funcao. Porem, perder a referencia 
  * somente dentro do escopo local de uma funcao que nao eh a
  * criadora da area de memoria nao eh tao prejudicial.*/
 char *s = string;
 while (*s++);
 return (s - string) - 1;
}

No exemplo acima temos um mini-programa de teste, mostrando algumas situações comentadas anteriormente. Recomendo ao leitor interessado compilar o programa, rodar, e logo após editar o código inicializando as variáveis, adicionando alguns "printf"s, e fazendo experiências em geral. Isso vai facilitar muito a compreensão do assunto!!

Observe que a função para contar caracteres de uma string utiliza um elemento não comentado da aritmética de ponteiros, que é a subtração. A lógica é simples: incrementa o ponteiro enquanto o caractere apontado por ele não for nulo. Logo após, a subtração indicará o deslocamentoÉ assim que a função strlen da libc trabalha.

Agora vamos à alocação dinâmica, que é o uso mais comum dos ponteiros. Não vou falar muito em detalhes sobre ela, apenas explicarei sua utilidade e exemplificarei. Quem quiser saber mais sobre o assunto, veja os links que achei no Google e considerei satisfatórios: Alocação Dinâmica em C e Alocação Dinâmica em C++.

A utilidade da alocação dinâmica é simplesmente alocar quantidades de memória variáveis. Estas quantidades podem variar de acordo com o fluxo do programa. Um exemplo prático seria, por exemplo, se desenvolvermos uma agenda que grave os dados em um arquivo de texto e carregue-os na memória, além de permitir novos cadastros pelo usuário. Saiba que neste caso não sabemos quantos registros possuimos na agenda, e nem quantos o usuário vai inserir. Você utilizaria uma agenda com limite de cadastros, que se você cadastrasse além do limite causaria um estouro de memória?? Certamente NÃO!! Para seu usuário não sofrer com este tipo de limitação, é necessário dominar a alocação dinâmica de memória.

Vejamos um exemplo de alocação dinâmica em C e um em C++ respectivamente abaixo:



#include <stdio.h>

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

int main() {
 int tamanho, cur_chr;
 char *str_ptr = NULL, *p = NULL;
 
 scanf("%d", &tamanho);
 str_ptr = malloc(tamanho+1); // Aloca a memoria...

 if (!str_ptr) {
  printf("Erro de alocacao\n");
  exit(1);
 }

 memset(str_ptr, 0, tamanho+1);

 p = str_ptr;

 while(tamanho--) {
  cur_chr = getchar();
  if (cur_chr != EOF) {
   *p++ = (char) cur_chr;
  }
  else {
   printf("ALERTA: String nao ocupou todo espaco\n");
   break;
  }
 }
 printf("Fim da leitura da string!\n");
 printf("String lida: %s\n", str_ptr);
        free(str_ptr);
        return 0;
}



#include <iostream>

using namespace std;

int main() {
 int tamanho;
 char *str_ptr = NULL, *ptr = NULL;

 cin >> tamanho;
 try {
  str_ptr = new char[tamanho + 1];
 }
 catch(bad_alloc &e) {
  cout << "Erro alocando memoria" << endl;
 }

 memset(str_ptr, 0, tamanho + 1);
 ptr = str_ptr;

 while(tamanho-- && cin >> *ptr++);

 if (tamanho) {
  cout << "ALERTA: String nao ocupou todo espaco" << endl;
  }
 cout << "Fim da leitura da string!" << endl;
 cout << "String lida: " << str_ptr << endl;
 delete[] str_ptr;

 return 0;
}

Bom pessoal, acho que já deu pra ter uma boa noção, não é??

[]'s
Postem a vontade sugestões, pedidos ou idéias!!

Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Carregando bibliotecas dinâmicas em C++ com a dlopen API

noreply@blogger.com (Bruno Moreira Guedes) — Thu, 16 Oct 2008 20:21:00 +0000

Palavras-chave: plugins, C++, dlopen, bibliotecas dinâmicas

Bom, este é meu primeiro post com conteúdo mesmo. Quero demonstrar uma solução para uma dificuldade comum que alguns programadores C++ podem ter em determinadas situações. As bibliotecas dinâmicas são extremamente úteis, principalmente em sistemas de plugins. Desta maneira podemos desenvolver aplicativos mais dinâmicos, e deixar que outros usuários criem novas funcionalidades para eles. E não é só isso, tenha a necessidade e verás!!

A primeira vez que tive a necessidade de fazer isso, um tempo atrás, achei poucas referências sobre o assunto, nenhuma em Português. Destaque para o "C++ dlopen mini-HOWTO". Me surpreendi em saber que ninguém havia feito uma tradução dele, ou escrito algo sobre isso em língua portuguesa até hoje, e por isso escrevo este post.

Ele explica como carregar bibliotecas dinâmicas em ambientes Unix(especialmente GNU, que como o nome diz não é Unix :-). Quando precisamos carregar na linguagem C uma biblioteca, especialmente nos ambientes citados acima, é muito fácil. Simplesmente utilizamos a dlopen() API da maneira que ela foi projetada para funcionar. Esta API é composta das seguintes funções básicas:

void *dlopen(const char *path, int flags) - carrega a biblioteca dinâmica e retorna um handler
void *dlsym(void *handler, const char *symbol) - Retorna um ponteiro para o símbolo desejado(uma função ou uma variável/estrutura da biblioteca)
int dlclose(void *handler) - descarrega a biblioteca dinâmica e retorna um status
char *dlerror(void) - retorna descrição do ultimo erro ocorrido na API

Até aí, aparentemente nada impede o uso delas em C++, apesar de ficar a pergunta: "e se eu quero carregar uma classe, por exemplo?". Mas indo mais a fundo, ou para programadores C++ mais experiêntes, o problema torna-se visível: "name-mangling".

Não vou falar muito neste post sobre este cara de nome esquisito. Mas basicamente, os linkers adicionam ao arquivo uma função em C com um nome. Este nome é o nome da própria função. Mas agora imaginem a situação: C++ trabalha com sobrecarga. E se eu tiver duas funções com o mesmo nome e parâmetros diferentes?? Para isso, o compilador C++ modifica o nome das funções antes de gerar o arquivo-objeto. Esta modificação segue um padrão de notação de nomes, que depende da implementação do compilador(apesar de existirem 2 padrões bastante seguidos). "Isso" recebe o nome esquisito de 'name-mangling'.

Quando chamamos a função dlsym(), ela não consegue "adivinhar" que o name-mangling do C++ 'hackeou' o nome da função, pois ele foi escrito em C e "nem sabia" que o tal de "C++" existia. E agora?? Bom, o C++ possui um recurso para manter compatibilidade de nomes com o C. Este recurso é a declaração 'extern "C"'. Veja um exemplo de como utilizá-la:


extern "C" int funcao(int parametro); //declaraÃ§Ã£o unica a nÃ£o ser "mangleada"

extern "C" {
/* várias declarações a não serem "mangleadas" */
int funcao2(void);
int funcao3(int pqp);
int var1;
}

Agora, temos alguns cuidados quando nossos programas forem códigos que possam ser compilados com um compilador C. O problema é que o compilador C não sabe que existe o 'extern "C"', pois a linguagem C não possui esse recurso(por razões obvias). E agora jacaré? Meu código será exclusivamente C++, mesmo que seja uma porção estruturada do código que fiz para poder reaproveitar em um programa escrito em C??

Calma, veja o exemplo de como o pré-processador de macros nos salvará:


#ifdef __cplusplus

extern "C" {
/* bla bla bla */
}
#endif

Isso normalmente é útil para bibliotecas :-) Mas e aí, qual é a minha falando disso se estou falando de bibliotecas dinâmicas em C++?? Vamos lá! Funções C++ realmente terão perdas nessa história, pois perderemos a sobrecarga. Mas classes e métodos(o que realmente mais interessa no C++) ganham maior dinamismo. Como assim??

É simples. Podemos ter diferentes classes carregadas dinamicamente, sem o programa sequer "saber que ela existe" em tempo de compilação. A única restrição é que ela precisa herdar uma classe virtual(aka abstrata) que nós já declaramos(por motivos óbvios).

Ok, vamos colocar a mão na massa então?? Ok. É hora de definir requisitos do nosso aplicativo de teste:
-Exibir 'Hello, Brunildz is a beautiful man, world' na tela;
-Perguntar ao usuário o nome do arquivo de plugin a ser carregado;
-Carregar o plugin;
-Fazer as chamadas aos métodos GetFoo() e GetBar() das classes dos plugins;
-Retornar ao prompt solicitando o plugin novamente;
-Quando o valor de resposta do usuário for '0', sair;

Requisitos dos plugins Foo e Bar;
-Exibir a mensagem 'Foo'(para o plugin Foo) ou 'Bar'(para o plugin Bar) quando for carregado;
-Implementar classe imprimindo o nome de cada método chamado quando eles forem chamados;
-Classe deve seguir a interface do aplicativo;

Para isso, "precisamos" criar uma classe abstrata 'BrunildzPluginInterface', além de uma definição de tipo para um ponteiro para função retornando um objeto de nossa classe, em um arquivo que poderiamos chamar de BrunildzPluginInterface.hpp:


#ifndef __BRUNILDZPLUGININTERFACE_HPP

#define __BRUNILDZPLUGININTERFACE_HPP

class BrunildzPluginInterface {
public:
BrunildzPluginInterface() { }
virtual ~BrunildzPluginInterface() { };
virtual void GetFoo() = 0;
virtual void GetBar() = 0;
};


extern "C" {
typedef BrunildzPluginInterface *BPI_load_t();
typedef void BPI_unload_t(BrunildzPluginInterface *);
}

#endif//__BRUNILDZPLUGININTERFACE_HPP

Agora podemos criar o nosso primeiro plugin, chamado Foo. Para isso, precisamos de uma classe, uma função carregadora, e uma função descarregadora, que podemos criar no arquivo Foo.cpp(eu sei, ficaria mais limpo e reaproveitável dividir em Foo.h e Foo.cpp, mas é só um exemplo, aqui no blog fica mais bonito assim):


#include <BrunildzPluginInterface.hpp>

#include <iostream>

using namespace std;

class Foo : public BrunildzPluginInterface {
public:
Foo() {
   cout << "Plugin Foo: Foo();" << endl;
   }
~Foo() {
   cout << "Plugin Foo: ~Foo();" << endl;
   }
void GetFoo() {
   cout << "Plugin Foo: GetFoo();" << endl;
   }
void GetBar() {
   cout << "Plugin Foo: GetBar();" << endl;
   }
};


extern "C" {
BrunildzPluginInterface *load_plugin(void) {
   return new Foo;
}

void unload_plugin(BrunildzPluginInterface *bpi) {
   delete bpi;
}
}

Agora faremos o nosso plugin Bar, seguindo exatamente a mesma lógica:


#include <BrunildzPluginInterface.hpp>

#include <iostream>

using namespace std;

class Bar : public BrunildzPluginInterface {
public:
Bar() {
   cout << "Plugin Bar: Bar();" << endl;
   }
~Bar() {
   cout << "Plugin Bar: ~Bar();" << endl;
   }
void GetFoo() {
   cout << "Plugin Bar: GetFoo();" << endl;
   }
void GetBar() {
   cout << "Plugin Bar: GetBar();" << endl;
   }
};


extern "C" {
BrunildzPluginInterface *load_plugin(void) {
      return new Bar;
   }
void unload_plugin(BrunildzPluginInterface *bpi) {
      delete bpi;
   }
}

Ok, nossos plugins estão criados. E agora?? Basta fazermos o "trabalho sujo", ou seja, nossa aplicação. Vamos chamá-la de ldplugin.cpp:


#include <iostream>

#include <string>
#include <dlfcn.h>
#include <BrunildzPluginInterface.hpp>

using namespace std;


int main() {
string plugin, swp;
void *plugin_h = NULL;
BPI_load_t *loader = NULL;
BPI_unload_t *unloader = NULL;
BrunildzPluginInterface *instancia = NULL;

cout << "Hello, Brunildz is a beautiful man, world" << endl;

while (1) {
   cout << "Digite o nome do plugin(0 para sair): ";
   cin >> plugin;

   if (plugin == "0") break;

   swp = "./";
   swp += plugin;
   plugin = swp;

      plugin += ".so";
      plugin_h = dlopen(plugin.c_str(), RTLD_LAZY);
   if (!plugin_h) {
      cout << "Erro: " << dlerror() << endl;
      return 1;
      }
   loader = reinterpret_cast<BPI_load_t*>(dlsym(plugin_h,
                             "load_plugin"));
   unloader = reinterpret_cast<BPI_unload_t*>(dlsym(plugin_h,
                             "unload_plugin"));
   if (!loader || !unloader) {
      cout << "Erro: " << dlerror() << endl;
      return 1;
      }
   instancia = loader();
   instancia->GetFoo();
   instancia->GetBar();
   unloader(instancia);
   cout << "Proximo simbolo..." << endl;
   }
return 0;
}

Agora, para compilar é só executar os seguintes comandos(supondo que todos os arquivos acima estejam no diretório atual):

$ g++ -I. -fPIC -shared -g -o Bar.so Bar.cpp
$ g++ -I. -fPIC -shared -g -o Foo.so Foo.cpp
$ g++ -I. -ldl -rdynamic -o ldplugin ldplugin.cpp

Palavras-chave de busca que mais trouxeram a este artigo:
-dlsym class loading
-implementar biblioteca dinamica em C++
-biblioteca cout (!!!)
---
Classificação do conteúdo: SÉRIO
Sobre mim:
Curriculum Vitae
Site Pessoal

Brunildz

noreply@blogger.com (Bruno Moreira Guedes) — Wed, 15 Oct 2008 18:53:00 +0000

Olá a todos,

Informo que está no ar o "Brunildz 0.1 beta". Vou dedicar um pouco do meu tempo a disponibilizar tudo aquilo que um 'Geek' de plantão gosta de encontrar na web: informações sobre Técnologia, Software e... Besteiras em geral para descontrair(essas são de grande importância).

Bom pessoal, como meu blog terá muito conteúdo bem humorado, prometo distinguir(ao final de cada post) se o artigo é sério com informações válidas, ou se ele é algo para fazer pessoas rirem.

Antes de seguir qualquer instrução ou dica mencionada em algum post, por favor verifique se ele é confiável ao final!!

Espero que todos gostem!!

-----------------------------------
Classificação deste post: SÉRIO
Sobre Mim:
Meu Site Pessoal
Meu Curriculum (provavelmente atualizado)