Posts on Peczenyj's Blog

MooseX - a new Ruby DSL for Object Oriented Programming (and much more)

Fri, 07 Feb 2014 20:13:00 +0000

MooseX is a postmodern object DSL for Ruby

This is a DSL for object creation, aspects, method delegation and much more. It is based on Perl Moose and Moo, two important modules who add a better way of Object Orientation development (and I enjoy A LOT). Using a declarative stype, using Moose/Moo you can create attributes, methods, the entire constructor and much more. But I can’t find something similar in Ruby world, so I decide port a small subset of Moose to create a powerfull DSL for object construction.

Adding a 'dry run' capability to your Moose class with MooseX::Role::DryRunnable

Sun, 07 Apr 2013 09:55:00 +0000

A ‘dry run’ is a testing process where the effects of a possible failure are intentionally mitigated. For example, an aerospace company may conduct a “dry run” test of a jet’s new pilot ejection seat while the jet is parked on the ground, rather than while it is in flight. Or, in software development, we can change the behavior of some methods in order to test, like avoid change data into a database (logging the action instead).

There are many ways to implement this capability. For example, we can add an explicity return in each method and test some condition. I will show some options in this article and we will find how to use the module MooseX::Role::DryRunnable in our Moose classes (Perl).

One simple example in Perl, reading from an environment variable DRY_RUN.


package Foo;

sub bar {
	logger->debug("Foo::bar @_");
	return if $ENV{'DRY_RUN'};
	...
}

Lazy::Bool my first module in CPAN

Wed, 23 Jan 2013 20:15:00 +0000

Lazy::Bool is my first module in CPAN (The Comprehensive Perl Archive Network). It is a simple module (only 60 lines) and few methods/operators but can be useful in some situation. The source code can be found in my github.

##Example##

use Lazy::Bool;
use Test::More tests=> 3;
my $a = 6;
my $b = 4;
my $x = Lazy::Bool->new(sub{ $a > $b });
my $false = Lazy::Bool::false;
 
my $result = ($x | $false) & ( ! ( $false & ! $false ) );
 
# now the expressions will be evaluate
ok($result, "complex expression should be true");
ok(!! $x , "double negation of true value should be true"); 
ok(!!! $false, "truple negation of false value should be true");

Schwartzian transform

Tue, 22 Jan 2013 16:00:00 +0000

I will show in this post one of the most useful things that I learn in Perl: the famous Schwartzian transform. With examples in Ruby

In computer science, the Schwartzian transform is a Perl programming idiom used to improve the efficiency of sorting a list of items. This idiom is appropriate for comparison-based sorting when the ordering is actually based on the ordering of a certain property (the key) of the elements, where computing that property is an intensive operation that should be performed a minimal number of times. The Schwartzian Transform is notable in that it does not use named temporary arrays.

Codility Equi Task Solution in Modern Perl

Thu, 10 Jan 2013 12:32:00 +0000

Codility is one of the most common services used to apply test codes (for job applications, for example). Here you can find a task sample to pratice before try the real test. The present sample is the Equi Task, and the propose is very simple.

Imagine an array with N elements. There is a P value (0 <= P <= N) who solve the problem below?

A[0] + A[1] + ... + A[P−1] = A[P+1] + ... + A[N−2] + A[N−1].

In other words, where is the equilibrium index of this array?

Spell Correct in GNU AWK

Sat, 29 Dec 2012 03:17:00 +0000

Based on Peter Norvig Spell Correct

# Usage: gawk -v word=some_word_to_verify -f spelling.awk [ big.txt [ big2.txt ... ]]
# Gawk version with 15 lines -- 04/13/2008
# Author: tiago (dot) peczenyj (at) gmail (dot) com
# about.me/peczenyj
# Based on : http://norvig.com/spell-correct.html
function edits(w,max,candidates,list, i,j){
 for(i=0;i< max ;++i) ++list[substr(w,0,i) substr(w,i+2)] # deletes
 for(i=0;i< max-1;++i) ++list[substr(w,0,i) substr(w,i+2,1) substr(w,i+1,1) substr(w,i+3)] # transposes
 for(i=0;i< max ;++i) for(j in alpha) ++list[substr(w,0,i) alpha[j] substr(w,i+2)] # replaces
 for(i=0;i<= max ;++i) for(j in alpha) ++list[substr(w,0,i) alpha[j] substr(w,i+1)] # inserts
 for(i in list) if(i in NWORDS) candidates[i] = NWORDS[i] } 

function correct(word ,candidates,i,list,max,temp){
 edits(word,length(word),candidates,list)
 if (!asort(candidates,temp)) for(i in list) edits(i,length(i),candidates)
 return (max = asorti(candidates)) ? candidates[max] : word }

BEGIN{ if (ARGC == 1) ARGV[ARGC++] = "big.txt" # http://norvig.com/big.txt
 while(++i<=length(x="abcdefghijklmnopqrstuvwxyz")) alpha[i]=substr(x,i,1)
 IGNORECASE=RS="[^"x"]+" }

{ ++NWORDS[tolower($1)] }

END{ print (word in NWORDS) ? word : "correct("word")=> " correct(tolower(word)) }

This is my version of the Norvig’s Spell Corrector in gnu awk.

hello

Sat, 29 Dec 2012 02:26:00 +0000

Hello World!

Mudando de endereço

Sat, 03 Jan 2009 15:22:00 -0300

Foram centenas de posts desde que comecei a usar o blogspot como valvula de escape.

Agora adquiri um domínio próprio e estou usando o wordpress como engine de blog, com MediaWiki para salvar os posts mais importantes daqui.

Atualizem os seus feeds: pacman.blog.br, estou desativando este site. Obrigado a todos pela audiência :)

Novas Distribuições Linux

Mon, 22 Dec 2008 13:44:00 -0300

Diariamente eu leio noticias sobre novas distribuições, brasileiras ou internacionais.

Até que ponto isso é realmente necessário? Não seria melhor tentar focar em uma das excelentes distribuições que existem hoje em dia ou então tentar ajudar a manutenção de pacotes ou mesmo traduzir documentação?

Acho que produzir uma distribuição é um bom aprendizado, porém produzir algo que sera dificil de manter e atualizar pode ser bem penoso.

Comments

Vitor Pellegrino

@pacman

Aqui em casa funcionou. Quando chegou o novo micro aqui em casa, eu instalei o ubuntu e falei para a minha mãe (ultra-leiga, diga-se por sinal) que era a versão nova do Windows.

Ela está usando o Ubuntu a alguns meses e está se virando super bem :)

Tiago Peczenyj

Um experimento interessante é vc instalar o ubuntu ou outra distribuição dizendo que é uma nova versão do windows e deixar o pessoal utilizar por umas horas. Vão dizer que "agora ficou bom", "é bem rapido", etc :)

JOSIAS RAMOS

Concordo com você Tiago, acho que fui muito duro. Eu mesmo demorei um pouco para aderir ao linux, e olha que era na época bem mais difícil. Agora eu não deixo-o de jeito nenhum.
A divulgação está muito boa, mas para o usuários leigos mesmo, que apenas usam o PC para coisas triviais, esses é que tem que serem tratados com carinho por nós da comunidade GNU/Linux, e não esculaxados em fóruns como eu mesmo já presenciei.
Mas nada muda o fato de que poucas distros poderosas seriam bem melhores, tanto para a divulgação quanto para o desenvolvimento do que várias distros que quase ninguem usa.

Tiago Peczenyj

Josias, eu acho que vai alem.

Existe um grupo de interfaces gráficas que tentam copiar ou imitar o windows. Ao meu ver é interessante para ajudar na transição de usuarios de uma plataforma para a outra, da mesma forma que o cygwin me ajuda a usar o XP sem dar ls no prompt de comando.

Porém outras interfaces seguem outras ideias, e essa é uma riqueza sensacional do mundo linux/bsd, open source em geral. Interfaces como o fluxbox, window maker, enlightenment, cada uma com um propósito diferente. Temos muitos problemas ainda pela frente e precisamos de alguns focos no mundo open-source. Um deles é a divulgação que, com tantos blogs, planets, listas e foruns acho que estamos no caminho certo, porém ainda existem iniciativas isoladas para transmitir conhecimento como as palestras do Tchelinux, as install fests, etc.

Uma hora chegaremos lá!

JOSIAS RAMOS

É verdade, deveríamos pensar em fortalecer boas distros, desenvolvendo o Linux para desktops. Um amigo me disse que não ia mais usar o Linux que eu dei para ele pois não conseguiu usar algumas ferramentas que só tem no Windows. Temos que admitir que o Windows ainda domina os desktops por causa dos aplicativos e sua interface gráfica bem mais amigável, para programadores e entendidos não é nada de mais trabalhar com o Linux, eu amo, mais para usuários finais, pessoas que querem apenas um PC para se divertir, entrar no MSN, criar textos no Word, entre outras coisas, vão ter dificuldades em interagir com o Linux.
Ainda há programadores que, por ter aprendido algo, pensam que já nasceram sabendo, e não ajudam novos usuários, que às vezes são mal-tratados e decepcionam ainda mais com o Linux.
Espero que posssamos nos juntar para criar e desenvolver aplicativos para desktops, ou o Linux vai ficar sendo conhecido como o sistema operacional para servidores, com usuários programadores e administradores.

Guilherme Chapiewski

Outro dia mesmo falei no Twitter: as pessoas adoram re-inventar a roda.

Re-inventar a roda é pura perda de tempo, a não ser que se tenha uma necessidade extremamente específica (o que normalmente não é o caso).

[ ]s, gc

Rodrigo Kumpera

Boa parte da motivação de novas distros é dar foco em um conjunto específico de pacotes ou configurações.

Agora se as pessoas soubessem como é fácil resolver esse problema.

Para construir pacotes trivialmente basta usar o build service do OpenSuse, que permite empacotar para os principais formatos e distros.

http://build.opensuse.org/

Uma vez com os pacotes em mãos, juntar todos eles em uma distro com Suse Studio é razoavelmente simples.

http://studio.suse.com/

Criar distros inteiras é um esforço descomunal, custa, no mínimo, uma dúzia de engenheiros em tempo integral só para juntar os pedaços e, no final, entregar algo que não é melhor que as principais existentes.

Kroiner

Fiz um post uns dias atrás em meu blog tratando exatamente este assunto. Na minha opinião está meio exagerado o número de novas distros. A partir disso estou mandando um e-mail para cada nova distribuição que aparece perguntando os diferenciais entre esta distribuição e as distribuições efetivadas na comunidade. O e-mail, obviamente, é educado e mostra interesse pelos projetos, apenas questionando-os. Já mandei para 4 distros que apareceram novas versões entre esta e a semana passada e até agora nenhum projeto me deu algum retorno. Estou esperando até o final do ano e depois colocarei um parecer dessa pseudo-pesquisa se é que alguma vai me responder.

Tonismar
kroiner.wordpress.com

Victor Bogado

A verdade é que não é necessário, pode até ser um processo "legal" pelo aprendizado e pode até ser que o criador acredite realmente que está criando algo realmente util para a humanidade.

A verdade porém é que 99% destas distros, e sim eu acabei de inventar este numero, terão a sorte de não ter mais que um ou dois usuários. Pois fazer uma distribuição que sobreviva ter milhares, ou até mesmo milhões de usuários é dificil e acaba por forçar o distribuidor a fazer decisões arbritárias que provavelmente irão trazer a ira de uma boa porcentagem destes usuários dos quais quem sabe um ou dois não resolvem se juntar e criar a sua própria distro e...

Tirando o Mofo

Mon, 24 Nov 2008 18:26:00 -0300

Fiquei uns dias sem postar, hehe.

Tive pouco tempo livre, afinal além de pegar alguns projetos novos (e ter que aprender muito no processo) ainda tem a faculdade, que agora chega ao fim do semestre com algumas provas.

Nesse tempo também participei de alguns eventos legais, a começar pelo workshop de design patterns ministrado pelo Bruce Eckel (Thinking in Java, Thinking in C++). Foram 3 dias imerso em um mundo de orientação a objetos com exemplos em Java e Python. O Bruce é um cara muito bacana, tive a oportunidade de conversar bastante com ele e descobri que tinhamos algo em comum: uma graduação em física incompleta (chegamos a conclusão que não foi um tempo perdido pois aprendemos a resolver problemas, ou pelo menos demorar bastante tempo até desistir). Também tive a oportunidade de participar de um Coding Dojo onde resolvemos o problema da notação de trits (ao contrário, diga-se de passagem) usando Haskell. A ideia do Dojo é sensacional!

Também participei da PyConBrasil 2008. Foi um evento muito bom, excelente organização, sem falar que a sessão aberta com o Bruce sobre os rumos do Python foi o ponto forte, que surgiu totalmente do acaso. Python é uma linguagem muito interessante, com uma comunidade consideravel. Quem não usa python devido a indentação obrigatória do código usa um dos argumentos mais ridículos possiveis :)

Outro evento sensacional foi o workshop de Domain-Driven Design ministrado pelo Philip Calçado na Caelum/RJ. DDD é sobre comunicação, um ponto essencial no desenvolvimento de software nos dias de hoje. O Phillip foi responsavel, ainda que indiretamente, pela minha vinda a globo.com, porém só agora pudemos tomar aquele chopp e conversar sem ter 12 horas de diferença.

Sabado passado começou o curso on-line e intensivo de BDD on Rails com RSpec ministrado pelo Danilo Sato pela eGenial. Esta valendo a pena, pois parte daquela premissa que sempre defendi que temos que testar o nosso código e, para isso, existem varias abordagens e frameworks.

Estou preparando outros posts, devo atualizar este blog em breve.

Comments

Roger Leite

Legal Peczenyj!
Também participei do workshop de DDD, aqui em Sampa.

Sucesso!

Fear, uncertainty and doubt

Fri, 24 Oct 2008 10:02:00 -0300

Fear, uncertainty and doubt (ou simplesmente FUD) não é algo novo. Volta e meia alguma instituição ou candidato a utiliza de forma a enfraquecer o(s) seu(s) adversário(s), geralmente os projetos open-source são vitimas frequentes.

Hoje, no Rio de Janeiro haverá o ultimo debate entre os candidatos a prefeito. Não sou de usar blog técnico como meio de propaganda politica porém não posso ficar de braços cruzados enquanto um candidato utiliza FUD, Boatos e Mentiras. Aqui e aqui vemos alguns exemplos extremamente baixos, que qualquer pessoa com um minimo de instrução deveria perceber. Até quando isso será permitido? E o TRE? E os panfletos apócrifos apreendidos?

Felizmente o outro candidato, cujo partido possui uma cor verde interessante, não responde na mesma moeda pois seria facil usar coisas desse tipo, mas que não acrescentam nada.

Realmente a melhor forma de se proteger do FUD é informando a população, cobrando das autoridades cabíveis e destacando o quão antiético é esse tipo de abordagem. Felizmente cada cidade tem o prefeito que merece.

Comments

ju-ju

Tá na hora de atualizar, né? :)

Tiago Albineli Motta

Muito bom!
Dia 26, vou votar 43!

Chrome: o browser da google

Tue, 02 Sep 2008 16:48:00 -0300

As noticias apareceram em todas os sites especializados: o google estaria lançando hoje uma novidade chamada chrome, um browser baseado em Webkit disponivel por enquanto para Windows XP e Vista.

Até um gibi foi disponibilizado, então esperando até as 4 PM consegui fazer o download em uma maquina virtual e pude testa-lo um pouco.

A performance parece ser muito boa, apesar da virtualização. Não observei travamentos ou comportamentos estranhos (como os que ocorrem no Safari para Windows). O visual e as tabs são realmente práticas, com muita área para ver o site e icones intuitivos.

Bem interessante é o gerenciador de tarefas, (Controlar Pagina Atual > Desenvolvedor) onde podemos ver o consumo de cpu, memória e rede de cada aba (que rodam como processos independentes).

E também temos acesso a informações de memória bem detalhadas (infelizmente estáticas, gostaria que houvesse algo como o top do unix, quem sabe no futuro...).
]

O histórico é limpo e muito bonito

E um recurso que eu gostei bastante do novo Opera, mas com uma nova roupagem: ao abrir uma nova aba temos uma pagina com os favoritos e snapshots das paginas.

Por fim, basta instalar com um clique o plugin flash para navegar no Youtube ou Globo Videos

Outras coisas que percebi: a pergunta para salvar as senhas dos sites é muito mais discreta, aparecendo acima do site após o login (não é aquele alert que surge do nada). O Gmail parece ter uma boa performance e o gtalk funcionou sem maiores problemas. Com 6 abas o consumo de memória foi de 144408k - e ainda podemos comparar com outros browsers abertos!

Sinto falta de usar '/' para fazer pesquisas na pagina (quem usa Vim entende disso) mas o Ctrl + F funciona bem. Para configurar o tamanho da fonte basta usar Ctrl + (mais) e Ctrl - (menos) para alterar o tamanho do texto, Ctrl 0 para voltar ao normal. E, a mais interessante, não há necessidade de um campo de texto para pesquisas rapidas ao google ou outro buscador: basta digitar os termos no lugar da url (bem intuitivo, aliás). O download de algum arquivo é simples e bonito também.

Bom, até então eu gostei, só aguardo a versão para Linux e quero por as mãos no tão falado codigo fonte logo-logo :)

Link para download: http://gears.google.com/chrome

Edit: o Chrome tem o mesmo problema que o Firefox tinha para gerenciar senhas: ele mostra a senha sem pudor algum:

Poderia ter um recurso mais seguro como o da senha mestra do Firefox, parece que não pensaram (tanto) na nossa privacidade. Quem sabe no futuro isso não será corrigido?

Comments

Guilherme Garnier

Fala Pac. Também estou achando o Chrome bem legal. Mas a maioria desses detalhes que você citou já existem no Firefox. Ex: a pergunta pra salvar senhas no topo da tela, os atalhos para pesquisar e para mudar o tamanho do texto, pesquisa no google digitando direto na URL. E tem um plugin pra mostrar as snapshots como no Opera.

Lauro Cesar

Aqui tá rápido e estável. Ah e gastando até menos memória que o Firefox (se bem, que essa estória de que cada tab é um processo às vezes engana a gente...)
Enfim, parece muito bom mesmo!

Tiago Peczenyj

Valeu, Wagner, estou lutando para baixar os fontes!

Não lembrava que a memorização da senha tinha mudado no FF3, hehe.

leoburla

Também achei 144Mb bem pesado... Mas vou dar uma olhada na parada. Parece ser muito boa! Um abraço.

Tiago Albineli Motta

144 megas pra 6 abas é um pouco salgado heim. Que abas você foram essas?

Wagner Mezaroba

Legal, estou baixando o fonte pra Linux por aqui:

http://dev.chromium.org/developers/how-tos/build-instructions-linux#TOC-Getting-the-code

Tá bem lento, mas passou da primeira etapa.

Em relação a memorização de senha, no FF 3 não abre nenhuma janela tb. Só aparece uma barra encima (que não interrompe o fluxo de navegação).

Falou!

Despedida do Antonio

Fri, 29 Aug 2008 21:13:00 -0300

Esta foi a ultima semana do Antonio na globo.com. A despedida foi em grande estilo, com direito a galeria gourmet. Fica o exemplo e a saudade desse grande colega.

Em clima de festa com direito a montinho e tudo:

Fico feliz por ter surpreendido do Antonio nesses poucos meses que trabalhei com ele, agora os desafios são outros (aka Expurgo...)!

Toninho, boa sorte no Yahoo!

Comments

Antonio Carlos Silveira

Pac, Boa sorte para vc tb e continue assim... You are in the right path!

SQL Injection - A fina arte de criar paginas realmente inseguras

Mon, 25 Aug 2008 13:11:00 -0300

Este post diz tudo:

Por mais que existam alertas sobre os perigos de SQL Injection, muita gente resolve ignorar e criar sistemas cujas consultas ao banco de dados são feitas através de concatenações de strings com os dados oriundos do usuário.

Uma das primeiras coisas que aprendi quando trabalhava como testador foi tentar este código em telas de login:

' or '1' ='1

Imagine que o impacto dessa belezinha em uma query como esta:

"SELECT USUARIO FROM TABELA WHERE USUARIO = '" + usuario + "' AND SENHA = '" + senha + "'"
temos, então:

SELECT USUARIO FROM TABELA WHERE USUARIO = 'qqCoisa' AND SENHA = '' or '1' ='1'

Consegui efetuar o login devido a extrema preguiça do desenvolvedor que nunca se interessou em estudar um pouco de segurança, muito menos sabe o que é um prepared statement. Isso no melhor dos casos, posso querer inserir um DROP TABLE da vida facilmente, pois o sistema está, literalmente, de pernas abertas.

Recentemente um colega testou esse tipo de ataque contra um site de uma instituição por curiosidade. Ele conseguiu obter um arquivo contento a senha e o IP do banco de dados e conseguiu acessa-lo, perceberam o perigo?

Sinceramente? Se eu vejo um site que cai nesse truque eu não sinto pena. Não vou zoar ou fazer algo maléfico, as vezes até tento avisar, mas não sei se vale a pena: ou o sistema custou muito barato ou custou muito caro, foi produzido por uma consultoria que lucou 1980% em cima do salario do estágiario e que, por mais documentos que tenham produzido não conseguiram fazer algo básico: um site seguro contra hackers que estudam pela Wikipedia.

Se o seu site não pode receber aspas simples, duplas ou %, tenha MUITO medo, pois alguem VAI fazer algo em breve...



Comments


Marcio

Muito bom o post!


Marcio

muito bom o post!


Felipe

Essa tirinha do xkcd é uma das melhores.


Tiago Albineli Motta

Brincar com SQLInjection é divertido... principalmente em dias de tédio.



Closures em Java - Parte 2
Mon, 11 Aug 2008 10:48:00 -0300

Ainda sobre a Closures do java 7, agora será possivel fazer isso:

public class A {
 public static void main(String args[]) {
 @Shared int acumulador = 0;

 {int => int } xxx = { int i => acumulador += i; i};

 System.out.println(xxx.invoke(1));
 System.out.println(xxx.invoke(2));
 System.out.println(xxx.invoke(3));
 System.out.println("o valor do acumulador eh " + acumulador );

 }
}


Só eu estou achando divertido?

http://gafter.blogspot.com/2008/08/java-closures-prototype-feature.html
Comments


Tiago Peczenyj

Não dá ideia!!

Logo aparece um @Global da vida... ;-)


Marcelo Martins

Fiquei com medo que tu falasse que era uma "variavel global" 

hehe


Tiago Peczenyj

Martins, sem o @Shared o codigo compila mas gera um warning. É uma marcação que a variavel é compartilhada com outra closure ou bloco de código.


Marcelo Martins

O que que vem a ser aquele @shared?


Fabio Nascimento

Pois é, a única dúvida é como ele faz o autoboxing escondido(leia-se por debaixo dos panos)?
Mas no geral, tbm estou gostando, vamos ver... quando chegar a hora do SDK implementar isso de verdade mesmo.

Té +




Closures em Java
Fri, 08 Aug 2008 19:23:00 -0300

Olha o que vai ter no java 1.7

public class A {
 public static void main(String args[]) {
 exec( { int a, int b => a + b });
 exec( { int a, int b => a * b });
 exec( { int a, int b => 
 System.out.println("closure " + a + ":" + b); 
 (a * a) + (b * b) 
 });
 }
 public static void exec({ int, int => int } closure){
 System.out.println(closure.invoke(3,2));
 }
}


$ java -Xbootclasspath/p:./closures-2008-08-04/lib/closures.jar A
5
6
closure 3:2
13


Divertido :)

Fonte:
http://guj.com.br/posts/list/99477.java
Comments


Tiago Peczenyj

Hehehe... bizarro mesmo sera quando o java tiver suporte a pipes, sinais e outras coisas do mundo shell/C/*nix.

Imagina uma classe fazendo um TRAP... hehehe!


La Batalema Pitonisto

Tenho muito medo disso!

[]'s
Cacilhas, La Batalema




Parsing de XML na linguagem ABC
Fri, 08 Aug 2008 15:01:00 -0300

A maior parte das linguagens de progração em uso pelo mundo tem pelo menos 1024 bibliotecas para trabalhar com arquivos XML. Me espanta saber que muitos querem "gravar e ler" arquivos nesse formato mas não fazem ideia do que é um XML!

Eis um bom começo:
http://www.w3schools.com/xml/default.asp

Acho que nenhuma linguagem tem mais variações sobre o mesmo tema que Java: http://guj.com.br/artigos.jsp#87031


Testable & Untestable Code
Fri, 08 Aug 2008 14:29:00 -0300

Leitura recomendada:

http://misko.hevery.com/2008/07/24/how-to-write-3v1l-untestable-code/
http://www.testingreflections.com/node/view/7221
Comments


Guilherme Gall

Estou achando bem interessante a proposta do TDD. É algo que parece ser importante e que infelizmente não é visto na faculdade. Continue postando sobre isso sempre que é bem legal. Se puder, indique algum livro sobre o assunto.

Saudações




The Good, the Bad and the Ugly
Thu, 07 Aug 2008 18:40:00 -0300

Depois de ter visto algumas vezes "Era uma vez no Oeste" (com Charles Bronson tocando harmônica), finalmente pude conferir o clássico "Três Homens em Conflito" (The Good, the Bad and the Ugly) do mestre Sergio Leone. 

Clint Eastwood, Eli Wallach e Lee Van Cleef estão perfeitos nessa história cheia de sangue, traições e a obcessão pela riqueza. As panorâmicas de Leone sobre o desertico velho oeste e a caracterização dos homens embrutecidos daquela época, onde a vida não valia mais do alguns dólares, são majestosas, com direito à mostrar parte da guerra civil americana.



Esqueçam aqueles filmes de indios e tiros falsos: são personagens densos, únicos, em um momento diferente da história, com momentos fantásticos (como a cena em que o "Feio" monta um revolver com as peças de outros). Sem falar no olhar mortal do "Olhos de Anjo" Lee Van Cleef, que passa uma frieza na espinha...

- "When you have to shoot, shoot. Don’t talk!"

Sem falar no maravilhoso tema de Ennio Morriconi, clássico absoluto. O estilo Western não é vazio como muitos pensam, basta saber apreciar.
Comments


fpasetto

Vlw meu velho, finalmente algo q venho engajando meus esforços vem a ser reconhecido...

Abs




Voltas às Aulas e o Java - parte 2
Thu, 07 Aug 2008 17:43:00 -0300

Existe o clássico problema de determinar se um aluno passou ou não de ano quando são informados as notas e o número de faltas.

Vejamos: 
1) O número de faltas é acima do permitido?. Aqui entra um if dos bons com uma comparação numérica, quando um número é maior ou igual a outro.
2) A média é basicamente somar as X notas e dividir por X (se for média aritmética). Somar e dividir são operações matemáticas básicas.

Uma forma de fazer é:
 if( numero_de_faltas > maximo_de_faltas_toleradas) {
 // reprovado por faltas
} else if ( media_do_aluno < media_para_passar ){
 // reprovado por nota
} 
// se nem um nem outro, esta aprovado


O ruim dessa abordagem é que o aluno estar aprovado é uma condição "que sobra". Se passarmos a focar a aprovação do mesmo ficaria assim:

 if( media_do_aluno >= media_para_passar && numero_de_faltas <= maximo_de_faltas_toleradas) {
 // aprovado!
} else {
 // reprovado!
}

É claro que eu posso que eu posso querer saber o motivo pelo qual o aluno foi reprovado:

 if( media_do_aluno >= media_para_passar && numero_de_faltas <= maximo_de_faltas_toleradas) {
 // aprovado!
} else if(numero_de_faltas > maximo_de_faltas_toleradas){
 // reprovado pelo número de faltas: ignoro a média.
} else {
 // aqui só sobra a reprovação por nota, 
 // basta fazer a tabela-verdade dessas expressões
}

Se o foco do professor for o algoritmo, isso é o que deveria ser analisado. Quem implementa corretamente um método que recebe X notas e um número de faltas e consegue responder a essas perguntas consegue descrever facilmente os casos de teste para verificar se a implementação corresponde ao que se espera.

Um programa que tenha algum tipo de interação (seja Swing ou console) ajuda a fazer um macarrão de código, mesclando o algoritmo com o controle de estado dos "menuzinhos". No fim vemos laços de repetição aonde não são necessários, calculo de média errado, etc.

Ok, não acho que um marinheiro de primeira viagem devesse começar por JUnit, mas uma com boa noção dos fundamentos da linguagem e evitando a interação desnecessária com o usuario (poderia ser usado até os parâmetros do main), acredito num melhor desempenho. O risco é o aluno acreditar que java é dificil ou que tudo se resume a getters/setters e gigantescos try/catch's onde as exceptions são varridas pra debaixo do tapete. 

Eu colocaria TDD num segundo momento, mas ai sem perdão, ensinando o caboclo a fazer do jeito certo o quanto antes. O que é dificil se eles conseguem passar sem saber fazer aritmética básica.


Algumas pessoas PRECISAM fazer programas interativos
Wed, 06 Aug 2008 15:05:00 -0300

Este código:
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv){
 int i;
 double total =0;

 for(i=1;i < argc;i++){
 total = total + atof(argv[i]);
 }

 printf("A soma dos %d parametros eh %f\n",(argc - 1),total);

 return 0;
}


É limpo, prático e scriptável. Não preciso fazer pergunta nenhuma nem tratar nada que o usuario informe: no maximo posso ver o número de parâmetros e reclamar. Basta saber como funciona o laço for e saber que argc é o número de parâmetros que eu passei para o programa e argv é um vetor de strings (que, em C puro, são vetores de chars) onde cada elemento é um parâmetro. O primeiro é sempre o nome do programa (a posição 0, que eu pulei).

$ gcc -Wall soma.c
$ ./a.out 1 2 3 4 5
A soma dos 5 parametros eh 15.000000


Eu compilo e pelo para que todos os warnings possiveis sejam mostrados. Novamente não tive nenhum problema e o código funciona bem. Nem um flush de stdin foi preciso. Se eu colocar uma palavra no meio, como abóbora, será ignorado.

Não é mais facil assim do que fazer milhões de menus? Nem precisa de system("pause") system("cls")!
Comments


NetWalker

hmmm...
in.ignore(std::numeric_limits
<std::streamsize>::max(),'\n');
in.get();
??
heheheh :D
i agree


Tiago Peczenyj

Que fique registrado: system("pause") é um convite a morte.




Test Driven Development - parte 1.
Wed, 06 Aug 2008 14:31:00 -0300

Veja este código:

 public void testEhPar() throws Exception{
 assertTrue("2 deve ser par",algoritmo.ehPar(2));
 assertTrue("4 deve ser par",algoritmo.ehPar(4));
 assertTrue("6 deve ser par",algoritmo.ehPar(6));
 
 assertTrue("1 NAO deve ser par",!algoritmo.ehPar(1));
 assertTrue("3 NAO deve ser par",!algoritmo.ehPar(3));
 assertTrue("5 NAO deve ser par",!algoritmo.ehPar(5)); 
 }


Dentro de uma classe de teste, usando o framework JUnit, a leitura dessas linhas é a seguinte:

Eu tenho um objeto chamado algortimo.
A chamada algoritmo.ehPar(2) deve retornar true, pois 2 é par, e este método informa se o parâmetro informado é, ou não, par.
O método assertTrue recebe dois parâmetros: uma mensagem informando o significado deste teste, e o resultado do mesmo.

Se o método estivesse com algum problema e retornasse false, isso:

assertTrue("2 deve ser par",algoritmo.ehPar(2));

seria o mesmo que

assertTrue("2 deve ser par",false);

Logo, o teste falha, pois 2 deve ser par.

Esta é uma forma programática de garantir o comportamento do código que eu desenvolvo: testando. Se o meu método só depende dos parâmetros informados, é muito simples verificar o seu funcionamento.

Desenvolvendo os testes antes de implementar o código, tendo apenas as assinaturas dos métodos (por isso recorri a uma interface aqui, lembra?), eu posso pensar nos comportamentos esperados e, então, vou desenvolvendo até que todos os testes estejam passando.

Não é nada fácil, funciona melhor quando o projeto que estás desenvolvendo está começando, porém os resultados são excelentes: veja o quanto de tempo estás economizando! Se tu pretendes determinar se um código teu está funcionando por programas que perguntam os valores, escrever 

$ ant clean test


é muito mais rápido! 

O problema surge quando queremos fazer algo complexo, pois a dificuldade de testar mostra problemas na arquitetura adotada, por exemplo. Quanto temos objetos que tem objetos, herança, polimorfismo, tecnicas mais avançadas podem ser usadas como usar Mocks de objetos (e prover os mecanismos para injetar estes Mocks).

No caso desse exemplo, esta é uma solução:
public boolean ehPar(int numero){
 return numero % 2 == 0;
}


Muitos alunos desconhecem as operações de divisão e módulo entre inteiros. O 1, inteiro, dividido por 2, inteiro, não é 0.5, (em java), e sim 0, pois este é o resultado da divisão inteira. O resto da divisão, simbolizado por %, retorna 1. Dessa forma, o resto da divisão de um numero par por 2 é 0, caso contrario é um número inteiro. São operações básicas que precisam ser dominadas. Repare que eu fiz um código que funcione, não tentei nada mais maquiavélico que dê 0.0001 milissegundos mais rápido. Evite a otimização precoce.

Programar profissionalmente é uma tarefa de muita responsabilidade. Desenvolver testes para garantir a qualidade provê excelentes resultados a longo prazo.
Comments


Tiago Peczenyj

Sim sim, escrevi errado!


OLP

"caso contrario é um número inteiro" não seria "caso contrario o numero é impar" ?




Trocar de Emprego
Wed, 06 Aug 2008 14:19:00 -0300

Completando 6 meses de globo.com, refleti sobre a opção que fiz quando resolvi trocar de emprego. Vi essa semana muitas pessoas com duvidas de como ou quando fazer uma opção parecida, por isso resolvi colaborar.

A primeira coisa que devemos pensar é na nossa carreira. As vezes chegamos ao limite na empresa onde estamos, ou não há perspectivas, ou a situação está ruim, etc. São muitas as coisas que podem acontecer. Com um mercado com falta de mão-de-obra qualificada, muito profissional é assediado por empresas, prometendo as vezes salário maior, ou então surge uma oportunidade fora do estado. O que fazer?

Todas as oportunidades devem ser vistas de forma crítica. Analise o futuro, a distância, o ambiente de trabalho e, também, a remuneração. Eu sempre escolhi o trabalho à remuneração, mas trabalho que paguem abaixo do esperado eu simplesmente não considero. Escolher um emprego vendo apenas o salário engana: imagine ganhar 20% a mais em um emprego mais longe, onde vais perder mais tempo no trajeto, será que compensa? Ou então sair de um ambiente legal para uma confusão absoluta, onde domingo é dia útil de trabalho? Pois é.

Feito isso, temos que pensar em coisas práticas: todas as exigências são atendidas? Tem empresa que só se preocupa com diploma e certificações, mesmo que a sua bagagem supere todas expectativas. Se a empresa é em outra cidade ou estado, temos que analisar o custo de vida, mudança, lugar aonde morar (em grandes centros urbanos é sempre caótico, veja isso com muito cuidado).

O currículo precisa estar atualizado. Ja leu isto aqui? E isso?

Nas entrevistas seja sincero e tenha confiança: tu és um produto, tens que te vender. E, se mentir, babau, vão descobrir mais cedo ou mais tarde... Pra isso, podes estudar bastante algum assunto (eu vim lendo as apostilas da Caelum na viagem de carro que fiz de PoA ao RJ).

Por fim, planeje bem a transição: vale a pena sair com as portas abertas, caso ocorra algum problema. Seguindo estes passos é relativamente fácil optar por trocar, ou não, de emprego.

O importante é se sentir bem aonde estás trabalhando e colaborar para que o ambiente evolua, caso contrario podes ficar fazendo o mesmo trabalho, da mesma forma, por muito tempo: até que um estágiario possa ficar no seu lugar ;-)

Ps: como vai o seu inglês?


Voltas às Aulas e o Java
Mon, 04 Aug 2008 12:20:00 -0300

Na época de volta às aulas nas faculdades percebe-se uma grande invasão de alunos desesperados em foruns de informática para resolverem os seus execícios. É facil reconhecer um aluno em pânico com o seu primeiro while ou algum exercício sobre Fibonacci: eles não tentam, simplesmente colam o enunciado do problema esperando a resposta pronta.

Entretanto tão bizarro quanto são os exercícios propostos: um programa que leia pergunte 2 numeros e retorne a soma, ou um programa para calcular alguma coisa que pergunte ao usuário... perai, pergunte? Um programa perguntando? Como?

Este é o típico programa 'interativo' com o usuário. Quando não usa a entrada padrão (algo completamente misterioso para boa parte dos alunos), usam algum recurso SWING. Mas sera que ninguem pensa o quão PREJUDICIAL são estes exercícios?

Normalmente o aluno se preocupa com a apresentação do mesmo, fazendo frescuras de menuzinhos, asteriscos pra lá e pra cá... e o algoritmo que é bom nada. Sinceramente: dane-se os menuzinhos. Sabem quantos programas com menuzinhos e que vão perguntar alguma coisa pro usuario vcs vão fazer na vida profissional de vcs? 0! Zero! Nenhum!

Existem muitas formas de interação com o usuario, hoje em dia vc pode ter interfaces web, por exemplo. Eu acho que, num primeiro momento, a única interação com o usuario deveria ser escrever na tela. Nada mais que isso se o camarada não sabe o que significa um NullPointerException.


Exemplo pratico:

- Prepare um diretório para trabalhar (suponho que vc vai usar linux, senão deve ser facil portar este exemplo para outros sistemas operacionais).
- Crie um diretorio lib e copie o junit-4.4.jar pra lá (use o google pra baixar esse arquivo, se vc não conseguir saia do curso de informática).
- Crie a estrutura abaixo, ainda no diretório de trabalho:
src/java
src/test
- Instale o aplicativo ant (de novo o google te ajuda, alias vc tem algum JDK instalado, certo??).
- Crie um arquivo chamado build.xml no diretorio de trabalho.
- Baixe o arquivo ant-junit.jar daqui [ http://www.java2s.com/Code/Jar/ANT/Downloadantjunitjar.htm ] e copie o .JAR para ~/.ant/lib (se não existe, crie).

Agora vem a proposta: baseado nessa interface:

public interface Algoritmo{
/* dado um numero, retorna true se for par */ 
boolean ehPar(int numero);
/* calcula o valor absoluto ou modulo de um numero, ex: -1 vira 1, 1 vira 1 */
int calculaModulo(int numero);
/* calcula algum termo da série de fibonacci: se 0, mostra o primeiro, se 1 mostra o segundo...*/
int calculaFibonacci(int elemento);
/* calcula o fatorial do numero indicado */
long calculaFatorial(int numero);
}


Vais criar uma classe chamada, digamos, SuaClasse que implementa esta interface (percebeu que tudo deve ficar em src/java não é?). Não pense na implementação dessa classe ainda.

No diretorio src/test vc vai salvar esta classe:

import junit.framework.TestCase;

public class AlgoritmoTeste extends TestCase{
 Algoritmo algoritmo;
 public void setUp(){
 algoritmo = new SuaClasse();
 }
 
 public void tearDown(){
 algoritmo = null; 
 }
 
 public void testEhPar() throws Exception{
 assertTrue("2 deve ser par",algoritmo.ehPar(2));
 assertTrue("4 deve ser par",algoritmo.ehPar(4));
 assertTrue("6 deve ser par",algoritmo.ehPar(6));
 
 assertTrue("1 NAO deve ser par",!algoritmo.ehPar(1));
 assertTrue("3 NAO deve ser par",!algoritmo.ehPar(3));
 assertTrue("5 NAO deve ser par",!algoritmo.ehPar(5)); 
 }
 
 public void testCalculaModulo() throws Exception{
 assertTrue("modulo de 3 deve ser 3",algoritmo.calculaModulo(3) == 3);
 assertTrue("modulo de -3 deve ser 3",algoritmo.calculaModulo(-3) == 3);
 assertTrue("modulo de 5 deve ser 5",algoritmo.calculaModulo(5) == 5);
 assertTrue("modulo de -5 deve ser 5",algoritmo.calculaModulo(-5) == 5); 
 }
 
 public void testCalculaFibonacci() throws Exception{
 assertTrue("elemento 0 da serie fibonacci deve ser 0",algoritmo.calculaFibonacci(0) == 0);
 assertTrue("elemento 1 da serie fibonacci deve ser 1",algoritmo.calculaFibonacci(1) == 1);
 assertTrue("elemento 2 da serie fibonacci deve ser 1",algoritmo.calculaFibonacci(2) == 1);
 assertTrue("elemento 3 da serie fibonacci deve ser 2",algoritmo.calculaFibonacci(3) == 2); 
 assertTrue("elemento 4 da serie fibonacci deve ser 3",algoritmo.calculaFibonacci(4) == 3);
 assertTrue("elemento 5 da serie fibonacci deve ser 5",algoritmo.calculaFibonacci(5) == 5);
 assertTrue("elemento 6 da serie fibonacci deve ser 8",algoritmo.calculaFibonacci(6) == 8);
 assertTrue("elemento 7 da serie fibonacci deve ser 13",algoritmo.calculaFibonacci(7) == 13); 
 assertTrue("elemento 11 da serie fibonacci deve ser 89",algoritmo.calculaFibonacci(11) == 89);
 assertTrue("elemento 13 da serie fibonacci deve ser 223",algoritmo.calculaFibonacci(13) == 233); 
 }
 
 public void testCalculaFatorial() throws Exception{
 assertTrue("Fatorial de 1 deve ser 1",algoritmo.calculaFatorial(1) == 1);
 assertTrue("Fatorial de 2 deve ser 2",algoritmo.calculaFatorial(2) == 2);
 assertTrue("Fatorial de 3 deve ser 6",algoritmo.calculaFatorial(3) == 6);
 assertTrue("Fatorial de 4 deve ser 24",algoritmo.calculaFatorial(4) == 24);
 assertTrue("Fatorial de 5 deve ser 120",algoritmo.calculaFatorial(5) == 120);
 assertTrue("Fatorial de 6 deve ser 720",algoritmo.calculaFatorial(6) == 720);
 assertTrue("Fatorial de 10 deve ser 3628800L",algoritmo.calculaFatorial(10) == 3628800L); 
 }
}


Uma ideia sobre o JUnit pode ser encontrada aqui: [ http://guj.com.br/java.tutorial.artigo.40.1.guj ], alias o guj, na sessão de tutoriais, explica varias coisas, é ótimo material de referência!

Ok, vc tem a interface que vc deve respeitar e um arquivo de teste. Vamos falar do arquivo de build do ant.

<project name="Meu Projeto" basedir="." default="dist">
 <description>
 Aprendendo a fazer um build.xml para o ant
 </description>

 <property name="lib" location="lib"/>
 <property name="src" location="src/java"/>
 <property name="test" location="src/test"/>

 <property name="build" location="build"/>
 <property name="dist" location="dist"/>

 <path id="classpath.test"> 
 <pathelement location="${test}" />
 <pathelement location="${build}" />
 <pathelement location="${lib}/junit-4.4.jar" />
 </path>

 <target name="init">
 <!-- Create the time stamp -->
 <tstamp/>
 <!-- Create the build directory structure used by compile -->
 <mkdir dir="${build}"/>
 </target>

 <target name="compile" depends="init" description="compile the source " >
 <!-- Compile the java code from ${src} into ${build} -->
 <javac srcdir="${src}" destdir="${build}"/>
 </target>

 <target name="dist" depends="compile" description="generate the distribution" >
 <!-- Create the distribution directory -->
 <mkdir dir="${dist}/lib"/>

 <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
 <jar jarfile="${dist}/lib/Algortimo-${DSTAMP}.jar" basedir="${build}"/>
 </target>

 <target name="clean" description="clean up" >
 <!-- Delete the ${build} and ${dist} directory trees -->
 <delete dir="${build}"/>
 <delete dir="${dist}"/>
 </target>

 <target name="test" depends="compile">
 <javac srcdir="${test}">
 <classpath refid="classpath.test"/>
 </javac>
 <junit>
 <classpath refid="classpath.test" />
 <formatter type="brief" usefile="false" />
 <test name="AlgoritmoTeste"/>
 </junit>
 </target>
</project>


A utilização desse arquivo é muito simples, não se amedronte pelo tamanho do arquivo, o formato xml do ant é bizarro e verboso, sou muito mais um Makefile, porém uma vez com ele feito basta ir adicionando coisas "com cuidado". Sem falar que tudo tem documentação oficial cheia de exemplos, só não aprende quem não quer.

$ ant 
isso deve compilar a sua classe e gerar um jar (pode ser util no futuro).

$ ant clean
limpa os diretorios que vc acabou de criar com as suas paradas compiladas.

$ ant test
compila e executa os testes unítarios.

É claro que vc vai dizer, e agora??? Bom, veja isso:

public class SuaClasse implements Algoritmo{
 public boolean ehPar(int numero){return false;}
 public int calculaModulo(int numero){ return -1;}
 public int calculaFibonacci(int elemento){return -1;}
 public long calculaFatorial(int numero){return -1;}
}


Olha que legal! Uma classe que tem o minimo pra compilar! Agora vamos testar...

$ ant test
Buildfile: build.xml

init:
 [mkdir] Created dir: /home/GLOBO.COM/peczenyj/test/junit/build

compile:
 [javac] Compiling 2 source files to /home/GLOBO.COM/peczenyj/test/junit/build

test:
 [javac] Compiling 1 source file
 [junit] Testsuite: AlgoritmoTeste
 [junit] Tests run: 4, Failures: 4, Errors: 0, Time elapsed: 0.005 sec
 [junit] 
 [junit] Testcase: testEhPar(AlgoritmoTeste): FAILED
 [junit] 2 deve ser par
 [junit] junit.framework.AssertionFailedError: 2 deve ser par
 [junit] at AlgoritmoTeste.testEhPar(Unknown Source)
 [junit] 
 [junit] 
 [junit] Testcase: testCalculaModulo(AlgoritmoTeste): FAILED
 [junit] modulo de 3 deve ser 3
 [junit] junit.framework.AssertionFailedError: modulo de 3 deve ser 3
 [junit] at AlgoritmoTeste.testCalculaModulo(Unknown Source)
 [junit] 
 [junit] 
 [junit] Testcase: testCalculaFibonacci(AlgoritmoTeste): FAILED
 [junit] elemento 0 da serie fibonacci deve ser 0
 [junit] junit.framework.AssertionFailedError: elemento 0 da serie fibonacci deve ser 0
 [junit] at AlgoritmoTeste.testCalculaFibonacci(Unknown Source)
 [junit] 
 [junit] 
 [junit] Testcase: testCalculaFatorial(AlgoritmoTeste): FAILED
 [junit] Fatorial de 1 deve ser 1
 [junit] junit.framework.AssertionFailedError: Fatorial de 1 deve ser 1
 [junit] at AlgoritmoTeste.testCalculaFatorial(Unknown Source)
 [junit] 
 [junit] 
 [junit] Test AlgoritmoTeste FAILED

BUILD SUCCESSFUL
Total time: 1 second


Agora basta escrever codigo de verdade na SuaClasse e testar, estara pronto quando TUDO estiver passando. São 4 métodos básicos, sabendo lidar com variaveis locais, if e for, vc consegue muita coisa.

Se eu fosse professor eu daria exercícios assim: o projeto deveria compilar e todos os testes deveriam passar senão o aluno leva 0. A nota viria de acordo com o que eu espero, posso usar um EMMA e ver a cobertura de código, posso avaliar a presença de um Javadoc que preste, etc.

Enfim, eu seria um professor muito malvado }-)

Não perca a parte 2 aqui, e uma introdução ao TDD aqui.
Comments


Marcelo

Muito bom o post, parabéns. Na minha opinião todo professor poderia ser "ruim" desse jeito.


Rafael Ponte

Excelente post, parabéns!

Infelizmente muitos professores se preocupam mais com telinhas e "firulas" do que o que é importante na disciplina, pior é que muitos destes professores nunca nem ouviram falar sobre TDD ou mesmo testes unitários!


Guilherme Gall

Está aí uma coisa que sempre achei errado e vi acontecer várias vezes com mais de um professor onde estudo: o cara começa ensinando bibliotecas para desenvolvimento de aplicações gráficas e detalhes específicos de determinada linguagem para uma galera que não sabe nada (e quando digo que não sabe nada digo que não sabem nem definir o termo) de algoritmos, ou herança e polimorfismo por exemplo.

Terminam as matérias que envolvem programação sabendo como fazer sobrecarga de operadores, mas implementando toda a lógica de um programa dentro de uma única classe com métodos static. Sabem fazer janelas com botões bonitinhos, mas se matam para implementar a lógica do programa.

Ficaria feliz se minha primeira aula de programação fosse no esquema do seu post. Sempre gostei de brincar com os exercícios propostos em sala, mas o cara era tão inflexível que certo dia veio me pedir para trocar de editor de texto, porque o que eu estava utilizando era complicado demais (vim) e me confundiria (wtf?). Tive aulas bastante boas depois, com um cara que valorizava o que é realmente essencial, mas alguns de meus colegas não tiveram a mesma sorte e continuaram tendo aulas desse tipo durante vários semestres.

Triste é ver o camarada que me pediu para trocar de editor de texto sendo citado como "excelente professor para quem está começando". :-|


Tiago Peczenyj

É aquilo, ou se aprende por necessidade ou pq se gosta da parada. Eu propus algo que, se alguem gosta de programar, vai se amarrar em fazer.

Mas tem quem cague pra isso. Paciência, depois vai pegar um estágio onde vai ter que fazer algo muito pior e sem internet pra poder postar as dúvidas!


tiago_stos

Concordo como Roger, professor que faz aluno pensar e aprender algo útil é visto como professor ruim, que não sabe ensinar. Caso verídico de um professor do semestre passado.

Interessante notar que alguns professores que fazem os alunos pensarem mas ensino coisas inúteis não tem fama tão ruim...

Agora, Tiago, vc deveria dar aulas para alguns professores sobre como ensinar de verdade... hehe

Muito bom.


Roger Leite

É Tiago, você seria um professor malvado e muito odiado, porque, seguindo a experiência acadêmica que tive, todo professor que ensina algo útil, e faz os alunos pensarem, geralmente caem naquela listinha (de troca de professor) que vai pra secretaria.

Pelo menos foi isso que eu vi acontecer. :(

De qualquer maneira, concordo com o seu post, e se um dia eu der aula, vou seguir a dica !


CMilfont

Tiago, a academia não é para você. Você seria uam vergonha para seus colegas de "d[e]ocência".
Onde já se viu utilizar Junit, ant e essas bizarrices em sala de aula?
Cadê o bom e velho pascal? [engraçado que tem aluno do 5º semestre ainda chamando de pascoal]
Cadê os System.out.println que todo sistema de vergonha tem?
:)
Tirando a brincadeira, muito bom seu artigo!


Tiago Peczenyj

Falta o convite de alguma instituição de ensino, de preferência uma que não dê bola pras tais "Certificações".


Rafael Carneiro

Você já está indo no caminho correto... quando será professor mesmo? :-)


Tiago Peczenyj

Tenho que dar o primeiro exemplo }-)


Tiago Albineli Motta

Pra mim você está sendo bonzinho, pois você escreveu os testes pros alunos. Assim fica mole.




Tor: Um sistema anónimo de comunicação na Internet
Tue, 08 Jul 2008 16:14:00 -0300

Pelo veto ao projeto de cibercrimes - Em defesa da liberdade e do progresso do conhecimento na Internet Brasileira

http://www.petitiononline.com/veto2008/

Se esta lei for aprovada, podemos fazer uso do Tor para navegar tranquilamente.

Tor é um conjunto de ferramentas para um amplo grupo de organizações e particulares que desejam aumentar a sua segurança na Internet. Usar Tor pode ajudar a tornar anónima a navegação e publicação na Web, instant messaging, IRC, SSH, e outras aplicações que usem o protocolo TCP. Tor também disponibiliza uma plataforma para os programadores de software, criarem novas aplicações com funções de anonimato, segurança e privacidade já incorporadas.

Tor pretende defender contra a análise de tráfego, uma forma de vigilância que ameaça o anonimato pessoal e a privacidade, a confidencialidade dos negócios e relacionamentos, e a segurança de estados. As comunicações são enviadas através de uma rede distribuída de servidores chamados onion routers, protegendo-nos de sites Web que constroem perfis com os nossos interesses, pequenos espiões que lêem os nossos dados ou registam que sites visitámos.

A segurança do Tor aumenta à medida que a sua base de utilizadores aumenta e mais pessoas se oferecem para alojar servidores. Por favor considere oferecer o seu tempo ou oferecer a sua largura de banda. Convém lembrar que estamos a lidar com código em desenvolvimento — Não deve usar o Tor se precisa realmente de fortes garantias de anonimato. 

Fonte: http://www.torproject.org/index.html.pt


Sudo
Thu, 03 Jul 2008 17:35:00 -0300




Erlang é dificil (parte 2)
Thu, 19 Jun 2008 15:15:00 -0300

Agora vamos usar as funções específicas para manipular listas.

-module(tut).
-export([generate/1]).

%%
%% Funcao generate(X)
%% Quando X for 0, retorna [0]
%% Quando X > 0, retorna [X,X-1,...,0]
%% Caso contrario retorna [0,1,2,...,abs(X)]
%%
generate(0) -> [0];
generate(L) when integer(L), L > 0 -> 
 lists:seq(0,L); % cria uma lista de 0 até L
generate(L) when integer(L) -> 
 % vamos reverter a lista?
 lists:reverse(generate(-L)).


Muito mais simples, certo? Veja o teste:

$ erl
Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.5.5 (abort with ^G)
1> c(tut). 
{ok,tut}
2> tut:generate(5) ++ tut:generate(-5).
[0,1,2,3,4,5,5,4,3,2,1,0]
3> 


O operador ++ une 2 listas :)


Erlang é dificil?
Wed, 18 Jun 2008 19:10:00 -0300

Erlang é realmente dificil?

-module(tut).
-export([generate/1]).

%%
%% Funcao generate(X)
%% Quando X for 0, retorna [0]
%% Quando X > 0, retorna [X,X-1,...,0]
%% Caso contrario retorna [0,1,2,...,abs(X)]
%%
generate(0) -> [0];
generate(L) when integer(L) -> gera_lista(L).

gera_lista(L) when L > 0 -> gera_lista_direita(L);
gera_lista(L) -> gera_lista_inversa(-L).

gera_lista_direita(L) -> gera_lista_direita(L,[]).

gera_lista_direita(-1,Z) -> Z;
gera_lista_direita( L,Z) -> 
 %io:format("chamando: gera_lista_direita(~p,Z)~n",[L]),
 gera_lista_direita(L - 1,[L | Z]).

gera_lista_inversa(L) -> gera_lista_inversa(L,[]).

gera_lista_inversa(-1,Z) -> Z;
gera_lista_inversa( L,Z) -> gera_lista_inversa(L,0,Z).

gera_lista_inversa(-1,_,Z) -> gera_lista_inversa(-1,Z);
gera_lista_inversa( L,A,Z) -> 
 %io:format("chamando: h(~p,~p,Z)~n",[L,A]), 
 h(L - 1, A + 1,[A | Z]).


Ok, dessa forma é dificil. Erlang é uma linguagem funcional, ou seja, suas funções seguem um raciocínio matemático e não imperativo. Vc sente o problema quando quer resolver algo iterativo ou utilizar variaveis de qualquer forma.

Fiz uma pequena função chamada generate, do modulo tut (de tutorial, uma vez que estou seguindo um). Ela é muito simples, se vc informar 0, ela gera uma lista simples contendo 0. Se vc passar um numero positivo ela gera uma lista de 0 até o número, inclusive. Se o numero for negativo, ele assume que vc quer fazer fazer a lista de forma inversa.

Veja só:
$ erlc tut.erl # compilando o modulo
$ erl
Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.5.5 (abort with ^G)
1> c(tut). # carregando o modulo
{ok,tut}
2> tut:generate(0). # invocando modulo:funcao(parametros).
[0]
3> tut:generate(10).
[0,1,2,3,4,5,6,7,8,9,10]
4> tut:generate(-10).
[10,9,8,7,6,5,4,3,2,1,0]
5> 


A função generate chama a função gera_lista se o parametro passado for um número inteiro.
A função gera_lista chama a função para gerar a lista direita ou inversa, de acordo com o valor do parâmetro.

Veja só a simplicidade:

gera_lista_direita(L) -> gera_lista_direita(L,[]).

gera_lista_direita(-1,Z) -> Z;
gera_lista_direita( L,Z) -> 
 %io:format("chamando: gera_lista_direita(~p,Z)~n",[L]),
 gera_lista_direita(L - 1,[L | Z]).


quando eu chamo gera_lista_direita(10) eu estou, na verdade, chamado a função gera_lista_direita(10,[]), onde eu fico usando uma lista como acumulador.

A operação [L | X] pode ser lida como [ elemento | lista ] , ou seja, eu adiciono um elemento em uma lista. gera_lista_direita(10,[]) vai chamar, então, gera_lista_direita(9,[10]), e depois gera_lista_direita(8,[9, 10]), e assim recursivamente até gera_lista_direita(-1,Z), quando eu retorno a lista. Fica claro se removerem os comentários (%) da frente dos io:format, que é a forma de fazer PPADD (Passei Por Aqui Driven Development) em Erlang.

Erlang precisa de MUITA pratica, principalmente de quem nunca programou em uma linguagem funcional e fica tentado a fazer coisas 'não ortodoxas' ;-)

Ah sim, o google é seu amigo:

http://www.dei.isep.ipp.pt/~paf/orgcdocs/Intro_Erlang.pdf
Comments


anselmo alves

Para os que quiserem mais informações sobre BDD com Erlang no Giraffas ou até desmistificar o tema, acessem: 2web.


Tiago Peczenyj

Exatamente. Mas eu bloguei primeiro }-)


Tiago Albineli Motta

Mas o negócio não é só fazer BDD com Erlang, é fazer BDD com Erlang no Giraffas! Aí sim o bicho pega. Só conheço uma pessoa no mundo capaz de fazer isso.


Tiago Peczenyj

Uma coisa de cada vez.

Só depois eu descobri que erlang ja tem todas essas funções no módulo lists -- e deve ser até bem mais rápido.

Erlante tem um framework eunit, mas ai fazer BDD com isso são outros 500.


Guilherme Garnier

Legal Pac. Mas vc não explicou como fazer BDD com Erlang no Giraffas...




Tabela do Brasileirão 2008 com links + sed
Wed, 18 Jun 2008 15:15:00 -0300

O sed é um processador de texto muito versátil.

O links é um browser modo texto com features tão interessantes quanto do antigo lynx.

Ano passado eu postei como imprimir a tabela do brasileirão com um one liner interessante. Agora eu resolvi beber de outra fonte:

#!/bin/bash
TIME=Internacional
COLOR=$(echo -ne '\e[31;1m&\e[m')
URL=http://globoesporte.globo.com/Esportes/Futebol/Classificacao/0,,ESP0-9827,00.html
links --dump ${URL} | sed -r 's/\[[0-9]*\]//;/(^[0-9]|J jogos)/!d' | sed "s/${TIME}/${COLOR}/
 1a-----Libertadores----------
 4a-----Pre-Libertadores------
 5a-----Sul-Americana---------
 13a---------------------------
 17a-----Rebaixado-------------"


O resultado não é tão bom quanto o do ano passado, é verdade, mas não deixa de ser uma alternativa
Comments


Alan Carvalho de Assis

Ola Tiago,
gostei do script, muito fera.

Um abraço,

Alan


Tiago Peczenyj

Dê tempo ao tempo... ;-)


Ivan Brasil Fuzzer

Com poucas alterações no script até o resultado melhora.
Os bugs encontrados estão na cor e no time!
Mudando para azul e Gremio fica bem melhor :-P

Abraços.




Gerenciando Inovações
Fri, 13 Jun 2008 23:24:00 -0300

No ramo da tecnologia da informação, vulgo informática, saber gerenciar inovações é uma arte. Não tenho outras palavras para descrever o fato de vc olhar para uma ideia como o gmail, youtube, icq, orkut ou geocities e dizer "isso tem futuro". Mas não é bem assim.

A história de cada inovação bem sucedida é extremamente complexa: são opiniões diversas, conflitos internos, apostas, brigas e muito trabalho para transformar uma ideia em algo que marque de verdade. Com certeza nada naquilo que temos hoje é o que foi imaginado de primeira, afinal os conceitos evoluem. Com certeza aquele chefe chato que barrava todas as ideias contribuiu, mesmo que indiretamente, para o sucesso da ideia.

Ai tem um ponto interessante: quem não conhece aquele chefe que barra todas as ideias inovadoras? Estes são o outro extremo da coisa! A informática muda muito, as pessoas que tem computador hoje são diferentes das que tinham no passado e assim por diante, é dificil vc inovar sem se arriscar muito: é ai que entra o medo.

Em todos os ramos existe inovação, o que diferencia é a velocidade com a qual as coisas andam. Alguns ramos seguem as mesmas ideias por décadas ou séculos, enquanto outros ramos a escala é de semanas. É dificil não ter medo, afinal ou vc inova ou vc faz coisas loucas, inconsequentes, que podem destruir todo um trabalho de uma vida.

O segredo é saber o que vc quer. Empresas de tamanho médio inovam com algum pé atrás, apostando em formulas consagradas e alguma novidade para quebrar o clima. Empresas grandes não podem se dar ao luxo de inovar sob pena de perder o fio da meada portanto podem comprar as empresas pequenas que, inovando, podem gerar lucro para gigantescas corporações multinacionais. E este é apenas um cenário de muitos que acontecem por ai. Temos empresas que sabem vender o convencional como se fosse inovação, e vice-versa. 

A questão é: como lidar com inovações quando as mesmas podem ser o próximo microsoft bob ou o Iphone? Acho que cada um tem a sua formula: seja inovando ou comprando inovações por chegar a um tamanho que não é possivel não ser burocrata, cada um enfrenta essas novas tendências como acha melhor, trabalhando num ramo muito recente, onde as regras estão sendo escritas por bilhões de pessoas.

A resposta não é algo vago como: dilheiro dá em árvores ou todos tem potencial para ser algo mágico, etc, etc. É necessário entender as inovações que surgiram nos ultimos 10 anos (flash, ajax, orkut, celular, busca por palavras chave, etc) e reconhecer que existem milhões/bilhões de pessoas que contribuem para isso e elas são extremamente intelectualmente ativas. Uma face disso são os projetos open source como Linux, Hibernate e Ruby on Rails que competem de igual para igual com gigantescas corporações.

Resumindo: eu não sei lidar com inovações, mas elas chegam até mim via centenas de privilegiados que bebem da fonte. De alguma forma eu participo delas, mas não sei gerar nenhuma, tampouco saberia gerenciar, mas sei respeitar que o assunto é complexo e, principalmente, causa medo.

Medo de prejuizos. Principalmente se alguem lembrar muito, ou pouco.


Pesquisando nos Grupos do Yahoo
Wed, 28 May 2008 18:17:00 -0300

Meu amigo MrBits me deu essa grande ideia:

#!/bin/bash
QTDE=20
CHARSET=UTF-8
GROUP=shell-script

while getopts g:c:q: OPTION ; do
 case $OPTION in
 g) GROUP=$OPTARG ;;
 c) CHARSET=$OPTARG ;;
 q) QTDE=$OPTARG ;;
 esac
done

shift $(($OPTIND -1))

SEARCH="$@"

if [ -z "$SEARCH" ]; then 
 echo "Usage: $(basename $0) [-q qtde] [-g grupo] [-c charset] search" 
 exit 1
fi

BASEURL="http://br.groups.yahoo.com/group"
URL="${BASEURL}/${GROUP}/msearch?submit=OK&charset=${CHARSET}&cnt=${QTDE}&query=${SEARCH// /+}" 
SEDCMD="/message/!d;/${GROUP}/!d;/.*[0-9]/!d;s#/group#${BASEURL}#g;s/<[^>]*span>//g;s/$/<br \/>/"

LYNXOPT="-dump -force_html -assume_charset=${CHARSET}"
lynx $LYNXOPT <( curl -b /tmp/cookie$$ -sL "${URL}" | sed "${SEDCMD}" )


Vejamos em uso:
$ ./find.sh 
Usage: find.sh [-q qtde] [-g grupo] [-c charset] search

$ ./find.sh -q 10 getopts # procurando por getopts limitando a 10 registros
 [1]Re: [shell-script] Script de busca de mensagens
 [2]Re: [shell-script] Re: script iterativo / passo a passo
 [3]Re: [shell-script] Script de Backup
 [4]Re: [shell-script] Script de Backup
 [5]Re: [shell-script] Script de Backup
 [6]Re: [shell-script] Script de Backup
 [7]Re: [shell-script] Echo e executa: superecho
 [8]Re: [shell-script] testar se parametro $1 foi passado
 [9]Re: [shell-script] Echo e executa: superecho
 [10]Re: [shell-script] testar se parametro $1 foi passado

References

 1. http://br.groups.yahoo.com/group/shell-script/message/26373
 2. http://br.groups.yahoo.com/group/shell-script/message/26204
 3. http://br.groups.yahoo.com/group/shell-script/message/26078
 4. http://br.groups.yahoo.com/group/shell-script/message/26076
 5. http://br.groups.yahoo.com/group/shell-script/message/26075
 6. http://br.groups.yahoo.com/group/shell-script/message/26072
 7. http://br.groups.yahoo.com/group/shell-script/message/25742
 8. http://br.groups.yahoo.com/group/shell-script/message/25720
 9. http://br.groups.yahoo.com/group/shell-script/message/25719
 10. http://br.groups.yahoo.com/group/shell-script/message/25718


Divertido, não? o default é procurar no grupo shell-script do yahoo, mas ele pode investigar em qualquer um.

Valeu Mr.Bits!!
Comments


Tiago Peczenyj

Hahaha... te amarrou, gc?

Podes usar pra pesquisar no rioguj ;-)


Guilherme Chapiewski

\o/

É por isso que bash é a melhor coisa de todo o universo!!!


Tiago Peczenyj

Mas é facil, Roger!

/padrão/!d -> apaga *todas* as linhas que *não* casam com o padrão

s/padrão/substituição/g -> substitui, globalmente, o padrão pela substituição

s#xxx#yyy#g -> mesma coisa, util para não ter que escapar o caracter /


Roger Leite

Putz Tiago ! Você tá ficando muito louco mesmo, deve ser o sol ai do Rio ... não é possível !

Estes comandos de sed são de arrepiar, um dia ainda vou entender isso "nativo".

flw e sucesso!


Tiago Peczenyj

VB ? NUNCA!!!

Mas ja fiz coisas com VBScript... :$


Marcelo Martins

Tiago, tu ta ficando cada vez pior cara. Já pensou em dar um tempo e programar um pouco em Visual Basic?


hehe.. muito bom!




Francisco Ayala: Ciencia e Religiao
Tue, 27 May 2008 23:18:00 -0300

Interessante conclusão do Francisco J. Ayala:

Considere que pelo menos 20% das gravidezes notoriamente terminam em aborto espontâneo. Se isso resulta de anatomia divinamente inspirada Deus é o médico que mais realiza abortos.


Vale a pena ler o resto aqui

O começo:
Ex-padre defende que Deus e teoria evolutiva de Darwin são compatíveis

Para um professor universitário, Francisco J. Ayala passa muito tempo na estrada. 
Biólogo e geneticista evolutivo na Universidade da Califórnia em Irvine, ele freqüentemente fala em universidades, igrejas e qualquer outro lugar, geralmente em defesa da teoria da evolução e contra argumentos do criacionismo e seu primo ideológico, o design inteligente.
Comments


Tiago Peczenyj

Mas ai é chutometro ;-)


voyeg3r

Já parou pra pensar que este número pode estar relacionado com a tal "vida moderna", a força do capitalismo que nos faz comer toda porcaria que há. Além do mais a indústria do aborto assim como a das armas também manipula números em seu favor. Fiquemos bem cientes que há sim um forte lobby sedento por sangue e lucros tão organizado quanto o que fez os brasileiros pensarem que armas protegem a vida!




Hello World orientado a objetos
Wed, 21 May 2008 13:47:00 -0300

Hoje em dia é raro um desenvolvedor conhecer bem apenas uma linguagem. Em nome da multidisciplinaridade, decidi mostrar algums exemplos do mesmo programa: uma classe HelloWord com um construtor que recebe uma mensagem ("ola mundo") e um método show() que imprime essa mensagem.

Vejamos um exemplo em C++

#include <iostream>
#include <string>
using namespace std;

class HelloWorld{
 string mensagem;
 public:
 HelloWorld(string mensagem) { // construtor!
 this->mensagem = mensagem;
 }
 
 void show() { // metodo show
 cout << "mensagem: " << this->mensagem << endl;
 }
};
int main()
{
 HelloWorld obj("ola mundo");
 obj.show();
 return(0);
}


Agora o mesmo código em Java:

package Hello;

public class HelloWorld{
 private String mensagem;
 public HelloWorld(String mensagem){ 
 this.mensagem = mensagem;
 }
 public void show() { 
 System.out.println("mensagem: " + mensagem);
 }
 public static void main(String [] args){
 HelloWorld obj = new HelloWorld("ola mundo");
 obj.show();
 }
}


Agora, percebam a simplicidade do Ruby:
class HelloWorld
 def initialize(mensagem)
 @mensagem = mensagem 
 end
 def show 
 puts "mensagem: #{@mensagem}"
 end
end

obj = HelloWorld.new "ola mundo"
obj.show


Agora em Perl (sim, Perl!)
package HelloWorld;

sub new
{
 my ($class, $mensagem) = @_;
 my $self = { mensagem => $mensagem };
 bless $self, $class; # abençoando a variavel!
 return $self;
}

sub show
{
 my $self = shift; # sim, ela vem como argumento!
 print "mensagem: " . $self->{mensagem} . "\n";
}

my $obj = new HelloWorld("ola mundo");
$obj->show(); # parece artificial, não?

1;


PHP também é: 
<?php

Class HelloWorld{
 var $mensagem = "";
 function HelloWorld($mensagem){
 $this->mensagem = $mensagem;
 }
 function show(){
 echo "mensagem : " . $this->mensagem . "<br/>";
 }
}

$obj = new HelloWorld("ola mundo");
$obj->show();
?>


Por fim, vamos criar um tipo usando JavaScript
function HelloWorld(mensagem){
 this.mensagem = mensagem;
 this.show = function(){
 alert("mensagem: " + this.mensagem);
 }
}

var obj = new HelloWorld("ola mundo");
obj.show();


Edit: Python, atendendo a diversos pedidos
class HelloWorld:
 def __init__(self, arg):
 self.message = arg

 def show(self):
 print "mensagem: ", self.message

hello = HelloWorld("Ola Mundo")
hello.show()


A diferença entre uma linguagem e outra está (entre outras coisas) na sintaxe: em Perl eu tenho que criar os mecanismos na mão (com bless e receber $self) mas em Java e Ruby é tudo muito natural. Em Javascript eu não tenho uma construtor propriamente dito (muito menos classes) mas uma função (e crio um objeto dando um new nessa função). 

Vou abordar o tema "herança" no proximo post, espero que seja útil :)
Comments


douttorx

Opa cara, que legal o post.
estava procurando hello world em C++.
um abraço.


Cauê

Oi cara!
Sou do Rio grande do sul e faço faculdade de Eng.Elétrica na Unipampa de Alegrete e vi um post teu em um site sobre um programa em C++ que precisava usar a biblioteca math.
Tirei uma duvida ali contigo pq não lembrava que tinha que passar o grau pra radianos antes de transformar.
Eu gostaria que se quando eu tiver alguma duvida eu posso te avisar e quem sabe evoluir meus conhecimentos em C++.
Abraço.
Meu msn é : caue_cmm@hotmail.com


Marcelo Martins

Bah, Perl dói o olho. hehe


Airton Arantes

Só para complementar o post do amigo,Olhem esse post no meu blog:

http://defopenblog.wordpress.com/2008/05/07/e-eu-que-pensei-que-ja-tinha-visto-de-tudo/


Tiago Peczenyj

LG, pena que o comentario destruiu a indentação (que é fundamental no Python). Também esqueci do C#, mas é 99% igual ao Java.

Só não consegui fazer um exemplo em SmallTalk :(


lg

Tiago,

Muito bacana seu post. 
Colaborando com a proposta do seu texto, fiz um código, em Python, que ficou assim:

class helloWord():
 def __init__(self, msg):
 self.hello_msg = msg
 def show(self):
 print self.hello_msg
 
a = helloWord("Ola Mundo !")
a.show()

Abraços,
Luiz Guilherme 
lg.aldabalde em gmail.com


Gallimimus

Pô Thiago faltou em Shell Script ahahahah, abraços e parabéns pelo post.

Carlos Ferreira
http://carnivorosemdentes.blogspot.com/




CRDS - Conselho Regional de Desenvolvedores de Software
Fri, 02 May 2008 16:07:00 -0300

Num futuro não muito distante, o carlinhos está desenvolvendo um pequeno sistema de contas a pagar para a Padaria do Manoel. Entretando o seu local de trabalho recebe uma visita de um fiscal do CRDS!

- Pronto 
- Sr Carlos Silva?
- É ele.
- Meu nome é Teobaldo, sou fiscal do Conselho Regional de Desenvolvedores de Software. Fiquei sabendo que nesse recindo está sendo desenvolvido um "software".
- Exato! To desenvolvendo um...
- Antes de mais nada, qual a sua formação?
- Sou formado em ciências da computação pela faculdade VIVA VIVER, do Acre, na modalidade EAD. Meu trabalho de conclusão foi "um sistema escrito em java para a web 2.0".
- Puxa, ultimamente só tem dado essa faculdade. 
- Po, ela custa 49,99 por mês...
- É claro. Continuando, onde está a ART desse sistema?
- Bom, é um sistema pequeno, com menos de mil linhas, precisa ART?
- Claro, e vc pode imprimir o boleto pelo site da CRDS, não tem desculpas.
- Ok. Eu pagarei...
- E onde está a documentação do sistema? Cadê o levantamento de requisitos, análise de impacto, análise de riscos, análise...
- EI! O meu sistema foi feito utilizando metodologias ágeis! É uma mistura de SCRUM com XP proporcionando um contrato de escopo aberto onde eu tento atender as necessidades do cliente, evitando burocracia, trabalhando em sprints de 15 dias...
- Ok, mas o CRDS exige essa documentação no template .doc que vc pode baixar do site
- Mas q .doc ?? Ta maluco, eu uso openoffice no meu linux.
- Linux ?? Vc desenvolve em um sistema operacional não homologado pela CRDS? Se ainda fosse Ubuntu...
- Mas Ubuntu é linux.
- Chega, se não tem documentação, como vc sabe que o sistema funciona?
- Eu uso testes unitários!
- Humm... teste precisa de um profissional habilitado em testes.
- Mas eu uso JUNIT, veja!
- Ei... q java esquisito é esse com esses @ e esses "maior e menor"?
- Isso se chama Annotations e Generics! Ta desde o Java 1.5
- Desculpe mas o CRDS só permite o uso de Java 1.4.2 que é a versão homologada para o Windows E Ubuntu.
- E se eu estivesse usando MacOS ?
- MacOS não foi homologado pelo CRDS ainda.
- Mas java é multiplataforma!
- Certo certo... e o modelo ER?
- Eu uso Hibernate para Abstrair o modelo ER..
- Hibernate ? Ok, terei que embargar o seu sistema...
Comments


felipespsousa

vc dá para um bom comentarista hein petiene!


Jonas Ferreira - Thunder-Boy

Moro, trabalho e me formei em uma faculdade aqui de Rio Branco - Acre, ainda bem que aqui não existem faculdades a este preço, 49.99, se não o conto seria mais real! :)


Tiago Albineli Motta

Sensacional hahahaha


Guilherme

Muito bom!


tiago_stos

Hehe, muito bom. Pena que a piada perde um pouco a grança quando lembramos que algo assim pode acontecer aqui em nosso país em pouco tempo.

Ta certo, não exatamente desse jeito, talvez até pior...


Tiago Peczenyj

Pior q eu esqueci um dialogo: quando o fiscal pergunta sobre os Design Patterns utilizados, mas ficou legal do mesmo jeito :)


Felipe

Isso soa ridículo para qum é da área.

Mas vai mandar um senador ler isso aí :-(


MagoSabeTudo!!!

Muito boa essa!

Espero que nunca aconteça esse tipo de coisa!!!


Cássio Marques

Muito bom! Essa conseguiu ser mais legal que a da Tropa de Elite!
É rir pra não chorar...


Elton

Imagine um post exagerado :-)




TDD com Perl
Fri, 02 May 2008 15:00:00 -0300

É possivel fazer Test Driven Development com Perl? Mas claro :)

Artigo interessante sobre Test::More:
http://www.testingreflections.com/node/view/5333

Tutorial bem sucinto:
http://www.wgz.org/chromatic/perl/IntroTestMore.pdf

Excelente apresentação:
http://wellington.pm.org/archive/200606/tdd/
Comments


Tiago Peczenyj

Trabalho que é coisa séria ninguem comenta... ;-)




Pra descontrair...
Fri, 02 May 2008 14:48:00 -0300



Comments


Gustavo

Lancei uma campanha também.. Comente http://www.lichti.eti.br/onde-o-padre-voador-esteve/ por onde o padre ainda vai passar. O melhor comentário vai ganhar um vôo com balões para ajudar o Padre




Regulamentar a profissão dos outros é refresco
Fri, 02 May 2008 14:26:00 -0300

Na onda da campanha contra a regulamentação das profissões da área de informática

Eu, que trabalho como Analista de Sistemas e tenho Bacharelado em Física incompleto, tenho uma grande inveja do Phillip Calçado, que trabalha na Austrália, e postou recentemente sobre essa “lei”.

http://blog.fragmental.com.br/2008/03/21/ainda-bem-que-estou-aqui/

Cito a opinião da Sociedade Brasileira de Computação 

1. Exercício da profissão de Informática deve ser livre e independer de diploma ou comprovação de educação formal.
2. Nenhum conselho de profissão pode criar qualquer impedimento ou restrição ao princípio acima.
3. A área deve ser Auto-Regulada.


Parece que os politicos querem saber mais de informática do que quem é da área (se bobear ninguem sabe o que é a ACM, devem achar que é um politico a pouco falecido). Fico com pena de algumas pessoas egoístas que pensam “tenho diploma, logo essa lei me favorece”. A nação brasileira frperde como um todo, retrocendendo décadas numa das atitudes mais lastimáveis de todos os tempos.

Parafraseando o Rodrigo Kumpera:

Para ser programador vamos precisar ter diploma, enquanto isso para fazer política basta assinar o nome. Regulamentar a profissão dos outros é refresco.


Segue a thread: http://br-linux.org/2008/campanha-contra-o-projeto-de-lei-6072007-de-regulamentacao-das-profissoes-da-area-de-informatica/
Comments


Tiago Albineli Motta

Pura ignorância. Sou formado, mas antes mesmo de me formar já atuava na área. Normalmente quem apóia esse tipo de medida são os que tem medo de concorrência. Ou seja, os incompetentes.


Tiago Peczenyj

Pois é Thadeu,

Acredito que existem casos e casos. Eu não quero ser impedido de trabalhar, por exemplo, por não ter faculdade na área, coisa que não é preciso em boa parte do (senão todo o) mundo avançado.

Acho que precisamos de uma legislação adequada e que atenda às necessidades brasileiras. SE tivessemos uma carga de tributos menor sobre os trabalhadores, SE tantas outras coisas... Um dia a coisa vai.


Thadeu Penna

Oi Tiago,

os físicos também estão às voltas com a regulamentação. Também a visão da maioria é contra a regulamentação. O processo só está andando pois precisamos nos proteger das outras regulamentações. Exemplo: no último concurso para geofísicos na Petrobras foram aceitos geofísicos, geólogos e físicos. Os físicos formam a imensa maioria dos aprovados. Agora existe uma corrente para proibir a inscrição de físicos. Isto é possível pois como a profissão de físico não é regulamentada, outras podem pedir exclusividade nas tarefas, desde que não impeçam outros regulamentados que possam cumprir a mesma tarefa. Se fôssemos regulamentados, e na regulamentação constasse que físicos podem trabalhar como Geofísica, então a proibição seria anulada. A posição da comunidade, durante muito tempo, foi de contrária à regulamentação de profissões que não lidam com risco de vida diretamente, mas devido à proliferação de regulamentações, chega uma hora em que tem que se proteger. 

Por exemplo, lavador e guardador de carro é regulamentado, mas para operador de piscina, a regulamentação foi negada. Daqui a pouco, você não poderá fazer nada, nem na sua casa. 

[]s




Código transparente, contas fechadas ?
Fri, 02 May 2008 14:24:00 -0300

Engraçado como começamos a falar em “Transparência de Contas” e aparece gente dizendo q queremos acabar com o FISL. Parece que a ideia é “Aceite o FISL como ele É ou tu és contra o software livre no Brasil (e provavelmente usa Windows em casa)”.

Mesmo que o FISL acabasse (o que não vai acontecer, e ninguem quer) existem dezenas de eventos acontecendo pelo Brasil afora (alguns com palestrantes internacionais até). O FLISOL aconteceu em diversas cidades simultaneamente, por exemplo. Esses eventos só tendem a crescer e se profissionalizar, criando todo um ecossistema de divulgação de conhecimento técnico.

“Código transparente, contas fechadas” é um lema perigoso que pode acabar com a reputação da comunidade de software livre brasileira.
Comments


Tiago Peczenyj

Depois dos comentários do Richard Stallman na comunidade de Open BSD (dizendo: "isto aqui não tem a minha bênção") eu só posso deduzir que existe muito fanatismo nesse meio, e de gente que teoricamente prega liberdade.


Tiago Albineli Motta

No mínimo estranhas as reações da comunidade ao se exigir a abertura das contas do Fisl. Parecem-me fruto de fanatismo.


Tiago Peczenyj

Calendário do Tchelinux 2008
http://tchelinux.org/blog/?p=1

Um dos poucos grupos 100% autônomos, que levam o software livre a quem precisa, colocando muito suor. Para assistir às palestras basta levar alimentos não perecíveis que depois são revertidos à alguma entidade que precise, de forma transparente.




Manipulando logs com AWK e SED
Sat, 26 Apr 2008 14:41:00 -0300

Eis que a lista de shell script traz um bom desafio.

Galera, tenho o seguinte log.:

AAAA-------------campo_1-------------campo_2-----campo_3----campo_4---------- 
teste_1 371508787 371547453 38666 testetesteteste

BBBB-------------campo_1-------------campo_2-----campo_3----campo_4---------- 
teste_2 4625081503 4651313710 26232207 testetesteteste

Estou a tentar usar o awk com a seguinte função : 
awk '$1~"teste_" {print $5";"$4}' teste > teste_.csv

a funcao busca realmente o que desejo:
$5 $4
testetesteteste 38666
testetesteteste 6232207

porem,, gostaria que seprasse da forma:

AAAA------------- 
testetesteteste 38666 
BBBB------------- 
testetesteteste 26232207 

Alguém tem uma dica de como fazer?

Ah... o bom e velho SED pode resolver isso

$ sed -rn '/(^[^-]+-+).*/{s//\1/;h};
/^teste_/{s/.* ([^ ]+) +([^ ]+$)/\2 \1/;x;p;g;p}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

Ok, ok, ta muito complicado, mas veja só:

$ sed -rn '/^[^-]+-+/h;/^teste_/{x;p;g;p}' arquivo.log 
AAAA-------------campo_1-------------campo_2-----campo_3----campo_4----------
teste_1 371508787 371547453 38666 testetesteteste
BBBB-------------campo_1-------------campo_2-----campo_3----campo_4----------
teste_2 4625081503 4651313710 26232207 testetesteteste

Vamos explicar
1) a opção -n serve para informar ao sed "imprima apenas quando eu mandar"
2) a opção -p serve para utilizar expressões regulares extendidas
(assim não preciso escapar o quantificador + , que significa "um ou
mais vezes", assim como os parentesis, para informar os grupos).

Eu fiz uma sacanagem. o comando h quarda o padrão num espaço chamado espaço reserva, tipo uma memória do sed, sobreescrevendo. Assim no espaço reserva eu tenho a ultima ocorrencia de uma linha do tipo, ^[^-]+-+ ,que traduzindo significa: tudo o que começa com um ou varios caracteres diferentes de -, seguidos de um ou varios - (no caso
do AAAA------------- ... ).

Agora, quando eu encontro uma linha que começa com teste_ eu:

x) troco essa linha com a linha que esta na memória (a atual
'teste_...' vai, outra volta).
p) imprimo a linha que veio (AAAA---------- ...)
g) pego a linha da memória (teste_...)
p) imprimo a linha cachorrona

Só que não fica como vc quer. Ai vc precisa fazer a sacanagem:

se uma linha NÃO tem o que eu quero, então eu a manipulo habilmente
até que ela chegue ao que eu quero

Eu poderia ter usado varias tecnicas mas... uma vez com sed, podemos continuar nele.

$ sed -rn '/(^[^-]+-+).*/{s//\1/;h};
/^teste_/{s/.* ([^ ]+) +([^ ]+$)/\2 \1/;x;p;g;p}' arquivo.log

eu transformei a primera ER em (minha_ER).* -- ou seja, criei um grupo para o que me interessa. basta fazer:

s/(minha_ER).*/\1/

para que toda a linha seja reduzida ao que a minha ER casa. em outras palavras, eu apaguei o resto da linha.

na outra eu fui mais sacana pois eu tenho 2 grupos e troco toda a linha pelos grupos, na ordem inversa. coisa de quem toma muito café e não tem escrupulos.

Vamos ver a versão AWK?

$ awk '/^[^-]+-+/{match($0,/^[^-]+-+/); x=substr($0,1,RLENGTH)}
/^teste_/{print x,"\n"$5,$4}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

x, nesse caso, armazena aquele pedaço da linha anterior, que eu descobri o que é via match. match procura uma expressão regular numa string, nesse caso em $0, e seta um valor na variavel RLENGTH, que é onde a expressão acaba. basta pegar essa parte da string e guardar na variavel x, que sera lida depois.

Aqui fala um pouco dessas duas funções: http://people.cs.uu.nl/piet/docs/nawk/nawk_92.html

Eu poderia ter resolvido dessa forma também
$ awk '/^[^-]+-+/{sub(/-[^-]+.*$/,"-");x=$0} 
/^teste_/{print x,"\n"$5,$4}' arquivo.log
AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207

Entretanto aqui eu faço uma substituição grosseira do resto da linha que tem o AAAA------... por -, abusando do .* (e o fato dele ser guloso). Parece mais simples, mas está sujeito à falhas, embora não consigo pensar em nenhuma situação que seja possivem demonstrar.

AWK & SED são ferramentas sensacionais para esse tipo de problema ;-)
Comments


blpsilva

Impressive, to say the least :)

Acho que chegou a hora de limpar a minha ferrugem e reler o Advanced Bash Scripting Guide.

You produce some quite nice pearls inside the shell ;)


Tiago Peczenyj

grep + awk + sed:

$ grep -B 1 teste_ arquivo.log | \
awk '/teste_/{print $5,$4; next} 1' | \
sed -r '/^--$/d;s/(^[^-]+-+)[^-].*/\1/'

AAAA-------------
testetesteteste 38666
BBBB-------------
testetesteteste 26232207




Sbado dia 26 de Abril tem FLISOL na PUC-Rio !!
Fri, 25 Apr 2008 12:46:00 -0300



Em 26 de abril, será realizado o FLISOL - Festival Latinoamericano de Instalação de Software Livre - evento de divulgação de Software Livre da América Latina. No Rio de Janeiro quem está organizando este evento é o SL-RJ. Segundo o coordenador Carlos Ferreira, “É uma ótima oportunidade para levar seus amigos para passar este dia tão importante, participando das palestras ou instalando legalmente seu computador”. O Local onde será realizado, é a PUC-Rio - Pontifícia Universidade Católica do Rio de Janeiro - Auditório do RDC, localizado na Rua Marquês de São Vicente, 225, Gávea - Rio de Janeiro, RJ - Brasil - 22453-900. Das 8:30 às 17:00.


Veja mais informações aqui:
http://installfest.info/FLISOL2008/Brasil/RioDeJaneiro

Software disponível

 * Linux: Ubuntu
 * Openoffice e Firefox.
 * Para quem desejar, existe a opção de receber um cd da distribuição Linux Ubuntu versão 7.10, para isto basta levar um cd virgem. 

Palestras

Veja aqui a grade de palestras completa.

Iremos disponibilizar uma máquina e uma pessoa para ficar durante todo o evento à disposição das pessoas interessadas em conhecer um determinado programa ou recurso, tirar dúvidas e/ou obter dicas.

Como ajudar?

Você pode ajudar o evento de diversas maneiras. A mais simples é divulgando-o para os seus amigos, na sua escola ou no seu trabalho.

Se você quiser, pode ser um instalador ou palestrante no InstallFest. Envie um e-mail para Carlos Ferreira  ou Luiz Aldabalde  falando um pouco sobre a sua experiência com GNU/Linux ou qualquer outra aplicação livre que seja instalada durante o evento.

Caso queira ajudar de qualquer outra forma, entre em contato conosco por e-mail. Toda a ajuda é bem vinda!

O que devo fazer para me preparar para o Install Fest?

ATENÇÂO: Maquinas do tipo Desktop(com gabinete) só poderão entrar no Campus da PUC-Rio até as 12:00 horas, após este horário somente laptops dentro de mochilas.

Checagem de Hardware: No Windows, vá até o Painel de Controle e escolha Sistema. Liste:

 * Placa de rede (marca, modelo, configuração)
 * Placa de vídeo (marca, modelo, configuração)
 * Placa de Som (marca, modelo, configuração)
 * CPU (Processador)
 * Memória RAM
 * Modem (marca, modelo, configuração)
 * Espaço livre em disco (mínimo de 5.0 Gb)
 * Componentes SCSI (se houver algum) 

* Faça backup dos seus dados. Por precaução, você deve fazer uma cópia dos seus dados importantes no computador do seu amigo ou em CD-ROM.

* Particionamento do disco: se você souber como fazer, faça uma partição de no mínimo 5.0 Gb. Quanto maior for essa partição, mais utilidades do Linux poderão ser instaladas. Se você não souber fazer isso, nós faremos no dia do Install Fest. Apenas irá demorar mais tempo.

* Desfragmento do disco: Se você não souber fazer o particionamento, desfragmente o seu disco. Se você não souber fazer isso, ou não quiser, nós o faremos no dia do Install Fest. Apenas a sua instalação demorará mais que se você o tivesse feito antecipadamente. Para desfragmentar no Windows, primeiro desabilite todos os programas. Isso incluirá ICQ, navegadores, anti-vírus ou qualquer outra coisa que você estiver rodando. A seguir, clique em Iniciar, Programas, Acessórios, Desfragmentador de Disco. A seguir, clique em Iniciar na janela que aparecer nesse instante.

* Os custos de transporte do seu PC são de sua responsabilidade.

* Trazer para o Install Fest o Gabinete,Teclado, mouse e ainda, cabos de comunicação CPU-Periférico e cabos de força. Enfim, tudo o que é necessário para fazer seu computador funcionar. Se possível, traga também os manuais do seu hardware.

Apoio

CASA DO MOODLE http://www.casadomoodle.com

Responsáveis

Coordenador: 
 o Carlos Henrique Lucas Ferreira  

Colaboradores:
 o Luiz Guilherme Aldabalde
 o Avalci Suzano
 o Carlos Eduardo(Cadunico)
 o Luis Felipe Costa
 o Bruno Garcia
 o Josir Gomes


Sobre o FISL e tudo mais
Sun, 20 Apr 2008 21:40:00 -0300

Rapidamente, foi ótimo reencontrar os amigos de Porto Alegre. Os ultimos dias do FISL me cansaram demais, porém foi ótimo conversar pessoalmente com o Aurélio (alias o livro dele é ANIMAL! vale a pena adquirir!), rever o Julio Neves, a galera do Tchelinux, sem falar na galera que eu conheci no evento (que eu insistia em trocar o nome, procedência, etc). Um abraço especial pro Marcelo Martins, que deve estar em Torres agora.

Destaque para a palestra do Guilherme Chapiewski.

Devo me preparar melhor para os próximos eventos, tanto em Poa ano que vem quanto os próximos eventos (como o FLISOL dia 26 de Abril na PUC-RJ, sem falar no Hack'n Rio). To doido pra ir no Javauy 2008 mas acho que não vai rolar :( Estou cheio de ideias!

Peço desculpas a todos que não conseguiram me encontrar ou que não pude conversar direito! Forte Abraço!
Comments


Tiago Albineli Motta

O Fisl foi bom demais!


Aurélio Jargas

Daê Thiago, legal te conhecer também cara, valeu pela força, abração!


Tiago Peczenyj

"art of testing" ??


The Art of Testing

Grande Peczenyj, foi muito bom conversar contigo cara. Varias e grandes idéias trocadas. Abração cara!!1




Um corretor ortográfico em gawk
Sun, 13 Apr 2008 14:39:00 -0300

Ano passado eu publiquei uma pequena nota sobre um pequeno corretor ortográfico feito em Python.

No artigo do Peter Norwig, ele explica o principio estatístico do algoritmo. No final, ele mostra varias implementações do algoritmo (em D, Java, Ruby e até Erlang).

Depois de muito pesquisar, decidi fazer uma versão em gawk. A primeira tinha 30 linhas e não funcionava muito bem, arrumando e testando cheguei a esta forma final com apenas 15 linhas.

Eu chamo de linha um statement completo do awk. Perceba que nenhuma linha dessas possui o separador de statement ; (ponto-e-virgula), exceto quando estou utilizando o for no estilo C.

# Usage: gawk -v word=something -f thisfile.awk [ big.txt [ big2.txt ... ]]
# Gawk version with 15 lines -- 04/13/2008
# Author: tiago (dot) peczenyj (at) gmail (dot) com 
# Based on : http://norvig.com/spell-correct.html
function edits(w,max,candidates,list, i,j){
 for(i=0;i< max ;++i) ++list[substr(w,0,i) substr(w,i+2)] 
 for(i=0;i< max-1;++i) ++list[substr(w,0,i) substr(w,i+2,1) substr(w,i+1,1) substr(w,i+3)] 
 for(i=0;i< max ;++i) for(j in alpha) ++list[substr(w,0,i) alpha[j] substr(w,i+2)] 
 for(i=0;i<= max ;++i) for(j in alpha) ++list[substr(w,0,i) alpha[j] substr(w,i+1)] 
 for(i in list) if(i in NWORDS) candidates[i] = NWORDS[i] }

function correct(word ,candidates,i,list,max,temp){
 edits(word,length(word),candidates,list)
 if (!asort(candidates,temp)) for(i in list) edits(i,length(i),candidates)
 return (max = asorti(candidates)) ? candidates[max] : word }

BEGIN{ if (ARGC == 1) ARGV[ARGC++] = "big.txt" # http://norvig.com/big.txt
 while(++i<=length(x="abcdefghijklmnopqrstuvwxyz")) alpha[i]=substr(x,i,1)
 IGNORECASE=RS="[^"x"]+" }

{ ++NWORDS[tolower($1)] }

END{ print (word in NWORDS) ? word : "correct("word")=> " correct(tolower(word)) }


Veja o script em funcionamento:
$ time gawk -v word=somethink -f spelling.awk
correct(somethink)=> something

real 0m4.862s
user 0m4.702s
sys 0m0.093s
Comments


Rael

Tiago, mais uma vez, parabéns!
É muito divertido mexer com estas coisas, não?
Ah, eu não esqueci de te mandar a versão otimizada em Java... eu só não achei seu email pra enviar! :P
Me manda um email, e eu te dou reply!


Tiago Albineli Motta

Corretor ortográfico, tatuagem... esse foi um final de semana divertido pra você heim! hahahha




Participe do Domingão do Faustão
Sat, 05 Apr 2008 16:35:00 -0300

Vou fazer uma propaganda descarada: o Domingão do Faustão lançou o quadro Dança da Galera!

Para participar, basta seguir as instruções aqui e enviar o seu vídeo!

2008 promete muitas novidades! Aguardem!


Venha Tomar um Chimarrão no Estande da Globo.com!
Fri, 04 Apr 2008 15:35:00 -0300

Acompanhando o post do Guilherme, dia 18 eu devo aparecer por Porto Alegre, para o FISL.

Venha Tomar um Chimarrão no Estande da Globo.com durante o FISL!
Comments


Tiago Albineli Motta

É claro que irei :)


Luis Eduardo Bohrer da Silva

Muito legal Tiago.

Nos veremos lá.
Para tomar um chimarrão e falar um pouco de tecnologia. :-D

Até mais.




Programando em C para console - parte 1
Wed, 02 Apr 2008 14:10:00 -0300

(Depois de um fecundo primeiro de Abril... )

Cada vez mais eu me espanto com a quantidade de novatos que tentam fazer programas para o "modo console" que não fazem o menor sentido.

Programas com menuzinho (1 - saque , 2 - deposito, 3 - sair) ou do estilo "digite um numero (q para sair)" são totalmente contra-produtivos. O novato perde TEMPO fazendo um monte de código desnecessário quando esquece o que deveria fazer (o tal do algoritmo).

Veja um exemplo: um programa que receba uma quantidade variavel de números e que imprima a soma dos mesmos. IMHO a forma mais interessante para fazer isso é pegar os números como argumentos do programa principal. Vc cria um programa console absolutamente limpo e facil de scriptar, por exemplo.

Veja só:

#include <stdio.h>

int main(int argc, char *argv[]){
 double soma = 0.0;

 printf("A soma dos numeros eh %g\n",soma);

 return 0;
}


Feito esse simples arquivo, vamos compilar
$ gcc -Wall soma.c
$ ./a.out 1 2 3 4 5 
A soma dos numeros eh 0


Ai vc fala "po, ta errado!", mas claro, eu primeiro escrevi a base do meu programa. Perceba que eu compilei com a opção -Wall, que me informa todos os warnings que a compilação pode gerar (o que sempre é uma excelente pratica, eu procuro compilar sempre com 0 warnings).

Feito isso, vamos definir 2 coisas:
 - O algoritmo da soma e
 - Possiveis fluxos de excessão.

Vou partir do suposto que, se vc digitar alguma coisa que não seja um numero, eu vou ignorar e considerar como 0. Caso eu não informe nenhum numero ao programa, isso significa que estou faltando com alguma coisa, nesse caso vou informar uma mensagem elucidativa sobre o uso do programa.

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

int main(int argc, char *argv[]){
 int i;
 double soma = 0.0;

 if(argc == 1){
 fprintf(stderr,"Faltando Argumentos!\n");
 fprintf(stderr,"Uso: %s x1 [ x2 .. xN ]\n",argv[0]);
 return 1;
 }

 for(i=1;i<argc;i++) 
 soma += atof(argv[i]);

 printf("A soma dos numeros eh %g\n",soma);

 return 0;
}


Todos os argumentos que eu passo para o programa, incluindo o nome do mesmo, ficam no vetor argv, e o número de argumentos fica na variavel arcc. Dessa forma, o nome do programa é o argv[0] e, se eu não passar nenhum argumento adicional, argc será 1. A função atof converte a string para um número de ponto flutuante e retorna 0 se não for possivel converter.

Simples, não? Agora vamos executar:

$ ./a.out 
Faltando Argumentos!
Uso: ./a.out x1 [ x2 .. xN ]
$ echo $?
1
$ ./a.out 1 2 3 4 5
A soma dos numeros eh 15
$ echo $?
0


A mensagem de uso utiliza uma notação no manual de alguns programas do mundo unix: colocar os argumentos opcionais entre colchetes. Eu informo que preciso de pelo menos um argumento. Caso eu entre no fluxo de excessão, o meu main retorna um valor diferente de 0 para o sistema operacional que pode ser capturado pela variavel de ambiente $? (nesse caso estou em um linux utilizando o bash, em outros sistemas mais exotéricos como o Windows eu não imagino como vc poderia capturar essa informação, tampouco imagino se ela seria util).

Perceba que eu posso criar um script extremamente simples para utilizar esse programa, assim como testar o resultado é uma tarefa de um grep (ou diff). Eu poderia juntar um script de teste e um makefile nesse post mas estou esperando um exemplo um pouco mais interessante.

Eu criei um programa sucinto, facil de entender e muito util, sem ter que perguntar para o usuario nada. transformar esse programa num que calcula a média, por exemplo, é uma tarefa de colocar apenas uma linha (na verdade uma subtração e uma divisão) a mais. Espero que os programadores novatos se inspirem nessa forma de pensar e que utilizem os programas básicos do unix como o grep, cat, diff, cp, etc, para seus futuros trabalhos.
Comments


Felipe

Aguardando....

OFF: As mentiras de ontem forma muito engraçadas, a do Java mesmo :-)


Tiago Peczenyj

Felipem, o GDB por si só precisaria de um post exclusivo. Tenho que pensar bem no exemplo para que seja util.

Estou pensando num algoritmo de ordenação com algum errinho, ou algum processo recursivo como calcular fibonacci, etc.


Felipe

Poucos sabem o que é um UNIX. Programam no DOS usando um while(1) para não fechar a tela do DOS, não sabem nem ir no cmd e digitar o nome do programa, eles clicam no executável.

O C é uma linaguagem que os programadores mais comuns não sabem/se interessam. Ler o TCPL sem entender o que é um wc, grep, sort... é IMHO impossível.

Aguardo os posts sobre getopt e GDB(ah sim GDB não está na lista de "promessas", mas vai ter, vai?)


Tiago Peczenyj

Duas coisas que esqueci de comentar: 

1) As mensagens de erro vão para a saida de erro (stderr)

2) A mensagem "A soma dos numeros eh " é totalmente desnecessária. Inclusive seria mais sucinto se a resposta fosse apenas o valor numérico.

fica para a proxima então: scripts de teste, makefile, getopt (posso querer utilizar uma opção -v [verbose]) e, se der tempo, localização!




Java 1.7 vai ter Ponteiros!!!
Tue, 01 Apr 2008 19:28:00 -0300

Sensacional.

Um dos recursos mais uteis do C finalmente conquistou o mundo java: a notação de ponteiros do Kernighan & Ritchie.

public class Example{
 public static void main(String [] args){
 int *x, y=0;
 x = &y;
 System.out.println("O valor de x eh " + *x);
 }
}

Agora será possivel fazer, em java:

- Passar primitivos por referência.
- Usar malloc, realloc e free.
- Utilizar ponteiros void para converter uma URL em String, ou um Throwable em um List.
- Sem falar que as Strings terão um caracter a mais no fim: o famoso \0 (na verdade a classe String deve desaparecer no Java 1.8, sendo substituida pelo bom e velho array de char)

Parabéns Sun!
Comments


Tiago Peczenyj

É claudemiro, vc deveria observar a data que eu postei essa mensagem :)


Claudemiro

cadê a fonte disso? cara sinto muito mas acho que isso não vai acontecer. e para o tiago stos. C sempre tera ponteiros. os ponteiros são um dos recursos mais importantes da linguagem c.


Tiago Peczenyj

Sinto falta de um eval() no Java.

eval("variavel" +i + " = " + j);


tiago_stos

Estranho observar essas mudanças nas linguagens. Ainda hoje ouvi dizer que na próxima versão do gcc a linguagem C não usará mais ponteiros, isso para fascilitar o aprendizado e aumentar o número de programadores C...


Claudio Rodrigues

Sinto a falta de métodos destrutores.




WhiteSpace Server Pages
Tue, 01 Apr 2008 18:59:00 -0300

E... para completar o dia: 
<?WhiteSpace
Say hello. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

 

 




 
 
 

 
 
 
 
 
 
 
 
 
 

 
 

 


 

 
 
 
 
 
 
 
 
 

 
 
 
 

 
 

 
 
 
 

 
 
 
 
 
 
 
?>


Novas Tecnologias .Net
Tue, 01 Apr 2008 18:51:00 -0300

A Microsoft resolveu contra-atacar a proposta da SUN com o FSP que, de uma tacada só, 6 novas linguagens no mundo dot NET: vejam exemplos dos novissimos ABAP .Net, ASM .Net, BrainFuck .Net, JCL .Net e VHDL .Net.

Para a parte web, vc poderá utilizar qualquer uma destas linguagens. Todas serão compiladas para CLI pelo ISS. A nova tecnologia permite, inclusive, rodar um .BAT, veja os exemplos abaixo!

<?ABAP
 REPORT ZHB00001.
 WRITE: 'Hello world'.
?>


<?ASM
 SECTION .data

 msg db "Hello, world!",0xa ; 
 len equ $ - msg

 SECTION .text
 global main

main:
 mov eax,4 
 mov ebx,1 
 mov ecx,msg
 mov edx,len 
 int 0x80

 mov eax,1
 mov ebx,0 
 int 0x80
?>


<?BRAINFUCK
 ++++++++++[>+++++++>++++++++++>+++<<<-]>++.>+.+++++++
 ..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.
?>


<?MSDOS
 @ECHO OFF
 REM Hello World for DOS batch

 ECHO Hello World!
?>


<?JCL
 //HERIB JOB ,'HERIBERT OTTEN',PRTY=12
 //* Hello World for MVS
 //HALLO EXEC PGM=IEBGENER
 //SYSPRINT DD SYSOUT=*
 //SYSUT2 DD SYSOUT=T
 //SYSUT1 DD *
 Hello World!
 /*
 //
?>


<?VHDL
 ENTITY helloworld IS
 END helloworld;

 ARCHITECTURE hw OF helloworld IS

 BEGIN

 ASSERT FALSE
 REPORT "HELLO, WORLD!"
 SEVERITY NOTE;

 END hw;
?>


Essa microsoft...


FSP - Fortran Server Pages!
Tue, 01 Apr 2008 11:21:00 -0300

Sensacional.

A SUN está ressucitando uma das mais velozes linguagens de todos os tempos. Uma nova tecnologia web foi anunciada hoje: Fortran Server Pages!


<?FORTRAN
*
C Hello World in Fortran 77
C (lines must be 6 characters indented)
*
 PROGRAM HELLOW
 WRITE(UNIT=*, FMT=*) 'Hello World'
 END
?>


A ideia é atingir um novo patamar em sistemas web.

Fonte: Google
Comments


Marcelo Martins

Boa cara. Já encomendei meus livros de Fortran. Não posso ficar fora dessa.




Hackeando um Hello World com sed
Fri, 28 Mar 2008 17:55:00 -0300

Fantástico o que o sed pode fazer!

$ cat a.c
main(){ 
 puts("hello world"); 
}
$ gcc a.c
$ ./a.out 
hello world
$ sed -i 's/hello world/_ola mundo_/'./a.out 
$ ./a.out 
_ola mundo_


A internacionalização do Engodo (2)
Wed, 12 Mar 2008 14:37:00 -0300

Excelente artigo do Olavo de Carvalho:

A internacionalização do Engodo (2)
Comments


La Batalema Pitonisto

Gostei do texto, só achei um tanto tendencioso.

Enquanto realmente muitas reclamações contra o filme veem de esquerdistas alienados, fãs das FARCs e de ONGs corruptas, o artigo peca pelo exagero na direção contrária, claramente fascista e contra a ação das ONGs.

Se alguém vai comentar sobre esses assuntos não precisa concordar com as FARCs, mas precisa entender sua existência; não precisa achar que toda ONG é boazinha, mas julgar todas por algumas é um erro similar.

Mesmo a atual postura direitista contra as drogas é tendenciosa e prejudicial ao bem comum.

Para opinar sobre qualquer assunto é preciso avaliar o máximo de variáveis envolvidas possível e tentar entender todos os lados – veja bem, entender, não concordar. Assim como o sr. Foley foi tendencioso contra o filme, o Olavo foi tendencioso a favor do facismo.

[]'s
Cacilhas, La Batalema


La Batalema Pitonisto

Gostei do texto, só achei um tanto tendencioso.

Enquanto realmente muitas reclamações contra o filme veem de esquerdistas alienados, fãs das FARCs e de ONGs corruptas, o artigo peca pelo exagero na direção contrária, claramente fascista e contra a ação das ONGs.

Se alguém vai comentar sobre esses assuntos não precisa concordar com as FARCs, mas precisa entender sua existência; não precisa achar que toda ONG é boazinha, mas julgar todas por algumas é um erro similar.

Mesmo a atual postura direitista contra as drogas é tendenciosa e prejudicial ao bem comum.

Para opinar sobre qualquer assunto é preciso avaliar o máximo de variáveis envolvidas possível e tentar entender todos os lados – veja bem, entender, não concordar. Assim como o sr. Foley foi tendencioso contra o filme, o Olavo foi tendencioso a favor do facismo.

[]'s
Cacilhas, La Batalema


Tiago Peczenyj

A beleza da democracia é poder concordar com ele :)


Andre Almeida

Será que ele vai juntando várias besteiras pra por tudo junto num artigo só?
Porque pra conseguir dizer tanta besteira junta só se esforçando, e muito!




Pra bom entendedor...
Mon, 10 Mar 2008 14:07:00 -0300



Fonte: http://xkcd.com/378/
Comments


Antonio Carlos Silveira

Excelente :-) o Phillip deve se identificar bem com esta tira




Projeto reconhece profissões de TI
Fri, 07 Mar 2008 19:14:00 -0300

Projeto reconhece profissões de TI, mas exclui criação de conselhos

Fonte: TI Inside

A Comissão de Ciência, Tecnologia, Inovação, Comunicação e Informática (CCT) do Senado aprovou, nesta quarta-feira (5/3), parecer favorável do senador Eduardo Azeredo (PSDB-MG) ao projeto de lei que regulamenta o exercício das profissões de analista de sistemas e técnico de informática. A proposta é de autoria do senador Expedito Júnior (PR-RO) e agora será encaminhada à Comissão de Assuntos Sociais (CAS), na qual receberá decisão terminativa.
(...)
De acordo com a proposta, a profissão de analista de sistemas somente poderá ser exercida por pessoas que possuam diploma de nível superior em análise de sistemas, ciência da computação ou processamento de dados.


Sem comentários...
Comments


[OsR]_fuckyou

estou fazendo sistemas de informação quando me formar não poderei ser contratado como analista? Serei apenas um programador? putz animador.


[OsR]_fuckyou

estou fazendo sistemas de informação quando me formar não poderei ser contratado como analista? Serei apenas um programador? putz animador.


Guilherme

blpsilva, eu passei por exatamente o mesmo problema (inclusive na mesma empresa...). E além da anuidade do CREA, tinha que pagar a contribuição sindical, mesmo contratado como analista. Um absurdo.


blpsilva

Como inúmeras pessoas da área não tem formação nessa área, acredito que isto só vai gerar novas derivações de ocupações. Em vez de "Analista de Sistemas", "Analista de XYZ", e vida que segue.

Eu cursei Engenharia Eletrônica e de Computação, e mesmo sendo um curso próximo de Ciência da Computação, não sei como ficaria isso legalmente.

Por outro lado, já vi coisas bem revoltantes ocorrendo com Engenharia, que já tem regulamentação há uns bons anos. Um amigo meu da faculdade fazia estágio na Embratel, que exigiu dele o CREA para efetivá-lo. Entretanto, em vez de registrá-lo como Engenheiro Eletrônico (e pagar o piso da época, de R$ 3500 CLT), efetivaram ele como Analista (sei lá de quê) e o salário era de menos de R$ 2500. Isso eu acho um absurdo. Exigir CREA, mas não contratar como Engenheiro pra mim é picaretagem.

Por essas e outras acho que essa regulamentação da profissão não terá impactos tão profundos na profissão pelo menos por uns bons anos.

Abraços,

Bruno Pereira


Guilherme

Shame....




Sobre o "ensino" de Java hoje em dia.
Thu, 06 Mar 2008 08:22:00 -0300

Java é uma linguagem orientada a objetos que contem tipos primitivos e wrappers para estes tipos, é executada sobre uma maquina virtual, com suporte a herança simples mas possui interfaces, com mecanismos de sobreescrita e sobrecarga de métodos, com um sistema de tratamento de exceções que te obriga a tratar determinadas situações e por ai vai.

Ao meu ver o estudo da linguagem deveria focar o domínio do mecanismo de herança e a construção de classes, domínio dos métodos, tipos de retorno, escopos de variavel, conversão de tipos, domínio das estruturas condicionais, de loops e de tratamento de erros, domínio das operações matemáticas e lógicas e,principalmente, domínio da classe String (ok, domínio pode ser uma palavra forte, talvez uma boa noção fosse suficiente em algumas situações).

Com disso tudo, o aluno deveria primeiro trabalhar com argumentos de linha de comando (o que vc acha que o main recebe?), depois passar a estudar a leitura e escrita em arquivo texto e, por fim, leitura pela entrada padrão.

Pois leitura pela entrada padrão é o que vc menos vai fazer em Java. Ninguem faz programa com menuzinho em Java pra console no mercado. Temos coisas mais complexas pela frente e sem conhecer tudo aquilo que eu listei antes só é possivel fazer gambiarras (como as famosas class functions, gigantescos métodos que fazem centenas de coisas com nomes adequados do tipo createTree3).

Ensina-se Java ao contrário: primeiro o camarada programa como se fosse C, perdendo tempo em fazer menus e estruturas de controle pois o usuario pode ter dado um enter, tab, "ç" ou ter digitado algo inválido quando deveria aprender os fundamentos da linguagem. Cria-se vícios que pode ser custoso para remover (como encher o código de getters/setters sem necessidade). A prova disso é que invariavelmente temos comparação de Strings usando o operador == quando deveria ser utilizado os métodos adequados para isso (imagina o susto quando a galera descobre o equalsIgnoreCase).

Eu vejo muitos estudantes incapazes de compilar e executar uma classe (o famoso hello world) pois os mesmos nunca fizeram uso da linha de comando muito menos foram apresentados ao conceito de classpath. Vejo barbaridades típicas de quem não conhece (ou não sabe ler) o javadoc das classes básicas. Fico me perguntando quando esses jovens serão capazes de ler um "Effective Java", por exemplo.

Aqui tem um excelente começo.

Espero que os professores acordem para essa realidade e que os alunos percebam que estão sendo prejudicados e passem a estudar por sua conta os tópicos necessários para sair arrasando pro ai.
Comments


Guilherme

O problema é que esses tais sistemas distribuídos não existem em qualquer lugar como se fala, e as pessoas frequentemente usam objetos fantoches independente da situação. Os sistemas distribuídos acabaram virando uma "desculpa" para os "objetos burros" existirem...


paulo

tem tda razão ferhr, mas no caso do sistema distribuido estamos falando de Data Transfer Objects (DTOs). É o caso que é necessario o fantochismo (as vezes da ate pra colocar alguma funcionalidade neles... mas é raro)


ferhr

(aliás, todo problema gerado por quaisquer linguagens de programação é o abuso).


ferhr

Também vejo problemas com abuso. Neste caso, concordo plenamente.

Mas também não vejo problemas com certos fantochismos, principalmente quando você tem que tratar um objeto (ou seria neste caso "dados"?) em sistemas distribuídos ou usando duas, três linguagens diferentes.


Tiago Peczenyj

Ao invés de criar um objeto cheio de get/set desnecessário, poderiamos preparar interfaces fluentes, como no exemplo do Chapiewski.


paulo

o problema está escrito la, chegou a ler o post? Voce deixa de programar orientado a objetos pra programar estruturado.

value objects nunca precisaram obrigatoriamente de getters e setters. alias, value objects imutaveis sao muito mais interessantes.

getters e setters não fazem encapsulamento por si só, isso é uma ilusão! as vezes muito pelo contrario: voce acaba expondo atributos que nao deveria expor: deveria ter criado métodos para trabalhar com esses atributos, em vez de apenas fornecer um simples par de getter e setter. Esse é o mais que conhecido anti pattern do dominio de modelo anemico:

http://www.guj.com.br/posts/list/75388.java

Seus objetos acabam virando fantoches:
http://www.fragmental.com.br/wiki/index.php?title=Fantoches

Em nenhum momento falei para nunca utilizar getter e setters, o problema é seu abuso. quem vem de linguagem estruturada e esta comecando com orientacao a objetos, costuma abusar demais disso, deixando seu sistema identico a um nao orientado a objetos.


ferhr

> fehr, usar getters e setters gerados, como 
> voce falou, é muito perigoso e pode gerar
> um dominio muito fraco. os objetos podem
> passar a ser apenas estruturinhas de dados:

ValueObjects / encapsulação, anyone? E qual o problema de alguns objetos serem apenas "estruturinhas de dados"? Nenhum. Depende da aplicação, da idéia. Não há bala de prata.


paulo

Oi Tiago! Agradeço o link para o blog da Caelum. Nos tentamos seguir essa linha de pensamento, focar no que é realmente importante: interfaces, polimorfismo, reescrita de método, encapsulamento. Alias, quando mostramos java.util e java.io, damos mais atencao para o bom uso das interfaces e polimorfismo desses pacotes do que a API em si. Saber fazer um bom design é o que é fundamental.

fehr, usar getters e setters gerados, como voce falou, é muito perigoso e pode gerar um dominio muito fraco. os objetos podem passar a ser apenas estruturinhas de dados:

http://blog.caelum.com.br/2006/09/14/nao-aprender-oo-getters-e-setters/

e atraves de reflection da sim para manipular os atributos, sem necessidade dos getter e setters, nao vejo reflection como motivacao para o uso dos getters e setters.


Daniel Wildt

Tiago, belo post. Eu vejo ser necessário ensinar o aluno que java não é dependente de uma IDE como ocorre com algumas outras linguagens de programação. Passo pelo menos 3 aulas trabalhando diretamente na linha de comando e usando um editor de texto sem sintax highlight. E desde o início trabalho identação de código fonte, organização de código fonte, enfim, o programador tem que entender a base do processo e tem que saber aplicar isto para qualquer outra linguagem de programação que venha a aprender.

Ainda, que você não precisa de uma IDE com 5000 plug-ins para ter produtividade. Deve achar o que te deixa produtivo, como disse o Vitor Pamplona.

E principalmente, focar no ensino de orientação a objetos. Criar classes, entender composição e herança, saber diferenciar uma classe abstrata de uma interface. Gosto de trabalhar todos os princípios para que um aluno possa ler um livro sobre design patterns e saber como construir aquilo, porque ele entende orientação a objetos, e não porque sabe java. 

Já vi aluno meu reclamar que não consegue aprender patterns porque o material que passei não era em java.

O Urubatan já falou em um post dele que aprender uma linguagem de programação deveria ser um processo rápido. Concordo com isto e no meu entendimento isto está relacionado a sua habilidade de abstração e de entender como as linguagens orientadas a objetos funcionam.

Eu aqui fico pensando em como estes profissionais que hoje tem problemas vão evoluir para novas linguagens de programação e assim manter a própria empregabilidade em alta.

Será culpa somente do aluno ou também é culpa do professor? 

Como professor, me considero um cara muito chato e deixo claro sempre para os alunos que não existe melhor linguagem de programação. Semestre passado em uma disciplina de desenvolvimento para web, ensinei ASP.NET, Java Server Faces e Ruby on Rails. Só que antes disto trabalhei muito o que envolve desenvolver para a internet.

Ufa, ficou longo o comentário... :-)


Ana Carolina

Oi Tiago.

Concordo totalmente contigo.
Trabalho com cursos e também disciplinas de cursos técnicos e sei que não adianta começar com a parte prática sem a parte teórica, e também não adianta o objetivo ser "conquistar o mundo", é com exemplos simples, mastigados e várias atividades que se consegue base para um bom profissional. Depois disso é que podemos aprofundar o assunto e abordar tópicos mais avançados.

Ah! E não é só Java.
Tenho muito aluno que vem dizendo que "eu sei trabalhar com banco de dados" e na verdade usou o Access e nem sabe o que é uma view.

Quando surge o incêndio, é a teoria que te ajuda. 

Se o aluno aprende primeiro "na mão", da forma mais trabalhosa e programando em modo texto, com certeza depois ele pode ir pra uma interface gráfica, mas o contrário não é verdadeiro.

Conheço um "professor" de Linguagem C que não sabia que um for() pode ser infinito heheheh 

Por esses problemas é que eu sou contra estes cursos muito curtos que ensinam "tudo" e não ensinam os fundamentos das coisas. 

É por essas e outras que quem trabalha com TI sofre tanto preconceito. Todos os anos vários "fabricantes de gambiarras" aparecem por aí (mas eles não tem muito sucesso, não se preocupe! heheheh)

Um forte abraço.

Ana Carolina 
http://anacarol.blog.br


ferhr

No início (bem no início, há mais de dez anos) via a questão dos getters/setters com muita desconfiança. 

No entanto é fácil de criá-los, nem que seja através de geração de código. 

Sem eles, entretanto, fica difícil fazer certas coisas com reflexão e afins.




Melhorando o “try()” do Ruby, a maneira “Groovy” [parte final]
Wed, 05 Mar 2008 18:21:00 -0300

class Omega
 def a
 self
 end
 def b
 self
 end
 def c
 self
 end
 def to_s
 "Omega"
 end
end

def da? 
 begin
 yield() if block_given?
 rescue => exc
 nil
 end
end

xyz = nil
a = da? { xyz.a.b.c } 

xyz = Omega.new
b = da? { xyz.a.b.c } 

puts "da? com nil -> '#{a}'"
puts "da? com Omega -> '#{b}'"


Executando:
da? com nil -> ''
da? com Omega -> 'Omega'


O que eu fiz? como a expressão xyz.a.b.c poderia retornar algum erro pois um dos métodos poderia returnar nil, bastaria executar em um bloco de código com a ajuda do método da? (péssimo nome, uma corruptela de "da para executar sem erro? se não, me retorna nil e era wilson...), que captura qualquer erro e some com ele.

Ruby é divertido. :)

ps: teste com

a = da? { xyz.a.b.c } || "nao deu..."


Melhorando o “try()” do Ruby, a maneira “Groovy” [parte 2]
Wed, 05 Mar 2008 15:32:00 -0300

Vou pedir perdão ao meu amigo Urubatan, que publicou um artigo de mesmo nome.

class Omega
 def doIt
 puts "ola"
 self
 end
end

class NullableClass
 def method_missing(*x)
 self
 end
end

class Object
 def existe?
 self
 end
end

class NilClass
 def existe? 
 NullableClass.new 
 end
end

xyz = Omega.new 
xyz . existe? . doIt . doIt

abc = nil
abc . existe? . doIt . doIt


Estou em duvida sobre o nome do metodo, por enquando fica existe? mesmo.

O que isso faz? Imagine que vc tem uma variavel ou atributo de classe que pode ser nil. Se for nil ela vai lançar um um erro em tempo de execução quando vc for tentar chamar algum método que a NilClass não possua (o que geralmente acontece, é semelhante ao NullPointerException do java).

Eu poderia resolver isso alterando o method_missing da NilClass, porém alguns scripts podem estar esperando erros desse tipo. Decidi então criar um método que, para qualquer objeto, retorna ele mesmo (self). Caso seja nil, ele vai retornar um NullableClass (outro nome infeliz, não tenho nenhuma ideia melhor) que simplesmente retorna ele para qq método requisitado.

IMHO pode ser o suficiente quando queremos fazer um teste simples: o objeto é nil? então não faz nada.

Se alguem achar isso util por favor me avise :)

Ah sim, a execução do script acima resulta em:
ola
ola
Comments


Urubatan

como eu disse quando tu postou este comentário no meu blog, este teu esquema não resolve o problema de aninhamento de objetos, por exemplo

@person.company.manager.name
se eu digitar
@person.existe?.company.manager.name 
e company for nil vai explodir tudo
e um .existe?. depois de cada objeto vai ficar gigante e pior do que o try na minha opinião :D




Escher em Lego
Wed, 27 Feb 2008 11:03:00 -0300

Sensacional:

Comments


Tiago Peczenyj

DCC?


Pesquisador

muito legal!
você é do dcc?

Trofia.com


Andre

Muuuuuuito bom...

Se publicar um passo-a-passo eu até compro lego pra fazer igual... :D


Felipe

Que nerdisse!!!




Alterando Multiplos Arquivos (versão final?)
Fri, 22 Feb 2008 19:27:00 -0300

O site Dicas-L trouxe na ultima semana 2 formas de renomear multiplos arquivos (aqui e aqui)

#Forma 1
for o in $(ls -1 *.txt); do
 mv $o $(echo $o | awk -F. '{print $1".htm"}');
done

#Forma 2
for i in `ls *.txt`; do
 mv $i $(echo `basename $i .txt`.html)
done

São ambas formas interessantes, porém ao meu ver consomem muito recursos da maquina, sem falar que são um tanto... feios... (nada contra - o que importa é que funcione)

Vou utiliza-los como exemplo de como podemos tornar algo melhor e mais prático (se o tempo permitir).

Vamos dividir as paradas:

altera() { mv $1 $(echo `basename $1 .txt`.html) ; }

for i in `ls *.txt`; do
 altera $i
done

Agora vamos tomar um cuidado: arquivos com espaço no nome

altera() { mv "$1" $(echo `basename "$1" .txt`.html) ; }

for i in `ls *.txt`; do
 altera "${i}"
done

Bom, o for pode iterar sobre uma lista de argumentos. As mascaras de nome de arquivo são expandidos pelo shell durante a execução, logo...

for i in *.txt ; do
 altera "${i}"
done

Agora, a rotina de alteração do nome do arquivo de destino é complicadissima, depende de um ou mais sub-processos. Isso poderia ser...

altera() { mv "$1" "${1%.txt}.html" ; }

Que, inserido no for...

for i in *.txt ; do
 mv "${i}" "${i%.txt}.html"
done

Interessante, certo? Nenhum sub-processo, exceto o inumeros mv que serão executados. Existem outras formas de fazer a mesma coisa

ls *.txt | awk -F. -v OFS=. '{ O=$0; $NF="html" ;printf "\"%s\" \"%s\"\n",O,$0 }' | xargs -n 2 mv

ls *.txt | sed 's#^\(.\+\)\.[^.]\+$#"&" "\1.html"#g' | xargs -n 2 mv 

(rodem as linhas acima sem o mv do xargs para entende-las -- é metaprogramação)

Agora... tudo isso é muito bonito mas... veja se o seu computador possui os comandos mmv ou rename (que facilitam Absurdamente a tarefa)

rename .txt .html *.txt

mmv "*.txt" "#1.html"

Simples, não?

Tudo depende do tempo que temos e das nossas necessidades. Mesmo que o rename/mmv sejam uteis, pode ser que a forma com awk / sed valha mais a pena pois o ls pode ser substituido por um find (ja pensou nisso?)
Comments


Leonardo Bernardes

Já conhecia o NF, depois de conhecê-lo queimei um pouco a cabeça tentando elaborar um método pra fazer essa passagem do 1 ao NF. Pensei em qualquer coisa semelhante ao while.. mas não veio nada.

Na verdade, Tiago, sou um belo amador, brinco de fazer scripts como terapia.. terapia que eu realizava aos montes na época de mIRC.

Por conta mesmo do meu amadorismo, não consegui entender seu exemplo de como queimar os registros intermediários. Mas não esquente com isso, se não há aquela variável mágica que eu usava no mIRC, é melhor que eu me contente com minhas limitações. Em todo caso, fico ligado nas suas dicas da seção shell.


Tiago Peczenyj

Ola Leonardo.

Infelizmente o gawk não tem o conceito de range. Quando vc utiliza o operador $X vc esta pegando o X-ésimo campo daquele registro. Vc tem uma variavel que é setada a cada registro que é NF, o numero de registros, que permite que vc leia o ultimo registro de forma simples

print $1,$NF

Agora... tem uma sacanagem que vc pode fazer: $0 é o registro inteiro, porém vc pode "queimar" alguns registros intermediarios

no seu caso, se vc fizesse

$3=$4=$5=$6=""
print $0

só sobraria o que vc quer.

Uma forma, menos agressiva, seria tentar pegar um padrão via expressões regulares.


Leonardo Bernardes

Tiago,

Você parece o sujeito certo pra esclarecer um dúvida:

Se eu quiser filtrar uma string do seguinte tipo

7718 0.0 0.0 1756 476 ? Ss 17:59 0:00 /bin/sh -c pidgin

Como AWK eu posso fazer através de algo como "awk '{print $1,$2,$10}'" 

Mas se eu quiser, por exemplo, filtrar o $1, o $2 e todos OS DEMAIS após o $7 sem saber o número total de termos, há alguma variável pra isso? Não sei se me fiz entender, mas essa dúvida me persegue desde que lembrei que quando eu brincava editando scripts no mIRC, uma simples $7- realizava essa função

Desculpe o abuso, abraços




Building Didier Stevens' SpiderMonkey in Cygwin
Sat, 02 Feb 2008 14:26:00 -0300

Eu estava quebrando a cabeça até que encontrei este post.

O Paul Melson ensinou de forma facil a compilar o SpiderMonkey para Cygwin: agora posso criar scripts usando javascript standalone.

Vantagem: Nenhuma, coisa de nerd :)


Twitter.sh versão 2.0
Wed, 30 Jan 2008 09:02:00 -0300

O Bruno me deu uma ótima sugestão: um simples usage.

Entretanto ontem eu fiquei batendo cabeça com os inúmeros tac/tail's mas percebi q um sed resolvia a questão. Alias é possivel também passar uma lista de parâmetros também!
#!/bin/bash
TWIURL=http://m.twitter.com # utilizando versão 'mobile' do twitter
USAGEMSG="Usage: $(basename $0) <twitter-user> [user list...]"

[ -z "$1" ] && { echo "${USAGEMSG}" ; exit 1 ; }
for i in "$@" ; do
 echo "==============================="
 links -dump "${TWIURL}/${i}" | sed -r '1,3d;/^\ +Older [0-9]+/,$d'
done

Agora chega :)
Comments


Tiago Peczenyj

Oi Paulo,

O Gabriel Stein me deu uma ótima ideia de como postar no twitter:

http://gabrielstein.org/?p=181

Estou pensando em fazer um script simples para ler e postar no twitter e isso pode evoluir para muita coisa :) Se quiser colaborar ou indicar como eu poderia divulgar mais, sinta-se à vontade.


Paulo Diovani

Script interessante.
Já pensou em fazer algum widget para desktop com ele? Ou quem sabe divulgar em alguma comunidade internacional para alguém fazê-lo.




Twitter + shell script
Tue, 29 Jan 2008 21:59:00 -0300

Como acessar o twitter a partir de um shell script de apenas 2 linhas? Fácil

#!/bin/bash
links -dump http://m.twitter.com/${1} | tac | sed -n '/\*/,$p' | tac | tail +2


Basta informar o username a ser impresso:

$./twitter.sh pac_man
 Twitter

 pac_man pac_man fogo controlado agora. about 1 hour ago

 Previous Updates
 * minha cozinha pegou fogo. about 4 hours ago
 * @gchapiewski To com a cuia, onde se compra a erva (mate)? about 9
 hours ago
 * @pcalcado alias XYZZY='echo -ne Zork!' about 16 hours ago
 * XYZZY about 16 hours ago
 * 4 horas pra montar um armario. Pelo menos jantei pizza. 08:36 PM
 January 28, 2008
 * Odeio fazer mudanc,a! Armario ainda nao ta pronto... 03:41 PM January
 28, 2008
 * Amanha chega a minha mudanc,a. Terei um pc finalmente. 07:41 PM
 January 27, 2008
 * Odeio limpar a areia dos gatos. 07:38 PM January 27, 2008
 * E ainda tenho q desmontar uma geladeira :/ 12:30 PM January 27, 2008


Não consegui fazer com que o links entenda o conjunto de caracteres correto mas... quebra um galho. Depois vou fazer um que submeta um post :)
Comments


aprendiz

Fiz algumas pequenas modificações pra ficar mais legal:

#!/bin/bash

if [ "$1" = "" ]; then
 echo "Usage: $0 < twitter-username >"
fi

links -dump http://m.twitter.com/${1} | tac | sed -n '/\*/,$p' | tac | tail -n +2

adicionei o Usage, pra daqui uns 6 meses eu nao precisar abrir pra ver o que faz :P

e também adicionei ao tail o -n +number pq tail +number ta deprecated na minha versao do tail.

Abraços,
Bruno Carvalho

PS: Aguardamos sua primeira aparição aqui na globo.com ! Bem vindo a equipe :)




Nada de muito novo.
Mon, 28 Jan 2008 20:27:00 -0300

A mudança chegou hoje. Sexta começa a labuta, até lá tem muita coisa pra desencaixotar.
Comments


Thadeu Penna

Tsc, tsc, tsc, ainda é gaúcho. O cara se muda para o Rio e acha que vai começar a trabalhar na sexta-feira de Carnaval :D))) Nem entrou no clima...




Enquanto isso, no RJ
Sun, 20 Jan 2008 15:15:00 -0300

Depois de uma semana turbulenta cheguei vivo ao RJ, e continuo até agora.

Não tenho muitas novidades além do calos e da ansiedade - e estou sem PC em casa. 

Logo terei novidades.
Comments


J. F. Mitre

Eu não sei como lhe dizer isso, meu caro, então vou direto ao ponto: estamos em clima de outono aqui no Rio...

Calor fez nos últimos 15 dias de dezembro passado (que chegou a 42 graus). Agora está suave, não tem nem chego a 40 graus...




Centésimo Post: Uma novidade!
Wed, 09 Jan 2008 19:59:00 -0300

Um dia eu estava conferindo os sites e blogs do meu bookmark quando vi este post. Fiquei impressionado como tanta coisa fez sentido pra mim.

Eu era só um test developer que tinha começado como testador lá em são leopoldo. Vi sistemas serem feitos de todas as formas, principalmente as erradas. E tive amigos que diziam "isso não se faz mais, hoje em dia se usa hibernate/struts/webwork/...", q coisa não? 

Voltando a vaca fria, fui lendo os posts e artigos do Phillip Calçado - assim como os seus posts no GUJ - e fui acordado para a minha verdadeira vocação: programar. Mas quando li este post eu criei coragem e enviei um email, extremamente humilde, perguntando o que eu poderia estudar para não fazer feio em uma entrevista na globo.com , afinal eu sabia das minhas limitações e, naquela época, eu estava pensando em tentar a vida lá.

Phillip foi super-simpático e conseguiu uma entrevista por telefone. Foi um terror, não estava preparado, eu só queria ter uma idéia, naquela época, do que estudar para conseguir sair da minha função mais reativa, para uma função ativa (o ato de desenvolver o software em si com qualidade e ter orgulho disso). Mas não desisti.

Nas minhas férias eu tive 3 entrevistas na globo.com, sendo a última no sábado pela manhã (eu ia voltar para Poa no domingo). Valeu a pena, quando o telefone tocou e o Guilherme disse "e ai, pacman?" eu gelei.

Tinha sido aceito no grupo mais louco e fera que eu já conheci (e olha que eu ja trabalhei com o Porto e com o Casantos). Fui super humilde em todos os momentos, cheguei a acreditar que não iria conseguir em muitos momentos, mas aconteceu.

Pena que o Phillip foi para Melbourne, queria te-lo conhecido pessoalmente. Por outro lado, eu sempre poderei ler os seus blogs e posts e poderei contribuir no trabalho que ele começou na WebMedia.

Tenho que agradecer a muitas pessoas: Marujo, Marlon, Fernando, James, Marcelo Martins, a galera da HP que me atura a mais de 3 anos e a todos os loucos que me mandam parabéns pelo orkut ou gtalk e que vou sentir falta.

"Trabalhar na Barra da Tijuca, ruim né?"

Poucos sabem das reais dificuldades que eu enfrentei pra chegar ao dia de hoje. E não vou deixar de ser quem eu sou, amigos. Quando ao emprego que eu já tinha conseguido, eu tive que recusar gentilmente.

2008 promete :)
Comments


RIC@RDO

"...(e olha que eu ja trabalhei com o Porto e com o Casantos)..."

hahahahahahahahaha
Essa foi pra matar Peczenyj!!!!
E os vovôs continuam aqui aprontando das suas... :P

Abraço amigo!


Tiago Peczenyj

Marcelo,

Essa resposta eu estou esperando do Phillip até hoje. Entretanto o Guilherme Chapiewski me deu algumas boas sugestões, basicamente livros sobre Agile e Domain Design Driven.


Marcelo

Olá,

Também cheguei até o seu blog através do Fragmental. Fiquei muito curioso em saber qual foi a resposta do Phillip Calçado sobre o que se deve estudar para não fazer feio em uma entrevista na Globo.com.

Parabéns pela conquista

Marcelo


Tiago Albineli Motta

Seja bem vindo a equipe pacman!


Luis Eduardo Bohrer da Silva

Gostaria de dar os parabéns Peczenyj.
Também cheguei aqui, através do framental.

Via seus comentários no GUJ mas não sabia que éramos conterrâneos, mas agora já está indo embora.
Enfim parabéns pelo esforço, pois tudo isso é fruto dele.
Estarei acompanhando o Blog.
Valeu.


Roger

Parabéns Peczenyj !
Quando comecei a ler o post e vi as referências a posts do Fragmental, GC ... já pensei: "Não acredito que o cara conseguiu um trampo lá !"
O ambiente lá parece ser muito legal, eu também sonho com uma oportunidade dessas, se por acaso souber de algum lugar desse em Sampa mando meu cv na hora. Enquanto isso continuo estudando "coisas inúteis" como TDD, Scrum, XP, DSLs, Ruby ... etc. mesmo sabendo que onde estou nunca vou usar. :-(
Por sinal acompanho o blog do gc também! Muito bom.

Sucesso pra ti merrmão (carioques fluente!)

Roger Leite




Coisas que eu gostaria de ter escutado antes.
Mon, 07 Jan 2008 16:51:00 -0300

Tive a (in)felicidade de escolher, no ano de 98, ingressar no curso de Física da UFRGS. Na época eu era Nerd e não entendia nada da vida, afinal eu era um adolescente, achei que estava fazendo a coisa certa.

Dizem que é melhor que a gente se arrependa por algo que fez do que por algo que a gente não fez. Durante o meu curso, optei pelo Bacharelado (um dos cursos mais dífíceis da UFRGS inteira), acreditando que este seria o meu futuro.

Não posso reclamar: tive contato com excelentes professores e ótimos amigos. Conheci o Linux, o Fortran, o Matlab, o Método de Monte Carlo, as Equações Diferenciais e o Cálculo Numérico (sem falar na Mecânica Estatística, no Claudio Schneider,...) e conheci a reprovação, os conceitos 'C' e um primeiro A (em Algoritmos e Programação - onde aprendi Pascal e praticava em um potente 286 com 1 mega de ram).

Graças ao professor Daniel Stariolo tive 3 anos de bolsas de iniciação científica com programação em C. Por intermédio do destino, o Daniel esqueceu de renovar a minha bolsa e precisei procurar emprego para sobreviver.

Este foi o impulso que eu precisava: consegui um emprego na área de testes. Com pouca experiência mas muita nerdisse, comecei na CWI a procurar defeitos nos programas dos outros.

As vezes precisamos acordar: estar dentro de um curso de graduação, principalmente no curso errado, limita um pouco a nossa visão do mundo. A nossa vontade de encontrar um grupo social nos faz crer que estamos fazer o que é certo e que estamos felizes (ou não estamos triste demais).

Coisas que eu gostaria de ter escutado antes:

- Leia muitos e diferentes livros
- Aprenda Inglês (ao ponto de falar bem ao telefone)
- Se tiver a chance: Aprenda a Dirigir. Dane-se que vc não tem carro
- Trate o seu currículo e a sua carreira com respeito
- Aprenda Java, Python, Ruby, Shell, AWK, HTML, C++, LISP, SQL...
- Aprenda BEM e pratique muito.
- Tenha Amizades positivas (do tipo que vão trabalhar com o que vc quer, que pensam parecido com vc, que te ajudem e sejam ajudados por ti).
E o principal,
- Faculdade é parte da nossa carreira. Se vc não estuda diariamente, se vc não se atualiza, se vc não se esforça, vc está perdendo tempo. Mude alguma coisa e não tenha medo de ousar: melhor do que estar a 9 anos no mesmo curso e ficar apatico com perguntas do tipo "não vai te formar?".

Sim, jovens que estão prestando vestibular ou que estão pensando no que fazer ainda, o mundo é cruel e complexo. A melhor maneira de se adaptar ao mundo chamado "Brasil País de Terceiro Mundo" é tenho conhecimento amplo, variado e capaz de gerar mais conhecimento - evitando conhecimentos do tipo 'paranóicos' e 'fanatistas'. 

Quando eu nasci o Brasil era uma ditadura. Meu avô era membro do PC-do-B, já podem imaginar. Eu lembro que ele escutava a Radio de Moscou (na programação de 2 horas em português) todo o dia e acreditava em tudo. Um dia o muro de Berlin caiu... e o mundo pode ver a quantidade de casas sem agua potável ou esgoto na antiga URSS, por exemplo. Tivemos o Collor, o FHC e, agora, o Lula. O Mundo muda, o Brasil mudou. Quem se dedicar a uma vida mais limitada sofrerá com as mudanças futuras e necessárias para que possamos alcançar um bom padrão de vida - ou vai sofrer ao se adaptar a um país melhor lá fora.

Pensem. Leiam. Tenham bons amigos e tenham boas conversas. Se informem diariamente e não fiquem mantendo as mesmas ideias por muito tempo: é necessário fluidez.

E fluidez não se ensina, se aprende aos poucos.

Quem estiver em dúvida sobre o que fazer, seja na vida acadêmica, na carreira profissional ou na vida amorosa, opte por procurar diferentes fontes de informação, dê atenção as fontes de melhor qualidade, raciocine e faça uma escolha - tendo a responsabilidade de arcar com o escolhido.

E se preparem para errar. Só acerta muito quem erra bastante.

Pronto, acabou a sessão "auto-ajuda" de hoje. Não vou prometer que dinheiro é encontrado no Vaso Sanitário ou que o Brócolis torna a Vida mais Feliz. Aliás a felicidade é algo passageiro e momentâneo, o resto das nossas vidas é desprovido de felicidade. É interessante pensar nisso pois precisamos encarar a verdade: o mundo é chato, é feio, é fedido, é cheio de gente que não presta e ainda podemos levar uma bala perdida devido a um debil mental que usa revolver para comemorar o fim de ano. Teremos pouquissimos momentos realmente felizes na nossa vida e são esses momentos que valem a pena.

Um abraço e espero que faça sentido para alguem :)

Feliz 2008!

Ps: é normal rodar em Cálculo I a primeira vez que se faz. Acredite.
Comments


Tiago Peczenyj

Thadeus, o seu comentário só enriquece o que tentei passar: em dados momentos vamos sentir que fizemos escolhas erradas. É momentâneo, afinal até as piores escolhas nos moldam no que somos hoje.


Thadeu Penna

Eu também mudei, apesar de não ter saído da Física: era físico nuclear experimental, conheci a computação e fui para a física computacional. Hoje trabalho em projetos interdisciplinares com engenheiros, médicos e até computeiros.
O seu post é uma experiência pessoal, daí eu não posso dizer o que é certo ou errado, apenas dizer o que concordo ou não. Nossos casos são semelhantes, de certa forma, e eu acho que se não fôssemos físicos não conseguiríamos transitar de uma área para a outra, com tanta facilidade. É fácil ver físicos trabalhando em computação, economia e finanças, etc. (eu mesmo já orientei alguns alunos que hoje estão nestas áreas). Daí eu não concordo que você tenha escolhido "o curso errado", pelo contrário, você escolheu o curso que permite mudar de idéia, área, etc. e perder menos com isso e, talvez, até ser um diferencial em relação aos formandos tradicionais. 

[]s


trbecker

Hah, eu passei de primeira em cálculo 1, e isso é estranho. Mas em cálculo 2 eu penei, levei 4 semestres para aprender a visualizar certas equações em espaços de 3 dimensões. E cálculo 2 é quase só isso.


Guilherme

Aliás a felicidade é algo passageiro e momentâneo, o resto das nossas vidas é desprovido de felicidade. É interessante pensar nisso pois precisamos encarar a verdade: o mundo é chato, é feio, é fedido, é cheio de gente que não presta e ainda podemos levar uma bala perdida devido a um debil mental que usa revolver para comemorar o fim de ano. Teremos pouquissimos momentos realmente felizes na nossa vida e são esses momentos que valem a pena.

Rapaz, até que enfim encontrei alguém que pensa assim como eu - e tem coragem de dizer abertamente sem ser tachado de "pessimista" ou "prá baixo", etc.

Ps: é normal rodar em Cálculo I a primeira vez que se faz. Acredite.

Que ótimo, me sinto normal agora. Estava achando que era falta de inteligência minha. :-)


Camila Peczenyj

Eu já tinha te dito, mais de uma vez, para tirar a carteira de motorista e o vô era filiado ao PSB. 
Nunca é tarde para recomeçar, isso eu tb já tinha te dito...
Gostei do texto e ele é cheio de verdades, só espero que vc o siga.
BJ
Camila


Julli

Finalmente eu vejo que você percebeu muita coisa que eu já te falava há tempos. :)
Agora é a minha vez. Beijo, te amo.


Felipe

Ótimo texto, ultimamente tenho visto como isso de ler muitos livros é importante.

Dois livros que estou lendo:
Getting Real(37signals) e
A estrada do futuro(Bill Gates, 1995)

Os 2 falam(dentre outras coisa)justamente da capacidade que a pessoa e/ou empresa deve ter para mudar rapidamente as opiniões/idéias/produtos.




Pra bom entendedor...
Sun, 06 Jan 2008 16:11:00 -0300




Coisas boas do Rio de Janeiro
Thu, 03 Jan 2008 18:56:00 -0300

Porto Alegre tem coisas boas (chimarrão, redenção, xis do cavanhas, suco da lancheria do parque, gasômetro e polar).

Entretanto o Rio de Janeiro me impressiona cada vez mais. A imensa variedade de sabores (na mesma quadra vc encontra culinária nordestina, frutos do mar, empadas, picanha, sushi e muito, mas muito chopp), as praias, os recantos escondidos (como grumari), a floresta da tijuca, o jardim botânico, a imensa atividade (em TODO o lugar tem algo acontecendo, a qualquer hora).

Fora o Calor...

A personalidade do carioca é um tanto diferente da gaúcha. Falta a estética do frio, o que ja era de se esperar.

Domingo volto pra porto alegre, algumas despedidas irão rolar. Até la estou juntando alguns assuntos nerds para postar aqui :)
Comments


Erlon

tu ve... eu odiei e odeio o Rio de Janeiro e alguns outros estados do país!




Peczenyj agora é cidadão carioca
Mon, 24 Dec 2007 12:47:00 -0300

Pois é...

Depois de muitas considerações decidi encarar o desafio de me mudar de Porto Alegre para o Rio de Janeiro. Facil não é, tampouco barato.

Recebi uma proposta irrecusável de uma empresa para trabalhar com o middleware de Tv Digital. Vai envolver muitos testes automatizados, java, lua, C, desafios novos, cidade nova, enfim, muita coisa boa. Logo vou postar umas coisas que eu ando aprontando aqui...
Comments


Roger

Olá Peczenyj !
Acompanho o blog de vez em quando, fiquei curioso. Como surgiu esta oportunidade ? Você fica em busca sempre sem compromisso e por indicação ?

De qualquer maneira parabéns !
sucesso!

Roger Leite


Tiago Peczenyj

Middleware ou mediador, no campo de computação distribuída, é um programa de computador que faz a mediação entre outros softwares. É utilizado para mover informações entre programas ocultando do programador diferenças de protocolos de comunicação, plataformas e dependências do sistema operacional.

Mais aqui...

No caso da TV Digital eu ainda vou descobrir o que ele faz.


Felipe

Nome:philix(GDH)

O que o middleware de TV digital? :-?




No Rio
Tue, 18 Dec 2007 19:06:00 -0300

3 dias de viagens seguidos. Foi cansativo.

Sábado saimos de Poa para chegar, 9 horas depois, em Curitiba. Muitos desvios na estrada, duas gatas berrando de vez em quando, sol e fome. Chegando, fomos numa churrascaria muito boa chamada Per Tutti e dormimos.

Domingo chegamos em São Paulo - a estrada para lá é hedionda. Depois de descansar um pouco, fomos numa 'lancheria' chamada Fifties, muito boa. Depois tomei um café expresso e dormimos.

Segunda chegamos no Rio. Depois de enfrentar um longo caminho, foi um alívio passar pela Serra das Araras e chegar à cidade. Deixamos nossas duas gatas na avó da Juliana e viemos pra casa, na Tijuca.

Hoje o dia foi cheio, andei um bom pedaço do centro do Rio, andei de metrô, tive conversas interessantes... quinta vou beber com o pessoal do MBB em lugar secreto, até lá terei alguma coisa boa para comemorar (alem de estar na cidade magavilhosa).

Quarta é o dia...


Ferias
Fri, 14 Dec 2007 21:24:00 -0300

Estou saindo de férias, quando tiver novidades irei postar :)


Testes Unitários com VBScript
Mon, 03 Dec 2007 12:49:00 -0300

Nas ultimas semanas, tive que aprender VBScript por conta de alguns testes que estão por vir. A sintaxe é bem estranha, mas fazer o que...

Entretanto é simples o suficiente para se desenvolver pequenas rotinas e, de quebra, aprender boas praticas de programação, como TDD, no exemplo abaixo:

' Função a ser testada
' EhPrimo determina se um determinado número inteiro é primo ou não
Function EhPrimo(numero)
 '
 'coloque o codigo aqui :)
 '
 EhPrimo=false ' so pra retornar algo...
End Function

'Coloquei o nome Test para ficar mais facil :)
Sub Test( objQuery, strMessage ) 
 If Not objQuery Then
 WScript.Echo VbCrlf & "ERRO: " & strMessage
 WScript.Quit 'no primeiro teste errado...
 End If
End Sub

' Testando primos
Primos = array(2,3,5,7,11)
For Each Numero In Primos
 Test EhPrimo(Numero),"Numero " & Numero & " deve ser primo!"
Next

' Testando _nao_ primos
NaoPrimos = array(4,6,8,9,10)
For Each Numero In NaoPrimos
 Test (Not EhPrimo(Numero)),"Numero " & Numero & " NAO deve ser primo!"
Next

' Testando outras coisas
Test (Not EhPrimo( 0)),"Numero 0 NAO deve ser primo!"
Test (Not EhPrimo( 1)),"Numero 1 NAO deve ser primo!"
Test (Not EhPrimo(-1)),"Numero -1 NAO deve ser primo!"


WScript.Echo VbCrlf & "Pronto, passou tudo!"


Pronto, agora 

Qual a vantagem dessa abordagem?
 1) vc se obriga a testar o seu código 
 2) vc descobre quais parametros são uteis nas suas funções
 3) vc especifica o comportamento das suas funções ANTES de implementa-la:)
Comments


NetWalker

Paranóia minha, mas código VB sempre me pareceu como um texto que abriu com erros... :D




Evento Tchelinux nesse Sábado
Wed, 28 Nov 2007 13:14:00 -0300

Nerds do Sul!

Sábado (1 de dezembro) haverá mais uma edição do Tchelinux, dessa vez em Porto Alegre.

Será um dia cheio de palestras de workshops, ao custo de 2 kilos de alimentos não pereciveis.

http://www.tchelinux.org/2007/

Inclusive eu irei ministrar uma palestra sobre AWK/SED no começo da tarde. Destaco também a palestra do Carlos Santos sobre "A História do Unix".

Enfim, um dia cheio de Ubuntu, Python, KDE, Kernel, BSD e muito mais!

Apareçam!


Analise Orientada a Objetos com Java - Parte 1
Sat, 17 Nov 2007 15:02:00 -0300

Estes dias eu me deparei com um problema bem interessante: uma forma de atribuir professores a disciplinas por meio de um sistema feito em Java. 

Já aviso, estou tentando aprender e achei este exemplo interessante. Este post é uma tentativa de análise orientada à objetos feita de forma progressiva, comentários são bem vindos.

A primeira proposta foram 2 matrizes bidimensionais, uma com os professores disponíveis naquele dia e outra com as turmas, distribuidas ao longo de uma semana. Eu logo percebi que isso podia ser um problema de modelagem, pois se vc vai utilizar matrizes, paineis, interface textual ou seja lá o que for, isto é apenas uma camada - a visão. Um modelo muito mais rico pode ser criado, vejamos este exemplo em Java:

class Professor{}
class Disciplina{}
class Turma{
 Disciplina disciplina;
 Professor professor;
}
public class Main{
 public static void main(String[] args) {
 Professor oseias = new Professor();
 Disciplina matematica = new Disciplina();
 Turma matA = new Turma();
 
 matA.disciplina = matematica;
 matA.professor = oseias;
 }
}


A minha classe Main mostra como seriam as operações sobre estas 3 classes. Basicamente eu tenho uma classe Professor, uma classe Disciplina e uma classe Turma. Se vc observarem qualquer instituição de ensino vão perceber que uma turma tem-um professor e tem-uma disciplina associados (composição).

Percebam também que eu não fui até uma escola ou universidade e fiquei horas levantando requisitos, criado diagramas uml ou documentos no word - apenas criei uma casca inicial de código (cheio de problemas por sinal). Também não me importo, ainda, com nenhum aspecto temporal. Sem falar que esta escola todos os professores podem dar qualquer disciplina - agora vamos implementar direito.

Vejamos... uma turma não troca de disciplina facilmente, mas de professor sim. Faz sentido, então, ter um setter de professor e um construtor que receba uma disciplina. Outra coisa, eu não defini nada nas outras classes, então está na hora de definir 2 atributos : id (numérico) e nome (String). Vou diferenciar os objetos pelo código, isto é, o seu id, e o nome será utilizado como descrição. Vou sobreescrever os métodos equals e toString.

Como o nome desses objetos é importante, vou coloca-los no construtor também (assim como o id).

class Professor{
 long id;
 private String nome;
 public Professor(long id,String nome){
 this.id = id;
 this.nome = nome;
 }
 public long getId(){ return id; }
 public String toString(){ return this.nome ; }
 public boolean equals(Object o){
 boolean test = false;

 if (!(o instanceof Professor))
 test = super.equals(o);
 else 
 test = ((Professor) o).getId() == this.id; 
 return test;
 } 
}
class Disciplina{
 long id;
 private String nome;
 public Disciplina(long id,String nome){
 this.id = id;
 this.nome = nome;
 }
 public long getId(){ return id; }
 public String toString(){ return this.nome ; }
 public boolean equals(Object o){
 boolean test = false;

 if (!(o instanceof Disciplina))
 test = super.equals(o);
 else 
 test = ((Disciplina) o).getId() == this.id; 
 return test;
 }
}
class Turma{
 long id;
 private String nome;
 private Disciplina disciplina;
 private Professor professor;
 public Turma(long id, String nome,Disciplina disciplina){
 this.id = id;
 this.nome = nome;
 this.disciplina = disciplina;
 }
 public void setProfessor(Professor professor){
 this.professor = professor;
 }
 public long getId(){ return id; }
 public String toString(){ 
 return this.nome + " [" + this.disciplina 
 + "] c/ " + this.professor ; 
 }
 public boolean equals(Object o){
 boolean test = false;

 if (!(o instanceof Turma))
 test = super.equals(o);
 else 
 test = ((Turma) o).getId() == this.id; 
 return test;
 } 
}
public class Main {
 public static void main(String[] args) {
 /* objetos bem comportados */
 Professor oseias = new Professor(1L,"Oseias");
 Disciplina matematica = new Disciplina(1L,"Matematica");
 Turma matA = new Turma(1L,"Matematica A", matematica);
 matA.setProfessor(oseias); 
 
 System.out.println("Professor " + oseias); 
 System.out.println("Disciplina " + matematica); 
 System.out.println("Turma " + matA);
 
 /* objetos mal comportados 
 * Sujeitos a NullPointerException */
 Professor juca = new Professor(2L,null);
 Disciplina calculo = new Disciplina(2L,null);
 Turma matB = new Turma(2L,"Matematica B", null);
 matB.setProfessor(null); // nem precisava mas...
 Turma matC = new Turma(3L,"Matematica C",calculo); 
 Turma matD = new Turma(4L,"Matematica D",calculo);
 matD.setProfessor(juca);
 
 System.out.println("Juca? " + juca);
 System.out.println("Calculo?" + calculo);
 System.out.println("matB? " + matB); 
 System.out.println("matC? " + matC);
 System.out.println("matD? " + matD);
 }
}


Mas que raios eu estou fazendo? veja a saída desse programa:

Professor Oseias
Disciplina Matematica
Turma Matematica A [Matematica] c/ Oseias
Juca? null
Calculo?null
matB? Matematica B [null] c/ null
matC? Matematica C [null] c/ null
matD? Matematica D [null] c/ null


Qual o significado? Bom... eu tenho uma forma razoavel de representar um professor, disciplina e turma, porém não é pratico, o construtor está gigante e, em muitas situações, eu posso ter parâmetros nulos, o que pode ser uma fonte de problemas. Existem muitas formas de refatorar estas classes, eu nem toquei no HashCode, enfim, tem muito pano pra manga. 

Apresento a vcs o desenvolvimento em etapas, iterativo. Eu estou chutando requisitos aos poucos, é verdade, mas eu entrego um codigo testável e completo e cada ciclo. Com os usuarios testando esse código (nesse caso, uma API, mas enfim...) eu obtenho um feedback interessante. O que vc acha?
Comments


NetWalker

Saudações, sir Peczenyj. :)
Muito boa a abordagem da análise.
Java, como sempre, usual e prático no que diz respeito a conceitos de orientação a objeto (a não ser herança múlt... ops, heim? alguém disse algo? ah bom... :D ). 
Pois bem, quero ver a segunda parte pra descobrir o que pretende com esses construtores.
No mais, já que Professores e Disciplinas são apenas referenciados em Turmas, e têm a sua existência independente destas, ainda acredito que a relação seria uma Agregação. E não Composição, como citou.
Voltando... Vc descreveu o problema como possuindo o objetivo de atribuir professores às disciplinas. Tem alguma restrição ou regra geral que o problema define e pretende seguir (disponibilidade, horários, etc)? Ou continuará o foco em relacionar professores e disciplinas sem maiores restrições?
Então é isso, continue o bom trabalho de sempre.
Abraço.
Até +.


Marcio

Eu acho que você deveria usar um problema mais complexo como exemplo e ver se isso realmente funciona. Seu exemplo é bem simples e todo mundo conhece o domínio (estou deduzindo que você estudou e fez faculdade :))

Acho que não é necessário coletar todos os requisitos possíveis e modelar todos os detalhes do sistema, mas é quase obrigatório um estudo do domínio e um design, nem que seja um rascunho, do sistema. Os outros detalhes surgirão com a implementação. :)

[]'s




Nascimentos
Thu, 08 Nov 2007 19:56:00 -0300

Coisas maravilhosas acontecem.

Descubro recentemente que um amigo meu virou papai. A pequena Sophia nasceu prematura, logo deve estar aos cuidados da família coruja. Agora descubro que outro amigo será pai: já está na sétima semana. Eta Canoenses!

É... o tempo passa... quando estamos na faculdade descobri que um colega será pai/mãe é incomum, mas com o passar do tempo temos que escutar "e tu, pra quando vai ser?"...

Na hora certa (espero eu).


Ferramentas de Teste
Tue, 06 Nov 2007 14:28:00 -0300

Excelente comparativo de duas ferramentas gratuitas de teste automatizado para interfaces web.

http://mguillem.wordpress.com/2007/10/29/webtest-vs-selenium-webtest-wins-13-5/

Pelo escore final, creio que muitos projetos web poderiam ser beneficiados pela combinação destas duas ferramentas.


From Nand to Tetris in 12 Steps
Tue, 06 Nov 2007 13:50:00 -0300

Otimo vídeo - Google Tech Talks October 10 ,2007
 

Link direto aqui.
Comments


Tiago Peczenyj

Pois é, pena que é bem corrido.


Felipe

Ótimo esse vídeo. principalmente para min que estou quebrando cabeça com o funcionamento do MIPS.




AWK e Arrays Associativos
Wed, 31 Oct 2007 13:09:00 -0300

Um grande problema para quem trabalha com arrays associativos no AWK é
com relação a ordem dos elementos quando esta fazendo uma iteração.

Ex:
$ gawk 'BEGIN{ split("5 4 2 1 3",T) ; for(i in T) print T[i]}'
1
3
5
4
2


Eu inseri, nessa ordem, 5, depois 4, depois 2... porém o acesso aos
elementos de um array em um for do tipo
for( variavel in array)

é imprevisive / incontrolável.

Agora vejamos isto:

$ WHINY_USERS=1 gawk 'BEGIN{ split("5 4 2 1 3",T) ; for(i in T) print T[i]}'
5
4
2
1
3


WOW! Através da variavel de ambiente do unix WHINY_USERS agora eu consigo acessar os elementos na ordem em que eles foram inseridos no array!

E para acessar os valores na ordem crescente:
$ WHINY_USERS=1 gawk 'BEGIN{ split("5 4 2 1 3",T)
 asort(T) ; for(i in T) print T[i] }'
1
2
3
4
5


A variavel de ambiente WHINY_USERS não esta documentada no man, muito menos na documentação que consegui a respeito do gawk. Descobri esta dica no comp.lang.awk e, por incrivel que pareça, tive que vasculhar o codigo fonte do gawk (graças a deus podemos fazer isso) para entender melhor o que essa variavel poderia fazer.

Enfim, fica a dica.


Tchelinux 2007 - Chamada de trabalhos
Tue, 30 Oct 2007 14:53:00 -0300

Seja bem-vindo à chamada de trabalhos do 2º Seminário do Software Livre Tchelinux que irá acontecer dia 1º de Dezembro de 2007 na UFRGS em Porto Alegre, RS. Antes de enviar sua proposta de palestra, recomendamos que leia atenciosamente o regulamento abaixo:

Sobre o Temário:

A equipe de avaliação de propostas irá selecionar 10 palestras técnicas sobre Software Livre dentro dos seguintes temas:

Sistemas Operacionais
Desktop baseado em Software Livre
Aplicativos Gráficos
Jogos e Multimídia
Linguagens de programação
Ferramentas para desenvolvimento
Banco de dados
Administração de Sistemas
Redes e Segurança da Informação

Sobre as Apresentações:

- Cada palestrante terá 75 minutos para apresentar seu trabalho 
- Os recursos disponíveis serão projetor multimídia e micro-computador rodando Ubuntu Gutsy
- O palestrante deverá permitir que os slides de sua palestra seja publicada no site do grupo
- Não haverá nenhuma remuneração ou reembolso de despesas para palestrantes

http://www.tchelinux.org/papers/

Participem!


Entendendo Ponteiros na linguagem C
Wed, 24 Oct 2007 11:09:00 -0300

Entender ponteiros (e ponteiros para ponteiros) nem sempre é facil quando estamos vendo C ou C++ pela primeira vez. O conceito é absurdamente simples, assim como os operadores * e &, mas pelo menos para mim demorou um tempão para a ficha cair (e olha que eu utilizava arrays direto e nem me ligava nesse detalhe).

Com auxilio do pre-processador C, vejamos se este exemplo que pode ser elucidativo:

#include "pointer.h" 
int main () 
{ 
 int x = 0; // variavel de exemplo 
 pointer(int) y; // ponteiro 

 y = address(x); // y aponta para o endereco de x 

 x++; // incrementamos o valor de x 
 value(y)++; // incremento indireto (via ponteiro) 

 printf("value %d %d\n",x, value(y) ); 
 printf("address %p %p\n",address(x), y ); 

 return 0; 
} 


Ou seja, a criação de um ponteiro para uma variavel do tipo inteira é através da macro pointer. Outra macro, address, retorna o endereço de uma variavel e, assim, tenho uma referência aquela variavel. Posso então ter acesso ao valor e até mesmo manipular a variavel original.

Vejamos agora o resultado da execução:
$ ./a.out
value 2 2
address 0xbfffeaa4 0xbfffeaa4


Perceba que eu consegui incrementar a variavel duas vezes (através das duas formas disponíveis). Perceba também que o ponteiro y tem como valor o mesmo endereço de memória que a variavel x, razão pela qual consigo alterar o seu valor.

O codigo gerado pelas macros 

int main () 
{ 
 int x = 0; // variavel de exemplo 
 int * y; // ponteiro 

 y = (&(x)); // y aponta para o endereco de x 

 x++; // incrementamos o valor de x 
 (*y)++; // incremento indireto (via ponteiro) 

 printf("value %d %d\n",x, (*y)); 
 printf("address %p %p\n",(&(x)), y); 

 return 0; 
} 


Eu recomendo que, uma vez que o conceito tenha ficado claro, que não se use mais este header sob pena de criar arquivos ilegíveis. Por exemplo, tente compilar com a opção de gerar os simbolos para debug (-g) e depois tente debugar esse programa: perceberão que o gdb, por exemplo, não mostra o codigo fonte com tanta clareza.

Para fazer este exemplo, utilizamos este arquivo header:

#define pointer(type) type *
#define value(var) (*(var))
#define address(var) (&(var))
Comments


Tiago Peczenyj

Magoei... :(


Ron

lixo! vai aprender a programar! :D




Tropa de Elite 2 - Dia de Treinamento Java
Sun, 07 Oct 2007 21:22:00 -0300

Seguimos com novos exemplos inspirados na triste realidade da polícia carioca.

/*
* O Bope foi criado para atuar quando a policia perde o controle
* E no rio de janeiro isso acontece com bastante frequencia
*/
class Bope{ 
 private String nome; 
 private int qtdeVitimas = 1; // ja começa bem!
 
 public Bope(String nome){
 this.nome = nome;
 } 
 // sobrecarga do método ondeTaOBaiano
 public void ondeTaOBaiano(Estudante e){
 e.sabeVoarEstudante();
 }
 public void ondeTaOBaiano(Traficante t){
 t.levaSacoNaCabeca();
 }
 // exemplo de método final!
 public final Doze encontreiOBaiano(Baiano b){
 return b.naCaraNaoQueEhPraNaoEstragarVelorio();
 }
}

public class Treinamento{
 public static void main(String [] xxx){
 // Apresento o capitão nascimento
 Bope instrutor = new Bope("Capitao Nascimento");
 try{
 // de cada 100 policiais que fazem o curso do Bope,
 // so se formam 5, e eu, quando me formei parceiro, 
 // eramos apenas 3. 
 Turma.tentaFazerCursoBopeCom(capitao);
 } catch (PolicialCorruptoEncontrado pce){

 } catch (PolicialFracoEncontrado pfe){

 } catch (PolicialSemABandoleiraNessaAlturadoCampeonato e){

 }
 }
}


SEUS FANFARRÕES!
VCS TEM 10 SEGUNDOS PARA COMPLETAR ESSE CÓDIGO!

- O zero-dois NÃO está escrevendo!
- SEU zero-dois, porque o senhor não escreveu nenhuma linha?
- A-a minha IDE não terminou de carregar, senhor...
- Agora a sua IDE ja carregou, seu zero-dois?
- S-sim senhor...
- Então, seu zero-dois, termine o seu programa, senão todos os seus colegas terão que usar o EDIT do MS-DOS até o fim do curso E A CULPA EH DO ZERO-DOIS!

 

HOMEM DE PRETO QUAL É A SUA MISSÃO?
É APRENDER JAVA SEM PRECISAR DE CERTIFICAÇÃO!
HOMEM DE PRETO O QUE É QUE VC FAZ?
FAÇO CODIGO FONTE QUE ASSUSTA O SATANÁS!
 

Estratégia, do inglês, Strategy...

- Senhor, o zero-cinco está dormindo...
Comments


Lucas

Muito bom :-)


Felipe

Hahaha muito bom!!


Sergio

Só faltou isso:

"Tira esse pin do peito que vc não é desenvolvedor java... vc é muleke!!!"

muito bom esse post


gto

hahaha!!
Isso vai virar um paradigma logo, logo.

"Eu uso OO (orientação a objeto).. Eu uso OE (orientação a eventos)..

Eu uso BP! (bope, porra!)"




Aprendendo Conceitos antes de Sintaxe
Thu, 04 Oct 2007 21:10:00 -0300

O homem aprende por dois motivos: por gosto ou por necessidade.

Depois de passar um semestre brincando com Pascal na era pré-google ( quando não encontravamos uma pagina através do yahoo ou cadê, tentavamos urls aleatórias como www.pascal.org - que era a pagina da família pascal ), tive uma disciplina cujo professor só sabia Fortran e C.

Através do MOO descobri o curso on-line da UFMG, e pude dar os primeiros passos em C. Entretanto o foco dessa disciplina não era fazer agenda ou video-locadora - eram programas científicos. Linux, gnuplot, maple... foi um mundo muito divertido.

É claro que algumas coisas eu simplesmente não compreendia: os tais dos ponteiros, por exemplo. Era só ver um * que não fosse multiplicação que eu já tinha dor de cabeça. E assim se passaram alguns anos onde eu apenas reproduzia os comandos que tinha aprendido.

Anos depois, conversando com o CaSantos caímos em uma micro-aula de programação. Eis que ele profere sabias palavras: Ao estudar uma linguagem de programação, a primeira coisa que se precisa estudar são os conceitos e, por último, a sua sintaxe.

Toda a vez que eu entrava em uma lista de discussão ou forum e via as perguntas dos novatos eu lembrava dessa frase. Coisas como dizer que os arquivos .h do C são bibliotecas, colocar system("pause") pro programa não "fechar do nada" e por ai vai. O tipo da coisa que, quem conhece o conceito, não perguntaria.

Por que razão não se ensina os conceitos de uma linguagem logo no começo? Eu só posso pensar que é para os alunos aprenderem de forma intuitiva no começo e resgatar isso mais tarde (talvez em uma cadeira de compiladores, sei lá), mas será que isso acontece? 

Geralmente o trabalho de fim de semestre dessas cadeiras é um CRUD em C com listagem (ou relatório) de alguma coisa ordenada de uma ou mais formas. Cadastrar alunos ou contas bancárias, salvando em arquivo.

Pois bem, se é uma disciplina introdutória, por que raios alguem iria pedir um CRUD?? Meu deus, os alunos mal sabem como compilar o programa, tampouco debuga-lo - No maximo enchem de printf("passei por aqui") - e pedem um programa com 'menu interativo'! Ai o camarada perde metade do tempo fazendo 'menuzinho' com asteriscos ou outro caracter e não consegue implementar a lógica. Quando implementa é aquela maçaroca. O que isso ensina?

Eu daria uma sugestão: quer ensinar C ou Java ou Snobol 4, ensine. Mas não peça um programa CRUD cheio de frescura - peça uma biblioteca. De um arquivo header ou uma interface java e diga: implementem essas funções/metodos ai. Eu vou testar o meu programa com essa biblioteca e espero que tudo funcione.

videolocadora.h
int cadastra_video(char *nome, int preco, int categoria);
int cadastra_cliente(char *nome, char *cpf, char *endereco);
int aluga_video(...);


Enfim, não consigo pensar num exemplo melhor. A ideia é introduzir um desenvolvimento em camadas, deixando o aluno pensar em como ele vai gravar, ler e ordenar os dados sem frescuras de tela, ensinando a fazer testes e também a debugar a aplicação.

Quer ensinar a fazer telinha? Ensina em outra disciplina, nesse caso ensinando técnicas de design apropriadas. Começando pela linha de comando do unix: como pode um aluno se formar sem nunca ter criado o seu próprio grep? Criar interfaces com o usuário não é algo facil, requer muito estudo, principalmente de usabilidade.

Alias fazer "telinhas" geralmente supõe colocar um programa em um estado. Quem aprende o conceito de maquina de estados no momento que esta fazendo esse cadastro? Posso apostar que esse pessoal não sabe o que é stateless e statefull e o professor nem pensa q isso seja importante (aqui eu lembro da agenda de telefones que eu fiz em pascal).

Fica aqui a minha sugestão. Espero que faça sentido :)
Comments


Setf

Excelente post Tiago. Acredito que os cursos de programação melhorariam muito (especialmente os de C) se utilizassem essa idéia simples de criar uma biblioteca ao invéz de perder tempo criando interfaces que nem ao menos são práticas ou úteis. Um professor poderia já entregar essa interface com o usuário pronta e o aluno implementar as funcionalidades dela. Seria muito mais empolgante.

Parabéns novamente pelo post.




Convertendo Números
Mon, 01 Oct 2007 19:29:00 -0300

Um dos meus primeiros desafios na área de programação foi fazer um conversor de números decimais para romanos. Eu estava aprendendo Turbo Pascal e usava um potente 286 com 1MB de memória - sem HD.

Fiz a maior sequencia de ifs da minha vida. Hoje estava relembrando e resolvi fazer uma versão SED.

/[0-9]*[5-9]...$/q
s/1...$/M&/;s/2...$/MM&/;s/3...$/MMM&/;s/4...$/MMMM&/
s/6..$/DC&/;s/7..$/DCC&/;s/8..$/DCCC&/;s/9..$/CM&/
s/1..$/C&/;s/2..$/CC&/;s/3..$/CCC&/;s/4..$/CD&/;s/5..$/D&/
s/6.$/LX&/;s/7.$/LXX&/;s/8.$/LXXX&/;s/9.$/XC&/
s/1.$/X&/;s/2.$/XX&/;s/3.$/XXX&/;s/4.$/XL&/;s/5.$/L&/
s/1$/I/;s/2$/II/;s/3$/III/;s/4$/IV/;s/5$/V/
s/6$/VI/;s/7$/VII/;s/8$/VIII/;s/9$/IX/
s/[0-9]//g


Tendo um número por linha ja basta. 

$ echo '3999' | sed -f other.sed
MMMCMXCIX


O sed é realmente fantástico! Pena que acima de 5 mil tem que colocar uma barra em cima dos números.
Comments


voyeg3r

Também sou super fã do SED, estou no momento criando um script para converter um wiki do pbwiki para moinmoin, são mais de 300 páginas e adição manual seria um trabalho digno para um usuário windows :)




Aprenda Java com os melhores versão Tropa de Elite
Sun, 30 Sep 2007 21:01:00 -0300

Exatamente: Não vem com essa que vc é istudante, vai tomar tapa na cara se não aprender Java. Saiba que, de cada 100, só 5 terminam o curso. Nem na Sun se treina programador assim.

/*
* O Bope foi criado para atuar quando a policia perde o controle
* E no rio de janeiro isso acontece com bastante frequencia
*/
class Bope{
 
 private String nome; 
 private int vitimas;
 
 public Bope(String nome){
 this.nome = nome;
 this.vitimas =0;
 }
 
 public void matou(int tantas_vitimas_agora){ 
 this.vitimas = this.vitimas + tantas_vitimas_agora;
 }
 
 public int quantas_vitimas(){
 return this.vitimas;
 }
}

public class Programa{
 public static void main(String [] xxx){
 // Apresento o capitão nascimento
 Bope capitao = new Bope("Capitao Nascimento");
 
 // quando o capitão sobe a favela, é pra matar, não pra morrer
 capitao.matou(1000);
 
 // agora ele subiu o morro de novo, com ele não tem erro.
 capitao.matou(2000);
 
 // e a farda dele não é azul, é PRETA
 System.out.println("O Bope matou: " + capitao.quantas_vitimas());
 }
}


Entendeu? Não?

ENTÃO PEDE PRA SAIR, GUERREIRO!
TU É CORRUPTO, TEU LUGAR É COM .NET, É COM VB! JOCKEY DE IDE! PEDE PRA SAIR AGORA!
Comments


RIC@RDO

Te puxou em Peczenyj!!
Essa ficou muito boa!!!


gto

hahah!
Nunca tinha comentado por aqui, mas leio as vezes. Dessa vez me obriguei a comentar.

Vou te dizer, pra ficar bem ao estilo do bope, com direito a caveirão e tudo mais, só faltava um método "ondeTaOBaianoPorra" :D

E claro, as ameaças com vouTeMostrarOSaco e pegaAVassoura...

uh!

[]'s!


NetWalker

Fala Peczenyj.
Estamos na mesma, só na base das descrições.
Agora, "Jokey de IDE" foi PHoda. LOL
Nunca tinha achado uma expressão que casasse tão bem. (com o jeito do Capitão Nascimento claro) :D
Isso inspira a fazer um do senado.
Difícil é que nunca sairia da prioridade mais alta (e com imunidade a kills).
Farewell. :)


Tiago Peczenyj

Acontece que o Capitão Nascimento aprendeu C primeiro, eu até tentei corrigir isso mas ele me ameaçou, disse q eu era moleque.

E não vi o filme ainda, me alimento das descrições eletrizadas dos meus colegas de trabalho :)


Edson

Assistiu ao filme na versão oficial (na única sala que o passa em Jundiaí) ou foi em piratão mesmo? 
Tem de tomar um tapa no ouvido mesmo, que "quantas_vitimas" é o jeito C de falar, e BOPE que se preza fala em Java ("quantasVitimas") :P


rsfair

Nada como comentários para facilitar o entendimento do programa :)




Ruby e o method_missing
Fri, 28 Sep 2007 11:43:00 -0300

Os objetos em Ruby possuem um método chamado 'respond_to?' para verificar se o objeto possui (ou melhor, se ele responde a) um determinado método. Em uma linguagem dinâmica como o ruby, onde podemos incluir um método numa classe em runtime, é um recurso muito necessário, ainda mais se pensarmos em termos de Duck Typing.

Em caso de dúvida, basta fazer um if, afinal chamar um método que não existe causa um NoMethodError, certo?

Depende. Observe:

class A
 def xxx()
 puts "xxx"
 end
 def method_missing(m, *args)
 puts "nao tenho esse metodo: #{m}"
 end
end

a = A.new
a.xxx
# aqui normalmente daria erro e o script seria abortado 
# sem o rescue adequado
a.yyy 


Resultado:
~> ruby A.rb
xxx
nao tenho esse metodo: yyy


Eu sobreescrevi o método 'method_missing', que como o próprio nome indica, intercepta uma chamada a um método inexistente. Divertido, não?


Ruby e suas travessuras
Mon, 24 Sep 2007 23:33:00 -0300

irb(main):001:0> def some(thing)
irb(main):002:1> puts "some#{thing}"
irb(main):003:1> end
=> nil
irb(main):004:0> some "thing"
something
=> nil
irb(main):005:0> some = "thing"
=> "thing"
irb(main):006:0> some(some)
something
=> nil


Ajude para ser ajudado.
Sat, 22 Sep 2007 15:47:00 -0300

Não é incomum encontrarmos pedidos de ajuda (as vezes em caps lock, com a palavra "urgente" e com açassinatos ao idioma corrente) em listas de discussão ou foruns.

Por exemplo:
 no postgresql o comando sql abaixo funciona perfeitamente 
 
 "SELECT c.descricao, u.nome, v.data_venda ," 
 + "v.valor_total, v.condicao_pagamento, v.codigo" 
 + "from venda v, carro c, usuario u" 
 + "where v.carro = c.codigo and v.usuario = u.codigo"; 
 
 mas quando executo no java ocorre erro
 

Não vejo diferença entre falar apenas isso e esta conversa pelo telefone:

- Alo, consultório médico
- Doutor, é a primeira vez que ligo, nunca nos vimos...
- Pronto, me diga o que esta sentindo.
- me sinto mal...
- Ah, tome um chá de joaçaba com mel e 2 anti-coagulantes
- Certo, e quanto a isso aqui na minha perna?
- Humm... vamos ter que operar. Ou espera uma semana que passa...


Enfim...
Comments


Taner Pereira

Você deve ouvir mais do que falar, por isso temos dois ouvidos e apenas uma boca.

Mas nos fóruns a coisa inverte, acho que precisamos de mais bocas e menos ouvidos. Tem gente que só participa para pedir ajuda mas nunca ajuda ninguém.


Tiago Peczenyj

Marcos, vc está certo, porém com uma descrição tão pobre eu não sei se era só _este_ erro. Sem bola de cristal fica dificil. 

Mas fora o pessoal "sem noção", foruns são extremamente úteis!


MarcosJordao''

Pior que é verdade... rs

Contudo, fóruns são muito produtivos e já me ajudaram muito!

A propósito, o erro em questão é que pela concatenação os comandos ficarão sem espaços, por exemplo:
"...v.codigofrom venda..."


Renan

A diferença é que o primeiro você pode consertar...

O segundo já não dá :P




Resumo do primeiro Chopp on Rails de Poa
Sat, 22 Sep 2007 00:55:00 -0300

O pessoal da lista rails-rs organizou um encontro em um local com bastante cerveja.

Acho que a melhor descrição do que poderia ter sido é esta:



Curso de Ruby on Rails em Porto Alegre
Tue, 18 Sep 2007 10:11:00 -0300

Uma oportunidade imperdível!

A Tech Office IT realiza no período de 24 a 28 de setembro de 2007 em Porto Alegre, o curso presencial Ruby on Rails, voltado a desenvolvedores Ruby que desejam conhecer mais sobre Rails e desenvolvedores de outras linguagens que tenham interesse em ingressar no RoR. O curso objetiva auxiliar o aluno a entender o Ruby on Rails e possibilitar a criação de aplicações o utilizando, além de expor suas vantagens e limitações.

Após o curso o aluno estará apto a desenvolver aplicações WEB utilizando o Ruby On Rails, saberá onde procurar mais recursos para acelerar o desenvolvimento e adicionar recursos na aplicação desenvolvida.

Com carga horária de 20 horas/aula, o treinamento será 100% prático e ministrado em laboratório. Durante o curso, os participantes desenvolverão uma loja de DVDs completa que poderá ser utilizada como exemplo ou como base para o desenvolvimento de uma aplicação mais complexa pós-curso. Mais informações poderão ser obtidas através do site www.techoffice.com.br ou e-mail contato (at) techoffice (.) com (.) br, além do telefone 51.3012.8241.

Mais detalhes sobre o curso de Ruby on Rails

Clique aqui para se inscrever no curso de Ruby On Rails

Se alguem não sabe o poder do Ruby on Rails, veja esse video:




Vagas Abertas!
Tue, 18 Sep 2007 09:58:00 -0300

Pessoal, trago aqui pelo menos 5 oportunidades de ingressar em uma das maiores empresas de tecnologia do mundo. O ambiente de trabalho é excelente, as condições são muito boas e existem muitas possibilidades de crescimento. Todas as vagas são para trabalhar em Porto Alegre/RS.

Desenvolvedor C# - 3 vagas
Experiência em desenvolvimento/programação de SW em C# e .Net
Conhecimentos sobre UML e OO e design patterns
Conhecimentos sobre XML e XPATH
Inglês avançado/fluente

Desenvolvedor/Testador - 2 vagas
Experiência na área de teste de software
Conhecimento de WebServices e protocolos SOAP e HTTP
Conhecimento de XML, XPATH e alguma linguagem Script
Experiência em OO
Inglês fluente

É claro, caso alguem queira ingressar na área de informática, eu sugiro que pense nessa vaga:
Testador de Software
Experiência na área de teste de software
Conhecimentos em Banco de Dados e SQL (select, update, insert,delete)

Aos interessados enviar email com currículo para tiago (.) peczenyj (at) gmail (.) com


Die Working Hardly
Wed, 29 Aug 2007 21:29:00 -0300

Sensacional Filme sobre efeitos especiais... sem efeitos especiais.

Foi dirigido pelo Zach Lipovsky, para concorrer no On The Lot, um dos programas mais inteligentes dos ultimos tempos: um reality show sobre cinema e o vencedor ganhou um contrato com a Dreamworks e foi trabalhar com o Steven Spielberg (entretanto não foi o Zach que ganhou)!

Quem não gostaria de fazer isso no seu proprio ambiente de trabalho?



Link aqui.


Metaprogramação com awk e sed
Tue, 28 Aug 2007 15:17:00 -0300

Criar um programa que cria programas é simples nas linguagens interpretadas.

Criamos o programa em uma string e executamos via eval() ou então gravamos em arquivo e executamos novamente.

Me deparei com o seguinte problema: inverter as palavras de uma frase ou arquivo mantendo a ordem em que aparecem.

É claro que eu pensei em usar o rev, mas ele inverte a linha como um todo. Depois de fazer um laço for muito feio em awk, fiquei pensando em como resolver de forma mais legível.

Tive esta ideia: vou fazer uma lista de palavras, inverte-las com o rev e, para cada palavra, vou substitui-la pela palavra invertida. Beleza, o sed faz isso com um pé nas costas.

Eu tenho um arquivo (poderia ser um named pipe) chamado 'direito' que contem uma lista de palavras sem repetição, com uma palavra por linha. Outro arquivo, com o mesmo conteudo mas revertido via 'rev'.

Uso o paste para colocar os arquivo lado a lado e uso o awk para gerar comandos como este:s/\bpalavra\b/palavra_revertida/g;


Usei o awk pq a sintaxe fica mais clara, o sed ficou muito poluído. Perceba que eu uso o recurso de borda das expressões regulares. Isso me garante que vou trocar uma palavra inteira, e não um pedaço da string.
 
Agora vem o pulo do gato: mando estes comandos via stdin para o sed, fazendo uso de um pipe. eu informo para o sed que os comandos virão pela stdin passando a opção -f -

Vejam o resultado abaixo, espero que seja útil para alguem :)

$ cat stuff
Nosso fórum principal.

Problemas com hardware em geral,

temperaturas, comparação de desempenho,

compatibilidades de componentes, etc.

$ LC_ALL=pt_BR grep -oE '\w+' stuff | sort -u | tee direito | rev > reverso

$ paste direito reverso | awk '{
 printf "s/\\b%s\\b/%s/g;\n",$1,$2 # facil, não?
 }' | sed -f - stuff
ossoN muróf lapicnirp.

samelborP moc erawdrah me lareg,

sarutarepmet, oãçarapmoc ed ohnepmesed,

sedadilibitapmoc ed setnenopmoc, cte.

Como o arquivo possui acentos, precisei setar a variavel LC_ALL para pt_BR, caso contrario a expressão regular \w+ não iria casar com todas as palavras.

Ps: Julio, que tal chamar isso de "Inversor do Tiago"?
Comments


Tiago Peczenyj

O que acontece é o seguinte:

cada vez que vc invoca o comando rev, vc perde tempo com a inicialização do programa e seu término. Eu utilizei o rev apenas uma vez, mas vc executa a cada palavra.

É a mesma diferença de

for i in *.txt ; do rm $i ; done

e rm *.txt

A segunda forma recebe ja todos os parâmetros e só tem o trabalho de iterar internamente sobre esta lista. A primeira forma cria um custoso laço por conta do detalhe que eu ja lhe falei.

Shel é sensacional, porém não pode ser pensado como uma linguagem script sempre, ele é uma forma de interação do usuario com o sistema ;-)


Leandro Santiago

Mas, se você transformar esse for acima numa função, tipo
InverteFrase()
{
 local IFS=' ' # tab e espaço
 string=($@)
 for (( i=0; i<=${#string[@]}; i+=1 ))
 {
 echo ${string[$i]} | rev | tr "\n" ' '
 }
}

Pode utilizar para fazer num arquivo, simplesmente tomando cada linha como uma string independente:

while read LINHA
do
 InverteFrase $LINHA
 echo ## esse daqui é para quebrar a linha, no final de cada frase
done < <(cat arquivo_de_texto)

Nossa, esse meu aí demorou 18 segundos num arquivo de textos simples, mas em compensação não precisa escrever em disco. Contra o seu método, que no mesmo arquivo demorou 0.12 segundo... hauhaau

Flw, e foi mal invadir assim o seu blog ;-)


Leandro

Poderia também utilizar vetores, num forzão bem cabuloso.
Exemplo:
$ read string
o rato roeu a roupa do rei de roma
$ string=($string)
$ for (( i=0; i<=${#string[@]}; i+=1 ))
> {
> echo ${string[$i]} | rev | tr "\n" ' '
> }
o otar ueor a apuor od ier ed amor

Mas só funciona com uma só string... rsrs. Só é muito lento, pois o rev, que troca palavra por palavra, é executado muuitas vezes, quebrando a linha, o que me obriga a utilizar um tr para substituir as quebras por espaço... Fica muito lento... (mas funciona para uma string ;-))


Tiago Peczenyj

Ola NetWalker,

Pois bem, o sed pode parecer dispendioso, porém em alguns casos a perda de desempenho é imperceptível. Sem falar que a sintaxe dele é mais clara (99% dos casos eu uso a opção de busca e substituição).

Mas perceba que o sed pode ser usado de forma mais otimizada, como o caso de imprimir apenas a linha 105 de um grande arquivo:

sed -n '105q;d' arquivo

sed + awk são uma dupla muito interessante ;-)


NetWalker

Cá denovo. :)
Depois de achar um exemplo teu de inversor em sed pela net (assustador lol), lhe pergunto: que faz/fez tanto com sed?? :D
Outra questão q intriga fora o uso real desse inversor (http://www.alltooflat.com/geeky/elgoog/ ?? weird heheh); é se já fez alguma avaliação sobre a performance do sed em relação ao awk, ou mesmo tarefas q possam ser substituídas por grep, cut, expansões e afins.
Pois em alguns casos sed me pareceu meio dispendioso. Porém não conheço sed a fundo para saber sobre o quanto os comandos estavam otimizados.
E adiantando, muito boa essa indicação do "On The Lot". Não conhecia. :) Ótimos posts como sempre.
Então é isso.
Farewell.

NetWalker


match

bem legaw, olha, estou usando o tput e para me familiarizar com ele resolvi fazer algo pratico brincando com ele e fazendo a "Screen Matrix" em shel, consiste em usar colunas fixas no tput com linhas aleatorias pra gerar akela chuva verde de caracters do Matrix Movie, saiu meio bagunçado e n tive tempo ainda de por uma ordem, talvez vc esteja interessando em ajudar o codigo estah em: http://crimeboy.110mb.com/neo.sh
[]z




Extended Globbing
Tue, 28 Aug 2007 15:15:00 -0300

Não sei se é conhecimento de todos mas o Bash possui, alem do globbing normal (a expansão * ? e [a-z] de nomes de arquivos e diretórios), um globbing extendido.

Acho que, em alguns casos, podera ser BEM util, eliminando um pipe para um grep por exemplo.

São eles (direto do man)
?(pattern-list)
 Matches zero or one occurrence of the given patterns
*(pattern-list)
 Matches zero or more occurrences of the given patterns
+(pattern-list)
 Matches one or more occurrences of the given patterns
@(pattern-list)
 Matches exactly one of the given patterns
!(pattern-list)
 Matches anything except one of the given patterns

Para poder utiliza-lo precisa executar o shopt conforme o exemplo abaixo

$ shopt -s extglob

$ ls
file filename filenamename fileutils

$ ls file?(name) # padrão pode aparecer 0 a 1 vezes
 
file filename

$ ls file*(name) # padrão pode aparecer 0 a N vezes
file filename filenamename

$ ls file+(name) # padrão pode aparecer 1 a N vezes
filename filenamename

$ ls file@(name) # padrão deve aparecer 1 unica vez
filename

$ ls file!(name) # divertido esse! padrão NÃO deve aparecer
file filenamename fileutils

$ ls file+(name|utils) # cada padrão pode aparecer 1 a N vezes
filename filenamename fileutils

$ ls file@(name|utils) # "lembra" um file{name,utils} ;-)
filename fileutils
Comments


Tiago Peczenyj

Para um administrador é interessante saber as opções huponexit e restricted_shell -- e depois dizem que o shell é complicado.

Po é cada coisa util que tem :)


NetWalker

Hail again Peczenyj. :)
Esse recurso extended globbing realmente é uma mão-na-roda. Isso sem falar em outros built-in do shell acessíveis pelo shopt. Lembrei de um comum q alguns odeiam, e tem quem goste: o cdspell; e mesmo o cmdhist.
No mais vale lembrar, pra quem visita, o óbvio desses globbings, q é um globbing poder "englobbar" outro. :P
Assim sendo: ls file!(+(name))
Eliminando qualquer ocorrência de name.
Até +.

NetWalker




JEDI - Java Education and Development Initiative
Sat, 18 Aug 2007 15:22:00 -0300

JEDI e o ensino de Java gratuito

Iniciado pela Universidade das Filipinas e apoiado pela Sun Microsystems, nasce através do Java Research & Development Center, a iniciativa JEDI (Java Education and Development Initiative), em Fevereiro de 2005.

A partir desta data, o JEDI vem sendo desenvolvido como um projeto colaborativo, que conta com o apoio da comunidade Java em todo o mundo. Tem como principais objetivos o de melhorar a experiência do ensino e da aprendizagem; Aumentar a qualidade dos graduados em Ciência da Computação e Tecnologia da Informação (disponibilizando os materiais de seus cursos gratuitamente para quem se interessar); Aumentar o banco de especialistas em Java e, Fornecer serviços e produtos a altura das necessidades do mercado mundial.

Tecnologia Java

A tecnologia Java está presente, hoje, em 2 bilhões de dispositivos tecnológicos em todo o planeta - e também fora dele, já que podemos localizar dispositivos Java rodando até em Marte. Existem hoje, no mundo, cerca de 579 milhões de celulares com Java, 93 operadoras de telefonia móvel, 750 milhões de cartões SmartCard (do tipo JavaCard) distribuídos, 650 milhões de computadores pessoais e com 2 milhões de cópias da plataforma empresarial J2EE. Por isto, 68% das novas aplicações, hoje, são desenvolvidas em Java, que substituiu o C++ como a competência mais procurada pelos profissionais. É executado em múltiplas plataformas e em uma ampla gama de dispositivos, indo de um pequeno chip em SmartCards aos servidores dos Grandes Data Centers.

Demanda por Profissionais

Com tudo isso, existe hoje, uma demanda por 2 milhões de novos profissionais de TI a cada ano. Desenvolvedores Java, devem prover soluções nas mais diversas áreas de tecnologia. Torna-se crescente a necessidade, por exemplo, do desenvolvimento de soluções para aparelhos celulares que demandam uma integração com sistemas legados, de maneira a fornecer soluções corporativas. A partir disto, o conhecimento de Java e de sistemas abertos, são imprescindíveis para profissionais de TI.

Além da demanda, a tendência é um outro fator motivador para este mercado. No Brasil, esta aponta para direção de trabalhos realizados para clientes de fora do país - o outsourced. É crescente a procura por parte das organizações, o desenvolvimento de projetos baseados em tecnologia Java, distribuindo-se as aplicações desenvolvidas aqui pela Internet.

Todavia, a busca do mercado por esse perfil de profissional vai de encontro com a capacidade de fornecimento do conhecimento Java. O fato é que, o mercado tem dificuldade em encontrar desenvolvedores com competência nos fundamentos de Tecnologia da Informação, orientação a objetos, conhecimento e experiência em Java avançado, competência em comunicação e nas relações interpessoais.

A industria de software supre o despreparo dos profissionais formados pelo mercado, com a necessidade de re-treinamento interno dos novos contratados, muitos graduados sem conhecimento em TI. A grande maioria não tem uma certificação, que tem um valor adicional no mercado, especialmente para trabalhos executados fora do pais. Outro fator que colabora para o despreparo do profissional é fato do treinamento oficial Java da Sun ser relativamente caro e os programas de treinamento interno das empresas atuais serem pouco abrangentes. Disso resulta uma contratação de apenas 5% dos currículos recebidos nas empresas.

Academicamente o treinamento é, muitas vezes gratuito e de boa qualidade, é acessível. Contrastando, os professores não possuem experiência prática das demandas da indústria e não há, por parte de centros acadêmicos, a compreensão com respeito ás preocupações da industria de software, que não conseguem cobrir as necessidades que o mercado exige. Aliado a isso, está a dificuldade de alterar os currículos acadêmicos.

E o JEDI ?

O JEDI, entra neste contexto de forma totalmente gratuita para a comunidade e disponibiliza todo o acesso aos cursos e materiais. O aluno terá ao seu dispor manuais, slides de apresentação das aulas, provas, exercícios e material de referência e vídeo-aulas. Contando ainda com os softwares, o treinamento de instrutores, o acesso a suporte e a lista de discussão da comunidade.

Na Filipinas já existe uma estrutura acadêmica dividida em fases. Na primeira fase foram disponibilizados os cursos de Introdução a programação I (versão 1.3); Introdução a Programação II (versão 1.1) e Estruturas de Dados (versão1.1). Na segunda fase os cursos de Engenharia de software (versão 1.0); Desenvolvimento de aplicações móveis (versão 1.0); Programação Web (versão 1.0). Na terceira fase, os cursos de Web Services; Segurança em Java e Programação, modelagem e análise orientada à objetos. Completando quatro semestres de curso com: Sistemas operacionais; Gerenciamento de projetos orientados à objetos e Inteligência artificial. Todo este material está atualmente disponível para download, em Inglês, no site Java.net.

A comunidade JEDI tem contribuído bastante para o sucesso desta iniciativa, em todo o mundo existem mais de 80 pessoas contribuindo ativamente. Os treinamentos são realizados pelos membros do JEDI que conduzem os testes e recebem cada vez mais pessoas como voluntárias. O JEDI possui, atualmente, parcerias globais nas Filipinas através de JP Petines (Java champion), no Brasil através de Daniel deOliveira (Java champion), na França através de Vicent Brabant (Java champion) e de coordenações na Malásia, Tailândia, Singapura, Japão e Vietnam.

Hoje o JEDI concentra o maior número de membros nas Filipinas. Desde fevereiro de 2005 até abril de 2006 são 110 escolas - 10% de todas as universidades e faculdades das Filipinas aderentes ao programa; Foram realizados 13 treinamentos e formados 207 instrutores multiplicadores, que formaram 1.318 instrutores que atendem a 48.205 estudantes.

Países de Língua Portuguesa

O Brasília Java Users Group - DFJUG é responsável pela coordenação do JEDI em países de língua portuguesa. Angola, Cabo Verde, Guiné-Bissau, Brasil, Moçambique, Portugal, São Tomé e Príncipe; Timor Leste serão países que poderão fazer o treinamento em língua nativa, com todos os recursos que a iniciativa provê. O DFJUG possui mais de 9.900 membros e é totalmente baseado em trabalho voluntário, sem personalidade jurídica e patrocinado pelo Instituto CTS, OSCIP, voltada para a pesquisa e desenvolvimento de tecnologias de software, que fornece ao grupo apoio logístico, administrativo e jurídico.

Atualmente, o Brasil conta, segundo a SUN Microsystems, com 70 mil desenvolvedores Java e 43 grupos de usuários Java, com mais de 25 mil membros participantes. É através do apoio destes grupos distribuídos em todos os estados da nação que esta iniciativa espera se consolidar, para elevar o nível de aprendizado Java, provendo melhores profissionais para atender as exigências do mercado mundial.

Como participar do JEDI ?

No momento estamos trabalhando na tradução e adaptação do material utilizado na Filipinas. Um vez que este esteja concluído, os cursos poderão ser acessados pelo site. Ao concluir o processo cada aluno terá que fazer uma prova presencial para obter a sua certificação, que será oferecida agentes que serão certificados em todo Brasil.

O DFJUG necessita de pessoas para corrigir e dar opiniões sobre todo o material produzido e realizar testes de Stress no site aonde o JEDI será hospedado, isso é um trabalho que somente poderá ser realizado com o apoio de toda a comunidade javanesa existente no Brasil. Quem quiser participar da iniciativa, no Brasil, deve acessar a página do DFJUG (www.dfjug.org) e entrar em contato com o grupo. Junte-se a nós, participe no instrutor ou como aluno desta iniciativa, poderemos assim enriquecer o conhecimento da linguagem e difundi-la de uma forma totalmente gratuita, voluntária e colaborativa, no Brasil e em diversos paises de língua portuguesa, será seu trabalho e seu empenho que ajudará elevar o Brasil ao hall dos melhores desenvolvedores JAVA no mundo.
Comments


Eduardo Bregaida

Me manda um e-mail ou MP no GUJ e fala tbm com o WilliamSilva do GUJ tbm q vc entra rapidinho =)


Eduardo Bregaida

Boa, está também envolvido no JEDI?

[]s


Israel

Putz cara... vou confessar que só caiu a ficha agora no lance do "nuts" UHAUHAUHAUHUA :D

Vou te colocar no blogroll. Abraços!


Israel

Nunca viu Jericho? Não sabe o que tá perdendo hehehe :)

A propósito, bem legal o teu blog. Gostei muito dos posts. Parabéns.




I Jornada em Defesa do Pensamento Científico
Thu, 16 Aug 2007 13:47:00 -0300

A disciplina de Metodologia Científica do curso de Geociências e
Educação Ambiental do Instituto de Geociências da USP e a Sociedade
Brasileira de Céticos e Racionalistas realizarão a I Jornada em Defesa
do Pensamento Científico.

Abaixo mais detalhes e a programação:
—————
Data: 18 de setembro (terça-feira)
Local: IGc/USP - R. do Lago, 562 - Cid. Universitária - Butantã - São
Paulo - SP

Programação:
09h10 a 09h30: Abertura Prof. Drs. Arlei Benedito Macedo (USP) e
Renato Sabbatini (Unicamp).
09h40 a 10h20: Analfabetismo científico, Prof. Dr. Renato Sabbatini
(Unicamp).
10h20 a 10h40: Café.
10h40 a 11h20: Criacionismo, Prof. Dr. Mário de Pinna (USP).
11h30 a 12h10: Como vender o pensamento não-científico, Prof. Dr.
Francisco Stefano Wechsler (UNESP)
12h10 a 14h00: Almoço.
14h00 a 14h40: Sensacionalismo e Jornalismo Científico, - Ulisses
Capozzoli - Astronomy Brasil).
14h50 a 15h30: Pensamento Crítico - Panorama da América Latina - Sr.
Alejandro J. Borgo (Pensar - CFI/Argentina)
15h30 a 15h50: Café
15h50 a 16h30: A defesa do pensamento científico nas universidades e
centros de pesquisa (mesa-redonda).
16h40 a 17h10: Resultados preliminares da pesquisa sobre
Pseudociências (alunos do LIGEA)
19h00 a 19h40: Ilusões e equívocos do pensamento humano, - Dr. Sérgio
Navega - (Intelliwise Research and Training).
19h40 a 20h00: Sumário e encerramento, - Prof. Dr. Francisco Stefano
Wechsler - UNESP).

Taxa de inscrição: R$ 60,00
Mais informações: palestrasreflexoes2007@gmail.com


Implementando um Corretor Ortográfico
Sat, 11 Aug 2007 23:56:00 -0300

O maluco do Peter Norvig (google) publicou no seu site o artigo How to Write a Spelling Corrector. Impressionante o que 21 linhas de Python são capazes de fazer!

>>> correct('speling')
'spelling'
>>> correct('korrecter')
'corrector'


Não é atoa que o Google é o que é hoje em dia.


Linux para Leigos
Sat, 11 Aug 2007 10:45:00 -0300

Vamos analisar a condição de leigo.

Eu já vi centenas de leigos que, ao sentar no computador, baixavam músicas, videos e jogos com os mais diversos programas, conectavam no irc, msn, icq, colocavam luzinhas e bichinhos animados para acompanhar o cursor do mouse, trocavam as fontes e os temas, procuravam os mais bizarros jogos, encontravam videos extremamente incomuns (sem youtube), etc. Para o que não presta, os leigos tem uma criatividade impressionante!

Quando falamos em um sistema pra leigos não precisamos pensar que as usuarios tem preguiça mental. Eles até podem ter, mas aí cabe aos projetistas desafiar e exercitar essa criatividade do mal e tranformar em criatividade do bem. Qualquer pessoa que senta na frente de um browser vai acabar nas paginas mais escabrosas mesmo que não sabia o que é 'google'. Vai me dizer que, nesse caso, a linha de comando é ameaçadora ou difícil?

Das duas, uma: ou pensamos em uma camada de software para permitir que um usuario abstraia o sistema operacional e as configurações (normalmente se faz isso em sistemas "embarcados") e use todos os recursos multimídia e de troca de informação com a facilidade de um pensamento OU pensamos em sistemas mais inteligentes, com documentação adequada e, com a ajuda da comunidade, divulgamos as informações e conceitos corretos. O Linux só é seguro porque o usuario comum, que vai fazer besteira, não tem a senha de root.

Não podemos fazer sistemas operacionais à prova de gente sem noção ou que sejam capazes de oferecer tanta intuitividade sem sacrificar a segurança, por exemplo.

Puxa, não tem nada mais fácil que usar a linha de comando (ok, sou suspeito pra falar). As pessoas não usam [o shell] pois não tem como acessar o orkut, ver vídeo do youtube, etc, de um jeito bonitinho. Alem de tudo, tá em inglês, ECA. Hoje em dia existem shells para pessoas iniciantes que ajudam, colorem o texto e sugerem mudanças praticas, como o fish.

É assim que fazemos um sistema pra leigos -- temos que desafia-los a usar a criatividade que normalmente é usada pra criatividade do MAL e mostrar que um PC com linux não é um playstation. Quer usar um browser de verdade e usar o orkut e o youtube? PO! não tem nada mais facil que instalar um ubuntu da vida e clicar no icone do firefox!

Não vamos tomar atitudes de forma a não desafiar intelectualmente os usuários. Eles merecem todo o nosso respeito. Agora quem quer que o usuário não pense que faça uma camada de software que abstraia o Sistema Operacional. Existe mercado para ambas as coisas.

Entretanto acho mais humano que a gente exercite os cérebros atrofiados dos empurradores de mouse. Há 20 anos as pessoas usavam computadores com 32 kb de RAM e carregavam os jogos de uma fita K7 e ninguem morreu por isso -- pelo contrário desenvolveram skills hoje necessárias em muitos cargos importantes e empresas como algumas multinacionais procuram desesperadamente.


Torvalds - A Microsoft simplesmente não me interessa
Fri, 10 Aug 2007 00:53:00 -0300


Será que Linus Torvalds e a comunidade do software livre podem vencer esta guerra contra as legiões de Bill Gates?

Linus Torvalds - Não vejo isso como uma “batalha”. Faço o que faço porque gosto e acho que vale à pena, e não estou nessa por causa de nenhuma cruzada anti-Microsoft. Usei alguns produtos da Microsoft ao longo dos anos, mas nunca nutri uma forte antipatia contra eles. A Microsoft simplesmente não me interessa. E o movimento de código aberto não é um movimento anti-Microsoft, apesar de haver certos grupos que talvez participem devido aos seus sentimentos anti-Microsoft.

O código aberto é um modelo sobre como fazer coisas, e eu acredito que este é um jeito muito melhor de fazer as coisas. O código livre vai tomar conta do mercado não por causa de nenhuma “batalha”, mas simplesmente porque jeitos melhores de fazer as coisas eventualmente tomam o lugar de métodos inferiores.

Por acaso a “ciência” é uma batalha contra a “ignorância”? Não, a ciência simplesmente é. E ela funciona tão bem que assume o lugar de velhas noções ignorantes. Não precisamos nos preocupar com gatos pretos cruzando a nossa frente, passar por baixo de escadas ou espelhos quebrados, pois hoje sabemos como o mundo funciona, e nos demos conta de que gatos pretos não são mais um sinal de perigo.

Fonte: idgnow

Sem mais palavras...


Google Wars
Tue, 07 Aug 2007 18:43:00 -0300

Inutilidade Pública: veja o que/quem possui mais resultados no google?

./GoogleWars.sh superman batman
batman 48500000
superman 33700000

./GoogleWars.sh gremio inter
inter 213000000
gremio 5560000

./GoogleWars.sh hp ibm
hp 379000000
ibm 147000000

./GoogleWars.sh cobol java fortran perl ruby lisp haskell
java 272000000
perl 103000000
ruby 101000000
lisp 21400000
fortran 17400000
haskell 15400000
cobol 10900000

O script é simples, abusando um pouco do SED e do AWK, com um toque de SORT ;-)

#!/bin/bash
COR=`echo -ne '\e[31;1m'`
END=`echo -ne '\e[m'`
CORSED="1s/.*/${COR}&${END}/"
GOOGLE='http://www.google.com/search'

[[ $2 ]] || { echo "usage: $0 item item2 [ ... item n]" ; exit 0 ; }

SEDCMD='/did not match any documents/{s/.*/0/g;p;q}
 /Results/{s/.* about[ ]\+\([0-9,.]\+\).*/\1\n/;p;q}'
AWKCMD='{ result[$1]=$2 ; x = length($1) ; if(x > max) max=x }
 END{ for(i in result) printf "%-"max"s\t%s\n",i,result[i]}'

for i in "$@" ; do echo -ne "${i}\t" 
 lynx -dump "${GOOGLE}?q=${i}" | tr -d '\n.,' | sed -n "${SEDCMD}" 
done | awk -F '\t' "${AWKCMD}" | sort -nr -t $'\t' -k 2 | sed "${CORSED}"


Quem quiser melhora-lo, sinta-se à vontade :)

Edit: ja lancei uma versão .02 com umas correções cosméticas aqui -- não resisti...


Considerações de Segurança
Mon, 06 Aug 2007 14:21:00 -0300

Me irrita profundamente usar um script que pressupõe certas definições no meu ambiente sem aviso prévio. O caso mais comum é, em algum *nix, acreditar que o diretório corrente faz parte do PATH -- contrariando uma regra básica de segurança, inclusive.

Não é dificil fazer ./programa (na verdade com o tempo isso vira padrão até). Fica uma dica importante: nunca façam suposições a respeito do ambiente, variaveis, estruturas de diretórios sem documentar ou fazer os testes necessários (pelo menos quando for fora de algum padrão).


Nightwish - Wishmaster Versão Alternativa
Fri, 03 Aug 2007 20:23:00 -0300

Sensacional esta 'versão':



Hamster - Apprendice - HeartBurn - Seven Seagals - Mario - this Apple - in me - Jewish Master !

Se não conseguiu visualizar clique aqui.


Caçadores da Classe Perdida
Fri, 03 Aug 2007 16:20:00 -0300

Eu já tinha feito algo parecido mas este post do Claudio Miranda reavivou a minha memória.

#!/bin/bash
[[ $2 ]] || { echo "Uso: ${0} diretorio classe" ; exit 1 ; }
find "${1}" -name \*.jar -print | xargs -n 1 unzip -l 2>&- | awk -v class="${2}" '
 BEGIN { IGNORECASE=1 }
 /^Archive/ { file="\nArquivo:\n\t"$NF": \nClasses:\n\t" }
 /class$/ && $NF ~ class { print file,$NF ; file="\t"; total++ }
 END { print "\nTotal",total + 0,"classes encontradas!" }'


Informando como parâmetros um diretório de partida e um fragmento do nome da classe, o find localizará todos os arquivos com extensão jar e vai mandar pro nosso amigo xargs. Este envia um a um para o unzip que lista (-l) o conteúdo de cada arquivo. Eu poderia procurar a classe que eu quero com o grep, mas o awk foi a escolha para formatar melhor a saída de dados.

Perceba que a variavel IGNORECASE tem valor diferente de 0, assim eu posso procurar por um trecho do tipo xml ou XML. Eu preciso saber o nome do arquivo 'corrente' e isso é informado pela linha que começa com 'Archive'. Quando eu encontro uma linha que termina com 'class' e o ultimo campo ( $NF ) 'casa' com o fragmento de nome (alias pode ser uma expressão regular!) eu imprimo esta linha.

Eu fiz uma sacanagem pra saída de dados ficar 'bonitinha', que é imprimir o 'cabeçalho' apenas uma vez, depois eu troco por tab (\t) -- e no final eu mostro um sumário com o número de referências encontradas.

Este script pode ser modificado para outros propósitos. Note que eu procuro tanto no nome da classe quando no nome dos pacotes (diretórios), assim xml poderia casar com XMLHelper.class ou /java/xml/foobar.jar -- mas basta ser criativo para resolver isso!
Comments


Tiago Peczenyj

AWK é extremamente versátil!


Claudio Miranda

Olá Tiago, obrigado pela dica-dica e manter a formatação de saída. Vou aprender um pouco mais de AWK.




Powders Graduation
Thu, 02 Aug 2007 16:31:00 -0300

Os programas de tradução estão cada vez melhores.

Pós Graduação = Powders Graduation

Graduação em Pó? Pulverizada?

São 22 resultados no google até o momento!


Usando o curl com Endereços IPv6
Thu, 02 Aug 2007 13:28:00 -0300

Hoje em dia usar endereçamento IPv6 parece um pouco exótico, porém aos poucos ele começa a aparecer em algumas redes internas e logo será a unica saída quando todos os 32 bits do IPv4 estiverem em uso, previsto para 2012.
 
Diga adeus ao "206.45.32.234" - longa vida ao "2001:bce4:5641:3412:341:45ae:fe32:65". Perceba como agora utilizamos a representação hexadecimal e cada quarteto é separado por um ':' -- o que torna mais fácil a sua memorização (e viva o DNS). Um bom artigo introdutório pode ser lido aqui.

Pois bem, imagine agora que precisamos acessar uma pagina em um servidor (por enquanto interno) através de um endereço IPv6. A url ficaria assim, por exemplo:

http://[2001:bce4:5641:3412:341:45ae:fe32:65]:8000/index.php


Como o caracter ':' é usado em uma url para separar o servidor da porta (é claro que isso é omitido na maioria dos casos, quando usamos a porta 80), e tiveram que proteger o ip entre [colchetes]. Um browser como o Firefox consegue entender esta url facilmente, entretanto não tive a mesma sorte ao usar os browsers modo texto mais comuns - lynx e o curl. 

Não subestime a importância destes browsers! Muitas vezes nos encontramos em um sistema com poucos recursos ou precisamos efetuar certas ações via algum script e eles caem como uma luva -- principalmente o curl, que simplesmente transfere informações de/para um servidor web, fazendo GET, POST, HEAD, upload de arquivos, etc. 

No man do curl descobri que o mesmo depende da libcurl ser capaz de resolver endereços ipv6 - inclusive posso forçar a usar apenas ipv6 com a opção -6.

Entretanto o curl tem outra interpretação dos colchetes em uma url -- elas são um recurso de sequência para multiplos downloads (da mesma forma como o bash faz, porém é interno ao curl), como nesse exemplo:

curl 'http://www.any.org/archive[1996-1999]/volume[1-4]part{a,b,c,index}.html'


Para desabilitar este "URL globbing parser" basta usar a opção -g, o que nos leva a solução completa:

curl -6g 'http://[2001:bce4:5641:3412:341:45ae:fe32:65]:8000/index.php'


Caso não queria desabilitar o globbing, basta 'escapar' os colchetes usando a contra-barra antes. O curl é um programa extremamente versátil, um verdadeiro canivete suíço na linha de comando, vale a pena estuda-lo em algum tempinho livre.


Barbosa
Thu, 26 Jul 2007 14:09:00 -0300

Trinta e oito anos depois da Copa do Mundo de 1950, um homem volta no tempo a fim de impedir o gol que derrotou o Brasil, destruiu seus sonhos de infância e acabou com a carreira do goleiro Barbosa.

Premiadíssimo curta de Jorge Furtado e Ana Luiza Azevedo, de 1988, unindo ficção científica e futebol de uma forma incrivelmente brasileira. Com Antônio Fagundes e Zé Vitor Castiel.

Para saber mais: CASACINEPOA

Assista aqui. Vale a pena!


Resolvendo Problemas Comuns 7 - open failed: |
Thu, 26 Jul 2007 14:03:00 -0300

Imagine um arquivo com algumas linhas duplicadas:
$ cat arquivo
permission denied
bad interpreter
missing separator
set correct localle
parameter list too long
unary operator expected
parameter list too long
bad interpreter


Obter as linhas distintas pode ser feito com a ajuda do sort + uniq

$ cat arquivo | sort | uniq
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected


 - Puxa! Que ótima combinação! Vamos guarda-la?

Bom, podemos querer guardar este e outros comandos em uma variável de ambiente também, afinal, deve funcionar sem maiores problemas, certo?
$ CMD="sort | uniq"
$ cat arquivo | $CMD
sort: open failed: |: No such file or directory


 - OPA! Eu sabia, maldito shell, encrenca com tudo!
 
Tsc... isso acontece porque o pipe | não foi informado como um 'pipe' e sim como a string "|" -- e o sort não conseguiu abrir o arquivo "|".
Este tipo de problema pode ser resolvido pelo eval -- ele interpreta novamente as strings na linha de comando.
$ eval "cat arquivo | $CMD"
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected


 - Ah, agora funciona. Mas esse eval ai ficou feio...

Então vamos criar um alias para o comando!
$ alias cmd="sort | uniq"
$ cat arquivo | cmd
bad interpreter
missing separator
parameter list too long
permission denied
set correct localle
unary operator expected


Perceba que o comportamento do alias é diferente de uma variavel de ambiente. Devemos ficar atento à correta interpretação da nossa linha de comando pelo shell corrente, senão vamos ter resultados nem sempre amigáveis.

Ah, sim, o cat nesse exemplo é completamente supérfluo, poderia ser assim: 'sort arquivo | uniq' 

 - E o uniq precisa do sort ? 
 
Sim... sem o sort ele fatalmente vai se perder, e é muito mais facil eliminar linhas repetidas que estejam em sequencia do que aleatórias. É bom dar uma lida no man destes comandos pois possuem opções muito poderosas!
Comments


Tiago Peczenyj

Claro, sort + uniq é um prato cheio! 

Uma coisa interessante é nessa dupla é, por exemplo, imprimir apenas as linhas repetidas ou não repetidas de um texto (opções -u ou -d) e, quando a entrada vem ordenada, o resultado é extremamente confiável.

Entretanto não lembro se não existe algum furo no sort -u apenas, vou pesquisar.

Abração!


Alexsander

Olá! muito boas as dicas q tens disponibilizado!
só uma sugestão:
"sort -u" também remove duplicidades.
abraços
t+




Resolvendo Problemas Comuns 6 - unary operator expected
Thu, 26 Jul 2007 13:07:00 -0300

Uma desatenção, muito comum quando trabalhamos com variáveis de ambiente no shell é que, quando elas não foram setadas ainda, o shell expande elas para... nada.

$ [ $XALALA == "oi" ] && echo 'ok' || echo 'nok'
-bash: [: ==: unary operator expected
nok


Nesse caso o (resultado do) teste da variável até pode fazer sentido, porém troque o == por um != e veja o resultado. A solução é proteger a variável com aspas!

$ [ "$XALALA" != "oi" ] && echo 'ok' || echo 'nok'
ok


Simples e rápido!
Comments


Tiago Peczenyj

Bah, não tinha reparado nisso.

E faz sentido, afinal [[ é built-in e [ é, geralmente, um apelido para o comando /bin/test

valeu!


Cláudio

Outra solução: usar [[ ]] ao invés de [ ].




Resolvendo Problemas Comuns 5 - The parameter list is too long
Thu, 26 Jul 2007 12:50:00 -0300

Essa é raro, mas acontece

$ cd /meu/diretorio
$ rm *.dll
Error: The parameter list is too long

 - O que? Eu não posso apagar todos os meus 3459834574935734957 arquivos?

Bom, primeiro vamos analisar o que aconteceu: a linha de comando 'rm *.dll' é expandida pelo shell corrente a 'rm arquivo1.dll arquivo2.dll ... arquivoN.dll' e, nesse caso, esta lista de parâmetros foi demais pro probrezinho do rm. 

Com o xargs é facil de resolver!
$ find /meu/diretorio -name '*.dll' -print | xargs rm

O que ele faz? o xargs recebe pela stdin toda uma lista de parâmetros que será entregue ao programa rm. Se esta lista extender o limite do sistema, então o xargs, inteligentemente, irá executar o rm uma vez, com a lista que for possível e, depois, executar de novo, até que todos os parâmetros sejam lidos. Aliás o xargs possui muitas opções interessantes, vale a pena dar uma estudada nele.

E assim todas as dll's são apagadas -- em definitivo, pois com rm 'tr00' não tem undelete ;-)
Comments


Tiago Peczenyj

Ah sim, quem limita/expande os coringas é o shell. Acho que escrevi uma frase ambígua -- valeu!


eljunior

na verdade a lista de parâmetros não foi demais para o `rm', quem limita isso é o próprio shell (tanto é que, num caso desses, nem um ls * funciona...). também não funcionaria somente `xargs rm', se fosse limitação do `rm'; seria necessário limitar a quantidade de parâmetros com a opção -n pro `xargs'. ;-)

nas máquinas que usei, o limite do bash geralmente fora 32768 parâmetros...

falou!




Resolvendo Problemas Comuns 4 - Corrigindo o localle
Thu, 26 Jul 2007 12:20:00 -0300

Precisamos estar atento que as variáveis de ambiente de localização podem atrapalhar, e muito, o comportamento de algumas expressões regulares.

Por exemplo, se eu quero encontrar uma palavra que começe com a e termine com o (ex: ação)
$ cat arquivo
luz, camera, ação
$ grep -oE 'a\w+o' arquivo # nao mostra nada!

Antes de sair dizendo que o linux, grep ou as expressões regulares não prestam, vamos testar o mesmo comando no nosso 'idioma'
$ LC_ALL=pt_BR grep -oE 'a\w+o' arquivo
ação

Ahá! Agora vamos ver um exemplo mais interessante:
$ tr '[:lower:]' '[:upper:]' < arquivo
LUZ, CAMERA, AçãO
$ LC_ALL=pt_BR tr '[:lower:]' '[:upper:]' < arquivo
LUZ, CAMERA, AÇÃO

Perceberam como a variavel altera o comportamento das ERs? 

Como ultima dica: sempre que precisarem comparar textos independente da 'caixa' (se maiúscula ou minúscula), usem os recursos de ignorecase da ferramenta utilizada. Converter um texto todo para minúscula pode não apenas ser afetado pela localização como existem idiomas onde alguns caracteres não tem o exato correspondente entre uma caixa e outra como nós pensamos -- é o caso do idioma Turco, onde o 'i' maiúsculo não é 'I'. E, principalmente, não tente fazer isso.

Mais informações em 'man locale' ;-)


Resolvendo Problemas Comuns 3 - missing separator
Thu, 26 Jul 2007 11:44:00 -0300

O make é um comando incrivelmente poderoso, principalmente para programadores, permitindo que tarefas sejam organizadas de acordo com dependências, por exemplo.

Um caso básico seria construir um grande programa, composto de diversos arquivos-fonte. O Makefile permite que vc compile apenas os arquivos que vc alterou desde o ultimo build, por exemplo, comparando o timestamp do fonte com o codigo objeto gerado.

Bom, ai um Makefile poderoso foi editado num editor de texto profissional e, na hora de testar, nos deparamos com:
$ make 
Makefile:3: *** missing separator (did you mean TAB instead of 8 spaces?). Stop.

$ cat Makefile # nome padrão de arquivo para o make.
# um makefile comum
all:
 @echo "oi mundo"


Puxa, parece tudo certo... entretanto ai vai um pequeno detalhe: para cada target do makefile, os comandos que vem a seguir devem começar por um TAB (alias a mensagem de erro é bem clara nesse sentido, certo?). Vamos conferir:

$ cat -A Makefile # é mais pontente que o -v
# um makefile comum$
all:$
 @echo "oi mundo"$

 
Tcharam! Se a linha do echo iniciasse com um TAB, como deveria ser, apareceria um ^I no inicio da linha. Provavelmente a origem disso é um editor de texto que transforma os TABS em 8 espaços por questões estéticas. Vamos corrigir o Makefile?

$ sed -i 's/^\ \{8\}/\t/' Makefile
$ cat -A Makefile
# um makefile comum$
all:$
^I@echo "oi mundo"$
$ make
oi mundo


Pronto, basta substituir os espaços por TAB. Outra solução corrigir em um editor de textos mas sem a opção de expansão dos TABs -- no vim basta fazer

:set noexpandtab


e editar numa boa.


Resolvendo Problemas Comuns 1 - Permission denied
Thu, 26 Jul 2007 11:12:00 -0300

Não é incomum, quando não temos experiência em shell, passar por uma situação dessas:

$ ./script.sh
-bash: ./script.sh: Permission denied


Antes de sair olhando se há algo errado com o script, vamos analisar a mensagem de erro em pt_BR: Permissão negada. Diferente de outros sistemas operacionais, no mundo *nix o que faz de um arquivo um programa executável não é a sua extensão e sim as suas permissões.

Resumidamente, existem 3 permissões básicas quando se trata de arquivos: ler, escrever e (finalmente) executar (representado pelas letras r,w e x, respectivamente). Isto é o que impede um usuário de conseguir ler os documentos de outro, por exemplo. Então, um programa, para ser executado, precisa ter esta permissão correspondente, e ai entra o comando chmod.

$ ls -l script.sh
-rw-r--r-- 1 peczenyj users 22 2007-07-26 11:08 script.sh
$ chmod +x script.sh # vamos ativar o bit de execução (x)
$ ls -l script.sh
-rwxr-xr-x 1 peczenyj users 22 2007-07-26 11:08 ./script.sh
$ ./script.sh #agora sim!!!
oi


Problema resolvido.


Resolvendo Problemas Comuns 2 - bad interpreter
Thu, 26 Jul 2007 11:07:00 -0300

Seguindo na nossa sessão de dicas, quem nunca passou por isso?

$ ./script.sh
: bad interpreter: No such file or directory

$ cat script.sh
#!/bin/bash
echo "oi"

 - Hein? Mas está tudo certo, eu tenho um /bin/bash, o que está acontecendo?

Bom, vamos ver mais de perto:
$ cat -v script.sh # 'show nonprinting'
#!/bin/bash^M
echo "oi"^M


Ahá! Tem um ^M no final das linhas atrapalhando. 
 - Mas o que é isso?
Muito provavelmente a origem desde script é uma maquina windows. A explicação é o caracter newline. O windows precisa de 2 caracteres para simbolizar o fim de uma linha em um arquivo texto puro, a dupla \r\n (veja link para a wikipedia), porém os *nix não precisam do \r -- que o cat gentilmente mostrou como um ^M. Este caracter a mais atrapalha o interpretador, que não recebe um /bin/bash e sim /bin/bash\r -- e isso realmente não existe.

Como resolver? Existem dois programas para este fim: unix2dos e dos2unix (as vezes aparecem como unixtodos e dostounix) que convertem os finais de linha em casos como este. Se vc abrir um arquivo texto do *nix em um bloco de texto vai ver todas as quebras de linha substituidas por um quadrado preto e todas as linhas em uma só.

Caso vc não tenha um programa conversor, pode usar o SED
$ sed -i 's/\r$//' script.sh
$ ./script.sh
oi


O tr também poderia ser usado, mas não é tão amigável.
$ tr -d '\r' < script.sh > novo_script.sh


Este detalhe pode ser muito importante um dia!
Comments


arpapa

Pode também converter usando o comando dos2unix script.sh que funciona legal.


Rioges

Resolveu o meu problema, muito obrigado pela dica!!




Tio Maneco
Thu, 26 Jul 2007 02:26:00 -0300

Quem se lembra do Tio Maneco?

Pois bem, descobri que foi aprovada a captação de recursos para a produção do filme "As aventuras de Reina Caiman em o resgate do Maneco" (RF Cinema e TV Ltda).

Pra mim, este é o filme mais esperado de todos os tempos, mal posso esperar para ver o Flávio Migliaccio de novo, em um dos papeis mais legais e inteligentes da tv brasileira -- afinal os filmes são impossiveis de serem achados e a série original foi apagada acidentalmente pela tv cultura.

(se alguem tiver mais informações, please, me avise!!!)
Comments


Tiago Peczenyj

Sim, o Flávio tava processando a Cultura até. Não sei a quantas anda isso, o que é uma pena pois eu tinha boas lembranças da série.

Nem lembro do nome dos Robos feitos com bules e chaleiras :(


panglossa

É verdade que foi tudo perdido? "Apagado acidentalmente"?




Calculando Números Primos usando Shell
Thu, 26 Jul 2007 01:48:00 -0300

Será possivel determinar se um número é primo, ou não, usando o bom e velho shell?

A resposta está no comando factor

seq 1 250 | factor | awk -F \: '$1 == $2{ print $1}' | column -x
2 3 5 7 11 13 17 19 23 29
31 37 41 43 47 53 59 61 67 71
73 79 83 89 97 101 103 107 109 113
127 131 137 139 149 151 157 163 167 173
179 181 191 193 197 199 211 223 227 229
233 239 241


A ideia é simples: se um número é primo ele possui apenas um único fator -- ele mesmo. Basta detectar esses casos via awk (ou grep, sed, existem varias formas). Usei aqui o seq para gerar uma seqüência e o column para tabular os resultados.


Identificando linhas repetidas em varios arquivos
Thu, 26 Jul 2007 00:10:00 -0300

Vamos imaginar dois arquivos bem simples e tres formas de identificar as linhas que aparecem em ambos:

$ cat arq1
oi
awk
ciencia
oi zoi

$ cat arq2
luxo
awk
oi
luxo


Simples de perceber que as linhas 'oi' e 'awk' se repetem. Poderiamos pensar em uma poderosa união de sort + uniq 
$ sort <(sort arq1 | uniq) <(sort arq2 | uniq) | uniq -d
awk
oi


Ou podemos abordar arrays em AWK (elegante, não?)
$ awk 'NR==1{ base=FILENAME } 
base == FILENAME {linhas[$0]++}
base != FILENAME && linhas[$0] { print }' arq1 arq2
awk
oi


Ou podemos usar o bom e velho grep:
$ grep -xf arq1 arq2
awk
oi

Qual a melhor abordagem? Ai depende de cada um :)

Veja toda a aula que deu origem à estes scritps aqui.
Comments


Tiago Peczenyj

Denis, mantive os seus dois comentarios, apesar de serem semelhantes.

Saca só, se pensarmos em 16 milhões de linhas, temos q pensar exatamente no que queremos. se for para encontrar as linhas exatas, talvez o grep seja mais rápido, porém acredito que vai ter muito acesso a disco.

Se separarmos os arquivos em partes, de acordo com os caracteres iniciais, acho que a pesquisa pode ficar bem mais rapida -- se estiverem ordenados então vai q é um tapa.

Ou talvez seja o momento de pensar em algoritmos mais complexos :)


Denis

Imagino que para um busca menor de 16milhoes a melhor seria o grep, pois nao utiliza os redirects como no caso do UNIQ.


Denis

Imagino que para um busca menor de 16milhoes a melhor seria o grep, pois nao utiliza os redirects como no caso do SORT. Se nao o AWK.




As Origens do Caos Aereo Brasileiro
Wed, 18 Jul 2007 21:33:00 -0300

O dia 17 de julho será lembrando, infelizmente, como a data do pior desastre aéreo em território Brasileiro. Todos os meios de comunicação enviam maciçamente informações, fotos e, sobretudo, opiniões de especialistas sobre o assunto. Não há como não se envolver -- principalmente no Rio Grande do Sul, o estado de origem da maioria dos passageiros.

As opiniões se dividem: terá sido erro do piloto (que não está aqui para se defender), a pista estava com problemas ou terá sido um acidente inevitável? 

Independente da resposta, a explicação do inegável Caos Aéreo Brasileiro não está em uma Caixa-Preta, ou em Tapes de Conversa de pilotos com a torre, não foi culpa dos Controladores de Vôo muito menos do Clima. Engana-se quem acha que tudo começou com o acidente da Gol.

A resposta vem em uma apresentação do presidente da Andep (Associação Defesa dos Direitos dos Passageiros do Transporte Aéreo) Cláudio Candiota Filho, na CPI do Apagão Aéreo. Especialista no ramo que, humildemente, cedeu uma cópia para que todos possam ver o inegável desmantelamento do setor aéreo e a fome de cargos corrupta que aniquilou o sistema de aviação civil brasileiro.



Link direto para a apresentação: aqui.

Minhas condolências a todos que perderam um ente querido ou sofreram com este terrível acidente.
Comments


Tiago Peczenyj

Opa, Valeu! Tche, andei fazendo umas pesquisas estes dias, vem coisa nova aí em breve.


NetWalker

Saudações Peczenyj.
Descobri teu blog há alguns posts atrás. E já chamou-me a atenção pela qualidade dos posts, sobretudo pelas citações de Rogue e The Last Star Fighter (old memories :), bem como demais "assuntos computacionais".
Não detectei a freqüência com que o atualiza, mas fica aqui um pedido de um leitor assíduo que já até realizou um fork de seu youtube downloader: continue a postar. :)
Espero que não tenha perdido algúem próximo, nesse terrível descaso "Brazileiro". Sobre o qual a "vergonha cidadã" impede-me de tecer maiores comentários.
No mais, fica meus agradecimentos pelas contribuições em conhecimento e pelo youtube downloader.
[]s (NetWalker)




Baixando musicas do iJigg
Wed, 18 Jul 2007 14:54:00 -0300

O iJigg é um youtube de mp3, basicamente. É interessante para trocar músicas ou mesmo colocar um pequeno player no seu site, como este:


Escolhi a musica Surfista Calhorda, dos Replicantes. Conheci este site graças a esta dica do dicas-l.

Como todo bom nerd, decidi melhorar a dica, provendo um script para isso.

#!/bin/bash
[ -z "${1}" ] && { echo "usage: $0 < ijigg URL | ID >" ; exit 1 ; }
ID=${1##*/}
CMD='/Location\|Title/{s/<[^>]\+>//g;p}'
URL="http://www.ijigg.com/cgi-bin/loadSongData.cgi?songID=${ID}"

set - $( wget -q -O - "${URL}" | sed -n "${CMD}" | tr '\n ' '\t_' )

wget ${1} -O "${2%.mp3}.mp3"


Ao executar e passar a URL ou ID da música como argumento, eu faço uma busca no site atras de informações sobre a mesma (veja variavel URL). Esta consulta é um xml que retorna a localização do arquivo mp3 e do seu nome. Faço uns malabarismos com SED -- que nem são tão complicados assim -- e obtenho a url direta para baixar o arquivo e o seu nome em um bom formato (troco os espaços do nome por '_' -- para permanecer os espaços no nome tem q fazer mais uns malabarismos...).

Nesse caso:$ ./ijigg.sh http://www.ijigg.com/songs/V2DA7ADPD
--15:10:05-- http://staticmdb-001.ijigg.com/songdata04/...
 => `Replicantes_-_Surfista_calhorda.mp3'
...
15:10:55 (33.26 KB/s) - `Replicantes_-_Surfista_calhorda.mp3' saved

Agora basta ouvir no seu player preferido.


Battlestar Galactica
Mon, 16 Jul 2007 22:14:00 -0300

Simplesmente a melhor série de ficção científica dos ultimos anos. A série é um remake de um clássico dos anos 70 -- surgida na esteira de Star Wars, mostrando os últimos humanos percorrendo as profundezas do espaço atras da mitológica Terra. O diferencial eram as batalhas dos caças Vipers contra as forças robóticas Cylons -- com o temível olho vermelho cintilante.

A nova série possui um grande diferencial: a ausência total de tecnobobagem e o clima extremamente realista e muito similar ao nosso mundo. Tirando o fato de usarem naves, eles fumam, sofrem, amam, brigam, morrem... até as armas são metralhadoras e pistolas comuns.

Isso prova que a boa ficção não são efeitos especiais ou badulaques e sim a força dos seus conceitos. Estes sobreviventes veneram os deuses gregos, mas são tão imperfeitos quanto nós. Destaque para o General Tigh com seu péssimo humor e alcoolismo crônico. Não é uma série que eles usam difratores de fótons ligados numa matriz parabólica -- eles gritam "MORRAM TORRADEIRAS" e mandam bala nos robos assassinos [quando não usam ogivas atômicas -- alguma graça tinha que ter].

Alias, robôs estes que estão muito diferentes, lembrando muito Blade Runner - aliás o novo Capitão Adama é o ator Edward James Olmos, que interpretou o enigmático Gaff no filme de Ridley Scott. 

É uma série com muita energia, desespero, ação e roteiros muito inteligêntes. Temas incomuns como tortura, esquadrões da morte e estupro ja foram abordados, mostrando que é possivel ser adulto no universo FC. As filmagens no espaço são muito realistas e é a unica série de naves que as pessoas fazem sexo!

Se vc não se importa em ver uns spoilers da terceira temporada, veja a cena que, na minha opinião, e a melhor de todos os tempos!


Passa na Tv a Cabo e os DVDs estão a venda -- começe pelo piloto de 3 horas e não vai se arrepender.
Comments


Tiago Peczenyj

Ora... temos os DVDs :)


Juliana

poxa, e eu não terminei de ver a segunda temporada ainda. :/




Frente quer proibir aborto em caso de estupro
Mon, 16 Jul 2007 15:13:00 -0300

Sinto muito mas... isso me deixa indignado.

Criada em abril passado, a Frente Parlamentar Contra a Legalização do Aborto - Pelo Direito à Vida tornou-se um dos grupos mais atuantes do Congresso Nacional. Os 199 parlamentares, entre deputados e senadores - o que representa 33,5% das duas Casas - têm agitado os corredores da Câmara e prepara uma nova ofensiva: a distribuição de uma cartilha intitulada "Por que Somos Contra o Aborto", com 30 mil exemplares. A versão preliminar da cartilha, editada pelo presidente da frente, deputado Leandro Sampaio (PPS-RJ), não só combate a legalização do aborto como critica a autorização para a interrupção da gravidez nos casos de estupro, como prevê a lei atual. O aborto em caso de risco para a mãe, outra hipótese permitida pelo Código Penal, é questionado na cartilha, com o argumento de que os avanços da medicina permitem salvar vidas mesmo em casos de extrema gravidade. O debate em torno do aborto ganhou força desde que o ministro da Saúde, José Gomes Temporão, considerou a prática um problema de saúde pública e lançou a proposta de que a sociedade discuta uma nova legislação sobre o tema. Hoje, tramitam na Câmara 19 projetos sobre aborto. 

Sinceramente... que p$#@$ de país é esse? Não basta termos um investimento ridículo em educação e cultura, deixar os investimentos em ciências à beira do ridículo, termos um dos piores sistemas de saúde do mundo, leis que não funcionam, etc, e ainda temos q ver mais um retrocesso?

Sério... todo o brasileiro que chega a idade adulta é um milagre, ja dizia o Pasquim -- graças à políticos como estes. O que virá depois: Criacionismo nas escolas?

Obrigado, Brasil.


Lucas 14 anos - urgente - Doadores Porto Alegre
Sun, 15 Jul 2007 14:20:00 -0300

Lucas 14 anos - urgente - Doadores Porto Alegre

Repassando o apelo de André Parodi: O meu sobrinho Lucas,fez uma cirurgia no cerebro,e precisa URGENTE de doadores de sangue de qualquer tipo, pois, ele faz um tratamento com plaquetas ( 1 bolsa a cada 8 horas ),precisamos de 42 doadores.A Familia esta mobilizada.Contamos com a sua ajuda.
Hospital da PUC Sao lucas / Banco de Sangue 2 andar
Paciente: LUCAS PARODI SPIER AS FAMILIAS PARODI SPIER AGRADECEM

Doar sangue é uma das coisas mais bonitas que podemos fazer - ajudará não apenas esse garoto como muitas outras pessoas com o plasma, por exemplo. Vamos difundir esta mensagem tanto quanto difundimos os nossos sistemas operacionais, browsers e gadgets preferidos.


Piadas de Programador
Fri, 13 Jul 2007 20:53:00 -0300

Why do programmers always get Christmas and Halloween mixed up?
Because DEC 25 = OCT 31

Essas e outras vc encontra em profession jokes.


O que mais falta inventar...
Fri, 13 Jul 2007 13:13:00 -0300



Which OS are You?



Which Programming Language are You?



Which File Extension are You?


Introdução aos Device Drivers no Linux
Thu, 12 Jul 2007 17:17:00 -0300

Vamos fazer um /dev/hello_word ?

Aprenda a fazer um neste fascinante artigo -- nunca se sabe quando será util!


Printf Format Specifications Quick Reference
Thu, 12 Jul 2007 15:38:00 -0300

Tudo o que vc sempre quis saber sobre o printf mas tinha medo de perguntar:
http://www.pixelbeat.org/programming/format_specs.html


Bases Numericas em Bash
Thu, 12 Jul 2007 11:49:00 -0300

Com Bash, podemos representar números nas mais variadas bases, desde 2 até 64 usando o operador # como no exemplo abaixo:
X=101 
for BASE in 2 8 10 16 32 64 ; do 
 echo "$X na base $BASE eh $(( ${BASE}#${X} ))" # conversao pra decimal
done
101 na base 2 eh 5
101 na base 8 eh 65
101 na base 10 eh 101
101 na base 16 eh 257
101 na base 32 eh 1025
101 na base 64 eh 4097 

echo $((16#FF)) $((32#V))
255 31

echo $((64#z)) $((64#Z)) $((64#@)) $((64#_)) # atenção nos 2 ultimos!
35 61 62 63

Além de ser possível usar a notação de octal e hexa do C (iniciar a expressão com 0 e 0x, respectivamente)echo $((10)) $(( 010 )) $(( 0x10 )) $((10 + 010 + 0x10))
10 8 16 34

Bastante útil para pequenas conversões. Agora se quisermos converter um numero de uma base qualquer para outra, o nosso amigo bc pode servir:

bc <<< 'ibase = 8 ; obase = 16 ; 1027'
2A3

Onde ibase é a base de entrada (input) e a obase é a de saída (output). A diferença fica nas bases muito altas (32 ou 64) onde não são usados os caracteres minúsculos, maiusculos e especiais.

Esta dica foi tirada do Advanced Bash Scripting Guide.




Comments


Tiago Peczenyj

Ola!

Se vc prestar atenção eu coloquei um comentário que informava a conversão para a base decimal pois achei q, se colocasse o 'na base 10' no final de cada linha poderia ficar um pouco poluido. Pelo visto ficou é confuso.

agora, 101 em hexa é 257 sim, uma vez que 100 significaria, nesse caso, 1 x 16^2 -- 256. Vou postar mais sobre o assunto ai e vai vamos chegar a um consenso ;-)


naoliv

Hum... comentando com um amigo meu eu acho que você quis dizer:

101 na base 2 eh 5 na base 10

101 na base 8 eh 65 na base 10

101 na base 10 eh 101 na base 10

101 na base 16 eh 257 na base 10

101 na base 32 eh 1025 na base 10

101 na base 64 eh 4097 na base 10

Faltou os "na base 10" :-)


naoliv

Isso tá certo?
Como que o número pode ser 5 na base 2? (se só existem os caracteres 0 e 1)

101 em hexa (base 16), por exemplo, é 65 e não 257.

Ou eu entendi errado o seu post?




Sindicato dos Messias
Thu, 12 Jul 2007 09:49:00 -0300

Basta de oligopólios monoteístas!

O Sindicato dos Messias ® é uma tradicional sociedade de Messias, Profetas, Avatares e Deuses, que remonta, neste plano, aos tempos de antes do Grande Uósh que escaramurfou as Formas de Vida Errantes da Terra. Fora deste Universo o Sindicato dos Messias existe desde antes do ínicio do Tempo como o conhecemos, e mesmo antes do surgimento do Primeiro Deus, sendo que os registros mais antigos remontam ao tempo em que nem o Nada existia ainda, só havia o conceito idealizado do Sindicato dos Messias, e mais um bando de idéias bizarras boiando num mar de Coisas Inexistentes Inimagináveis.

Continua...


StarCraft 2
Wed, 11 Jul 2007 23:42:00 -0300



O que eu posso dizer... 

...YEAAAAAAAAAAAAAAAAAAAHHH!!! StarCraft 2 está chegando!!!

Vejam a primeira apresentação para o publico: ainda é Beta, mas ja temos ideia de como serão algumas unidades, principalmente as Protoss.

Alguem mais alem de mim achou sensacional o buraco negro que a nave mãe gera?


Bad Astronomy
Wed, 11 Jul 2007 23:23:00 -0300

Não posso deixar de recomendar o ótimo site do Astrônomo Phil Plait: badastronomy.com

Phil é uma daquelas pessoas que se dedicam a informar, acabando com boatos e inverdades científicas - em especial na sua área, a astronomia. Também é escritor do (excelente) livro Bad Astronomy - Misconceptions and Misuses Revealed, from Astrology to Moon Landing "Hoax".

Um link realmente importante é sobre a "Fraude" da ida à lua. Com uma linguagem clara e muitos exemplos, fotos e diagramas, ele refuta todos os mais absurdos comentários sobre a impossíbilidade da missão Apollo ter descido até o nosso satélite natural. Confiram para ver.

Um artigo na mesma linha (em pt_BR) está presente no ótimo site do Projeto Ockham, escrito pelo engenheiro Widson Porto Reis.

Ps: se ouvirem falar de um filme chamado "What the Bleep do We Know", leiam este guia cético bem humorado (e informado).


Paz, Amor & Linux
Wed, 11 Jul 2007 16:13:00 -0300

Hacker é como Punk, Ateu ou Geek -- um rótulo.

Uma hora a mídia fala q ser Hacker é ruim. Outra hora fala q não são Hackers, são os Crackers que são a ameaça. Acho que falta um pouco de romantismo na nossa vida...

Proponho uma revolução no mundo digital através do amor. Vamos deixar comentarios no codigo fonte repleto de belas mensagens, poemas e juras de amor eterno. Vamos visitar o apartamento frio e escuro dos nossos amigos mais anti-sociais e levar bolos, café e carinho. Vamos fazer divertidas obras de arte como borboletas e caras-de-gatos com os DVDs do windows vista e distribuir para os nossos amigos.

Bigodinho e chifres nas fotos do Bill Gates e Steve Ballmer nunca mais! Vamos colocar coraçõezinhos e flores coloridas e passar muita energia positiva. Sejamos francos e sinceros. Vamos usar de adjetivos angelicais e fala suave para que amor sempre venha a tona.

Assim, o codigo fonte sera alvo do nosso tórrido amor. Interfaces apaixonadas e Algoritmos envolventes serão o nosso legado.

E assim o amor triunfa. Nada de esmurrar o teclado. No lugar do café: flores. No lugar do ódio: Linux.
Comments


pauloriceli

 :) 




Sugestões de Leitura
Wed, 11 Jul 2007 15:38:00 -0300

Ja ouviu falar na tal Web 2.0? Veja os slides da apresentação do Philip Calçado.

Quer dominar o Vi/Vim? Veja este pequeno guia.

Se inglês não é problema, vc pode aprender Java, C++ ou Programação Avançada em Linux usando livros gratuitos e de ótima qualidade.

No site da InfoQ vc ainda pode baixar livros de SOA, Scrum & XP, Domain Driven e Dicas de Visual Studio .NET.

E, se vc se interessa por Gerência de Projetos, vai gostar desse artigo.

Boa leitura!


O Último Guerreiro Estelar
Wed, 11 Jul 2007 12:47:00 -0300




Saudações, Guerreiro Estelar! Você foi recrutado pela Liga Estelar para defender a Fronteira contra XUR e a Armada Ko-Dan!

Assim começa o jogo na (antiga) maquina de Arcade. Alex Hogan é apenas um adolescente morando em um conjunto de trailers na california, mas é o melhor jogador de todos os tempos, atingindo o recorde da maquina.

Seria mais um filme nerd bobo se não fosse pelas consequências: o video-game é, na verdade, uma maquina caça-talentos e descobre um promissor piloto espacial! Uma noite Alex recebe a visita de um homem chamado Centauri e, então, sua vida muda completamente, conhecendo o espaço, suas maravilhas e perigos.
 
Uma premissa interessante: quem não gostaria de ver o seu jogo favorito se tornar realidade? Entretanto, nada é facil para Alex, que resolve desistir quando sente a responsabilidade -- quando se torna, literalmente, o último guerreiro das estrelas. 

The Last Starfighter entrou para a história do cinema por usar intensamente cenas feitas em CGI pela primeira vez -- tornando as batalhas impressionantes para a época. Destaque para a cena final com o uso da "Arma da Morte" com a classica fala "We Die". 

Vai bem com um balde de pipoca, em um aparelho de DVD mais perto de vc.


Ansi C orientado à objetos
Tue, 10 Jul 2007 16:37:00 -0300

Divertido! Compila e não gera nenhum warning.


#include <stdio.h>

struct {
 struct {
 int (*println) (const char *);
 } out;
} System = { {puts} };


int main (void){

 System.out.println("ola mundo");

 return 0;
}


Achei um pdf no google sobre o assunto chamado Orientação A Objetos em C Ansi. Neste caso, eu criei um ponteiro para a função puts (presente na libc), chamado println. Criei uma variavel chamada System, que é uma estrutura que possui uma variavel chamada out que, por sua vez, possui o ponteiro println.
Comments


Tiago Peczenyj

Ola!
Esqueci mesmo, achei o pdf e postei na correria. :)


J. F. Mitre

Amigo, 
tenho acompanhado seu textos a algum tempo, são de alta qualidade, mesmo quando são curtos. Muito bom.

Mas quando você escreveu esse texto e colocou esse link no fim da página, você esqueceu de mencionar que era um livro gratuito de mais de 200 páginas...

Link para a página de divulgação do livro. Bom para saber quando e quem escreveu.

Eu só posso dizer obrigado !

1[]'s




Falando em Feira da Fruta...
Sat, 07 Jul 2007 15:28:00 -0300

Uma imagem fala mais o que mil palavras.


Stênio Garcia e Antonio Fagundes, quem diria, deram uma de super-heróis. E se vestiram, justamente, de Batman e Robin. No episódio de sexta-feira de "Carga pesada", Bino (Stênio) e Pedro são assaltados por uma quadrilha e largados, sem nada, num galpão abandonado. Lá, eles encontram as fantasias, que quebram um galho no momento de aperto. 

Essa trama de serem trancados em um galpão lembra muito McGyver ou Esquadrão Classe-A :)


Como aprender...
Sat, 07 Jul 2007 14:59:00 -0300

Para aprender C, leia o curso da UFMG. 

E Linux ?, um bom começo é o Guia Foca Linux.

Quer ir mais longe e aprender criptografia ou fazer o seu proprio bootloader ? O lugar é o aldeia numaboa.

Ou quem sabe ler um delicioso artigo sobre programação orientada à aspectos?

Se vc souber pesquisar, vai encontrar muitos tutoriais escritos no seu idioma. Mas os melhores textos ainda estão escritos em inglês. Não se pode virar as costas à este fato, porém não é de todo ruim. Aprender coisas novas mantém o cérebro ágil e jovem.

Não importa o assunto, a internet está ai: pesquise. Isso pode tanto fazer um diferencial competitivo na hora de arrumar um (novo) emprego, quanto prover uma melhor qualidade de vida.

Afinal, se não fosse pela internet não teriamos o classico Batimã: Feira da Fruta.


Bunny Suicides
Fri, 06 Jul 2007 16:51:00 -0300

Conheça os adoraveis coelhos suicidas.




Pra bom entendedor...
Fri, 06 Jul 2007 16:20:00 -0300

Coitado do latinha nesse universo amálgama:




Youtube Downloader 2.0
Fri, 06 Jul 2007 15:25:00 -0300

A versão 1.0 foi até pro Dicas-L. Graças a esta exposição percebi que o script é muito útil para quem não tem um plug-in flash (que preste) no browser. É o caso do pessoal que usa Beos, por exemplo. 

Reduzi o número de linhas, usei a expansão de variáveis do bash para algumas substituições simples e agora vc pode informar o nome do arquivo que vc quer salvar, senão será usado aquele nada pratico id. A extensão é flv que pode ser visualizado pelo mplayer ou convertido pra mpeg.

$ ./script.sh endereço_do_video nome_do_video

Eis o código
#!/bin/bash
# youtube downloader
test -n "${1}" || { echo -e "Missing url or id!\nUsage: ${0} <url | id> [filename]" ; exit 1; }

set - ${1/*=} ${2:-${1/*=}} "http://www.youtube.com/watch?v=${1/*=}" 'video_id=.+&t=[^\"&]+'
 
wget -O "${2%.flv}.flv" "${3%/*}/get_video?$(wget -qO - "${3}" | grep -oE "${4}" | sed '1q')" 


Tentei usar o curl e não consegui. Quem quiser tentar, faça um curl -I na url final e veja os cabeçalhos -- não sei como ir para o 'Location'. O wget faz isso numa boa, mas seria interessante ter a opção com o curl.

O que seria mais interessante? Baixar uma lista de videos? Baixar os X primeiros videos que aparecem em uma dada pesquisa?


Respostas Claras
Thu, 05 Jul 2007 14:17:00 -0300

Em exemplo interessante de falta de atenção (inspirado em casos reais):
Nome 
Idade 
 Opinião 




Curiosidade
Wed, 04 Jul 2007 10:28:00 -0300

Desde que comecei com este blog, não imaginei que receberia visitas do Vietnã e do Hawaii (graças ao Google Analytics).

Aos visitantes de tão longe, assim como os de tão perto, um grande abraço!
Comments


Sergio

Meu blog eh bem novo mas percebi que quem acessa mais no estrangeiro é a Germany segundo portugual e terceiro Japan, gostaria de saber o que ele acham de tudo isso hauahuahua...




Linux Ubuntu
Tue, 03 Jul 2007 16:42:00 -0300

Houve um tempo que usar linux era coisa de louco. Era difícil de instalar, as interfaces gráficas eram pobres, poucos programas... era o sistema ideial para programadores e nerds. Quem precisa de Word quando tem o Vi e o LaTeX? Quem precisa de Excel quando tem AWK? Ora... é uma questão de escolha, simples assim.

O que era um projeto de nerds virou um modelo de negócios. Surgiram boas distribuições, inovações como o Linux Mandrake (nunca a instalação de um sistema foi tão fácil e bonita), o StarOffice, o WindowMaker, KDE...

Pois bem, eis que surgiu o Ubuntu Linux. Criado pelo programador E turista espacial Mark Shuttleworth, o Ubuntu é um sistema inteligente, projetado para ser utilizado com simplicidade por qualquer pessoa. O resultado foi uma distribuição extremamente popular, bonita e intuitiva.

Fica ai a dica: façam um test-drive com um LiveCD do Ubuntu (vcs podem pedir CDs de graça no site oficial -- eles entregam no brasil).

A seguir uma breve entrevista do Mark Shuttleworth:



Oportunidades de Emprego (Porto Alegre)
Tue, 03 Jul 2007 11:22:00 -0300

Tens experiência em Java / Oracle / .Net / C / C++ / Javascript / Teste de Software / Gerência de Projetos /Cobol ou Clipper?

Procurando emprego na região de Porto Alegre?


Desenvolvedor C# (2 vagas)

Desenvolvedor de Testes

Analista de Suporte Java

Integrador de Sistemas

Analista de Sistemas

Lider Técnico - Java (mínimo 3 anos de experiência)

Desenvolvedor Java/Oracle (4 anos experiência)

Desenvolvedor Oracle Developer (Forms/Report) (3 anos de experiência)


Não perca tempo, envie o seu curriculo atualizado para mim informando, principalmente, tempo de experiência, certificações e nível de inglês.

Sugiro também a leitura deste post do blog pythonologia. Muito interessante na hora de redigir um currículo ou email para alguma vaga.


Parâmetros em Shell Script
Mon, 02 Jul 2007 22:46:00 -0300

Meu primeiro artigo, resultado de uma boa noite de insônia.

Direto do CentOSBR: Parâmetros no Shell.

Estou enrolando outros textos tem tempo: vamos ver se agora eu continuo.


Conheça o Incrível Ruby on Rails
Mon, 02 Jul 2007 17:39:00 -0300



Ruby é uma linguagem interpretada orientada à objetos que vem aparecendo no mercado faz tempo. Sua popularidade vem subindo graças ao framework on Rails, que pode acelerar, e muito, o desenvolvimento de aplicações para a web. 

Gostou da demonstração? O ponto de partida para um entusiasta pode ser o Ruby on Br, com alguns bons artigos e um forum que une os melhores profissionais no ramo. 

Dê uma olhada nos tutoriais do Taq e, se gostar, compre o livro (é muito bom, recomendo). Outro livro muito bom é o do Akita (responsável pela tradução do livro Getting Real by 37 Signals para pt_BR).

Embarque nessa vc também!


Rogue: Muita Ação em 1980
Mon, 02 Jul 2007 12:22:00 -0300

No fim da década de 90, fui o feliz proprietário de um PC 286 dotado de monitor CGA monocromático. Rodando DOS 5.0 no disquete maior, esta pontente maquina possibilitou que eu aprendesse Pascal para a faculdade, alem de testar centenas de sharewares baixados do Sintel.net.

A vontade de jogar era maior do que tudo, obviamente. As limitações do Hardware, entretanto, só foram eliminadas com um jogo extremamente simples, datado da década de 80: Rogue (uma breve história do jogo pode ser encontrada aqui).



Rogue é um jogo simples: tu és um guerreiro (ou alguma coisa parecida) representado por uma carinha ascii (ou uma @, dependendo da versão). Navegando por labirintos cheios de itens mágicos, armas e monstros, vais descendo até encontrar o temível Dragão (representado pela letra D -- após algumas horas de jogo, o alfabeto torna-se incrivelmente ameaçador!).

A complexidade do jogo não é pequena: vc pode usar um anel amaldiçoado (cursed) que te teleporte aleatoriamente até que vc consiga remove-lo com a mágica certa. Um dos monstros pode remover níveis do seu personagem, involuindo-o (letra X se não me engano -- alias esse foi o único jogo que apresentava esse tipo de desafio). Cada jogo é diferente do outro, o que representa centenas de horas de diversão. Para saber mais, começe aqui.

Jogos em modo texto, com este tipo de interface gráfica ou os mais simples como Zork ou Colossal Caves representam um excelente desafio: jogos cujo impacto seja a sua estória, suas possibilidades e a criatividade do autor. Qualquer um que pense em criar jogos (mirabolantes ou não) deveria conhecer estes vovôs dos jogos atuais, e tentar fazer um, inclusive.

Existe espaço até para jogos multiplayers, como no caso dos MUDs. Tem gente jogando a mais de uma década o que os mais novos descobriram no WoW.

ps: eu SEMPRE joguei em modo "Fast Play" (Scroll Lock!), exceto em ambientes grandes e escuros.


O melhor de dois mundos: C e Fortran
Mon, 02 Jul 2007 11:48:00 -0300

C é uma ótima linguagem de programação, simples e clara.
Fortran, para problemas matemáticos, é imbativel!

Que tal usar o melhor dos dois mundos com este tutorial?

Vejamos o exemplo abaixo:

Arquivo testC.cpp
#include 

using namespace std;

extern"C" {
void fortfunc_(int *ii, float *ff);
}

main()
{

 int ii=5;
 float ff=5.5;

 fortfunc_(&ii, &ff);

 return 0;
}


Arquivo testF.f
 subroutine fortfunc(ii,ff)
 integer ii
 real*4 ff

 write(6,100) ii, ff
 100 format('ii=',i2,' ff=',f6.3)

 return
 end


Compilando

$ f77 -c testF.f
$ g++ -c testC.cpp
$ g++ -o test testF.o testC.o -lg2c


Executando

$ ./test
ii= 5 ff= 5.500


Aceito sugestões, agora que não tenho muita coisa para fazer em Fortran.


Mono: C# no Linux
Mon, 02 Jul 2007 11:33:00 -0300

Considere este simples código:

using System;

class MainClass {

 public static void Main() {
 Console.WriteLine("Eu sou um programa feito em C#");
 Console.ReadLine();
 }
}


Tcharam: um hello world que, no mundo MS, seria compilado no Visual Studio após alguns segundos de espera. Para plataformas abertas, podemos usar o Mono:

$ uname
Linux
$ mcs Example.cs # Mono Compiler Suite
$ mono Example.exe # Mono's ECMA-CLI native code generator
Eu sou um programa feito em C#
[enter]
$ 


Independente de Ideologias, C# é uma linguagem interessante e seu uso está cada vez mais comum. Para quem não quer ficar fora do mercado de trabalho, o mono pode ser uma ótima oportunidade para praticar. O site java2s possui um tutorial interessante para os curiosos.


Youtube Downloader
Mon, 02 Jul 2007 10:26:00 -0300

Cerca de um ano atras eu pesquisei uma forma de fazer o download automatico de videos do youtube informando o id ou a url inteira. Ele é bem didático, basta ser um pouco nerd e conhecer um pouco de expressões regulares (alias o livro do Aurelio está em promoção).

Minha inspiração para postar este script veio desta notícia, onde Warren Harding baixou um vídeo usando o Lynx e usou o Mplayer para exibir o vídeo no modo ASCII. O resultado é insano, porém divertido.

#!/bin/bash
# youtube downloader
# usage: script 
# YouTube URL: http://www.youtube.com/watch?v=[video_id] 

[ -z "${1}" ] && { echo 'Error! Missing url or video_id!' ; exit 1 ; }

URL="http://www.youtube.com"

# download link: http://youtube.com/get_video?video_id=[video_id]&t=[t_id]&...

DOWNLOAD=`wget -qO - "${URL}/watch?v=${1/*=}" | grep -oE 'video_id=.*&t=[^\"&]*' | head -1`

wget -O "${1/*=}.flv" "${URL}/get_video?${DOWNLOAD}"


Eu poderia ter feito tudo em uma unica linha usando xargs, porém ficaria um pouco poluído para publicar neste humilde blog, mas fica aí a dica.


Classificação do Brasileiro via Shell Script
Mon, 25 Jun 2007 14:07:00 -0300

Querendo saber a classificação do seu time no campeonato brasileiro de 2007.

O bom e velho lynx + grep resolve.

$ URL=http://esportes.terra.com.br/futebol/brasileiro2007/classificacao/
$ lynx --dump ${URL} | grep '%'

 Colocação Time PG J V E D GP GC SG %
 1º Botafogo 17 7 5 2 0 18 7 11 81%
 2º Paraná 14 7 4 2 1 14 9 5 67%
 3º São Paulo 13 7 4 1 2 7 2 5 62%
 4º Goiás 12 7 4 0 3 13 9 4 57%
 Fluminense 12 7 3 3 1 11 6 5 57%
 Corinthians 12 6 3 3 0 7 2 5 67%
 7º Atlético-PR 11 7 3 2 2 12 10 2 52%
 Atlético-MG 11 7 3 2 2 11 9 2 52%
 Vasco 11 7 3 2 2 11 10 1 52%
 10º Cruzeiro 10 7 3 1 3 16 15 1 48%
 Figueirense 10 7 3 1 3 13 14 -1 48%
 12º Grêmio 9 7 3 0 4 5 12 -7 43%
 13º Palmeiras 8 7 2 2 3 9 12 -3 38%
 14º Juventude 7 7 2 1 4 9 11 -2 33%
 Internacional 7 7 2 1 4 8 12 -4 33%
 Santos 7 7 2 1 4 7 11 -4 33%
 17º Flamengo 6 6 1 3 2 11 15 -4 33%
 18º Sport 5 7 1 2 4 9 13 -4 24%
 Náutico 5 7 1 2 4 9 15 -6 24%
 20º América-RN 4 7 1 1 5 6 12 -6 19%
Comments


Tiago Peczenyj

O link de 2007 tambem serve, o terra redireciona para o brasileirão atual :)


J. F. Mitre

O novo link para 2008 é:

http://esportes.terra.com.br/futebol/brasileiro/2008/classificacao/

funciona igualzinho ao anterior...


Alexandre

Bacana isso ( de mais um flamenguista -triste- por aqui).


Julio

Isso serve para mostrar como o Shell tem mil-e-uma utilidades. Script simples e rápido.

Legal Tiago, ficará melhor ainda qdo o mengão estiver em 1o. lugar. :)

Julio
:wq




The Linux Documentation Project
Thu, 21 Jun 2007 23:37:00 -0300

Muitos guias, tutoriais e Howtos aqui.

O 'Advanced Bash-Scripting Guide' do Mendel Cooper merece destaque especial -- um livro excelente, assim como o 'Bash Guide for Beginners' do Machtelt Garrels e o 'Linux From Scratch' Gerard Beekmans.

Pesquisando um pouco conseguimos ate encontrar o Linux Portuguese-HOWTO escrito em 1997 pelo CaSantos.

Boa leitura!


Entrevista com Matthew Smith
Wed, 20 Jun 2007 10:40:00 -0300

Uma entrevista com o criador do "Maniac Miner" para ZX Spectrum



Maniac Miner foi um grande sucesso na epoca. Percebam como o Matthew Smith ficou loucão depois de uma temporada na holanda tomando todo o tipo de drogas com o dinheiro ganho com os jogos.

Agradecimentos ao Thielo por ter me mostrado o video.
Comments


maykon

muito loko o cara;;;
auauauaua




NUTS - Amendoins para Salvar Jericho!
Tue, 19 Jun 2007 12:09:00 -0300

Devido à baixa audiência, o canal CBS cancelou a série que conta o ponto de vista da pequena cidade de Jericho em um futuro próximo, onde um devastador ataque nuclear varre as principais cidades americanas. Muita paranóia, caos e personagens interessantes, temos ai um bom clima para uma série muito interessante e ousada.

Seria mais um caso como tantas outras séries sendo canceladas se não fosse a persistencia dos fãs. Bem organizados, uma verdadeira chuva de emails, petições e campanhas foram organizadas, não dando tregua a CBS. Qualquer um poderia achar um exagero, afinal isso raramente dá certo.

Entretanto mais de 7 toneladas de amendoins foram enviadas à CBS sob forma de protesto, graças ao site Nuts on Line. 

Nuts! Assim terminou a primeira temporada da série de TV americana Jericho (terminou de forma totalmente aberta, diga-se de passagem). Um termo, à principio sem sentido, é explicado pelo site Poltrona.tv:

A frase "Nuts!" é atribuída ao general norte-americano Anthony Clement McAuliffe durante a II Guerra Mundial. Cercado por alemães ao fim da Batalha do Bulge, na França, McAuliffe soltou a frase sem nenhum sentido aparente para afirmar que não se renderia.

Deu certo. A CBS encomendou 7 novos episódios -- e existe a possibilidade da série continuar dependendo da audiência. Uma boa noticias aos fãs tão ousados e persistentes (ou, nas palavras da CBS: P.S. Please stop sending us nuts  ) 

Vamos torcer para que passe no Brasil logo!


Canivete Multifunções do Shell
Tue, 19 Jun 2007 11:35:00 -0300

O Aurelio (verde) levou algum tempo juntando excelentes dicas sobre shell script que podem ser vistas aqui: o famoso Canivete Suiço do Shell.

Facil de consultar, é extremamente útil para qualquer administrador ou usuário experiente de algum sabor de *nix (ou mesmo no Windows, via Cygwin).


Bebendo da Fonte quando o assunto for WEB
Tue, 19 Jun 2007 11:28:00 -0300

Se existe um (bom) ponto de partida para todos os programandores e/ou web-designers no que diz respeito às principais tecnologias, siglas, formatos e padrões Web, este é o site do w3schools.

Começando pelo extremamente simples learn HTML, podemos ver um pouco de Javascript, XML, Ajax e ate PHP e SQL. Muito útil e simples, fica aí a dica.


O Desenvolvimento da Linguagem C
Mon, 18 Jun 2007 16:30:00 -0300

Um texto cativante e histórico (por Dennis M. Ritchie): 

http://cm.bell-labs.com/cm/cs/who/dmr/chistPT.html

a Linguagem C e o Sistema Operacional Unix foram revolucionários, trazendo conceitos usados até hoje. Qualquer um que queira se aventurar no mundo da informática, seja como hobbie ou profissão, tem que conhece-los ao menos um pouco.


Closures em Shell
Fri, 15 Jun 2007 17:27:00 -0300

Uma das coisas mais impressionantes (pelo menos para mim) da linguagem Ruby são os Closures:

$ ruby -e 'r=0...3 ; r.each { puts "oi"}
oi
oi
oi


em um objeto do tipo Range eu tenho um método chamado each que recebe um bloco de código como argumento. Este bloco pode até ser parametrizado, por exemplo:

$ ruby -e 'r=0...3 ; r.each { |i| puts 2*i}'
0
2
4


O que o metodo each faz é passar este bloco de código para 'dentro de si' e aplica-o em cada elemento do objeto 'range'. Pode ser para imprimir o resultado ou efetuar uma operação matemática, até mesmo substituindo um laço for simples. A verdade é que os Closures são bem mais do que isso e permitem fazer scripts bem interessantes.

Sera que poderiamos ter o mesmo em BashScript ? Bem... vou simular aqui 

$ each(){ 
 local F="${@}" 
 while read i ; do 
 set - $i 
 eval "${F}" 
 done 
}

$ seq 3 | each '{ echo "encontrei $1" ; }'
encontrei 1
encontrei 2
encontrei 3


Simples heim? Eu crio uma variavel local dentro de uma função e 'executo-a' para cada resultado via comando eval. Se este tipo de construção for util para alguem, fica aí a dica!


Avaliando Espaço em Disco
Wed, 13 Jun 2007 17:19:00 -0300

Um problema comum de qualquer administrador é o espaço em disco. As politicas de quotas geralmente resolvem boa parte destes problemas, é claro, mas nem sempre são suficientes.

O caso: pensando de forma genérica, diversas pessoas criam diretórios de trabalho dentro do bom e velho/local e, com o passar do tempo, esta partição pode lotar e comprometer o trabalho de todos. Politicas de uso racional do espaço em disco podem ser aplicadas mas as vezes a coisa pode sair do controle -- nesse caso o prejuizo pode ser grande.

Os diretorios possuem o seguinte formato:
/local/diretorio/algum_nome_identificador.vws


Vamos recorrer ao bom e velho Shell-Script para investigar se existe algum problema em andamento!

$ df /local
Filesystem 1K-blocks Used Available Use% Mounted on
/dev/sdb1 35001508 11330452 21893064 35% /local


Vejam só: apenas 35% da partição está sendo ocupada e isso não representa risco neste momento. Se estivesse acima de 80% alguma medida perventiva deveria ser tomada. Como podemos fazer este teste? Existem varias formas, vou usar o poder das expressões regulares para isso!

$ seq -f"%g%%" 10 5 100 | grep -E '(100|[89][0-9])%'

80%
85%
90%
95%
100%


A expressão usada no grep casa com valores de porcentagem acima de 80% (inclusive), logo podemos usar em um teste simples

 if df /local | grep -qE '(100|[89][0-9])%' ; then
 echo '/local [quase] lotado!'
 else
 echo '/local seguro (menos de 80%)'
 fi


Simples, não? Poderia ter usado os operadores && e || mas não queria sacrificar a legibilidade do código.

Agora vem a parte divertida: e se o /local estiver ficando cheio, vamos fazer o que?

Quando vc não tem a responsabilidade de apagar arquivos desnecessários, o maximo que vc pode fazer é avisar os responsáveis. Elaborar um relatório com os 'problemas' encontrados e enviar por email usando shell script é simples.

Vamos usar o du para calcular o espaço gasto em cada diretório e o sort para ordenar do maior para o menor tamanho total.

$ du -bs /local/diretorio/* 2>&- | sort -nr 
3765643919 /local/diretorio/nonono001.vws
2290883178 /local/diretorio/nonono002.vws
2067295469 /local/diretorio/nonono003.vws
932165874 /local/diretorio/nonono004.vws
...
267271 /local/viewstore1/nonono999.vws


Facil heim ? Se vc se dá ao trabalho de ler as man pages do du e do sort, basta fazer algumas experiências até obter o resultado que mais lhe agrada. Por exemplo, uma atitude interessante seria listar os X maiores diretórios e enviar por email para o administrador.

$ du -bs /local/diretorio/* 2>&- | sort -nr | head -10 > /tmp/arquivo.log 
$ mailx -S "Lista dos 10 maiores diretorios" "administrador@server" < /tmp/arquivo.log


Talvez vc pergunte o motivo pelo qual eu utilizo um arquivo temporário: caso o envio do email dê algum problema, é possivel recuperar a lista.

Um script para rodar na cron e enviar o email de forma automatizada teria este formato:

#!/bin/bash
# Autor: Tiago Peczenyj - 13/jun/2007
# Script parametrizado para avaliar tamanho de alguns diretorios

X=10
DIR=/local/diretorio
EMAIL=administrador@server
SUBJECT="Lista dos ${X} maiores diretorios em $(date +"%Y%m%d" )"
if df ${DIR} | grep -qE '(100|[89][0-9])%' ; then
 du -bs ${DIR}/* 2>&- | sort -nr | head -${X} > /tmp/arquivo.log 
 mailx -S "${SUBJECT}" ${EMAIL} < /tmp/arquivo.log
fi


O script parece simples, entretanto algo simples como informar o usuario dono de cada diretório é muito mais complexo. A minha solução foi esta:

paste -d '\t' <(du -bs /local/viewstore1/* 2>&-) \
<(ls -l /local/viewstore1 | awk '/^d/{print $3}') | awk '{
 OFS="\t" ; print $1,$3,$2
}'| sort -nr


Utilidade Pública
Wed, 13 Jun 2007 13:25:00 -0300

Tirado do blog Gambiarra!



Uma utilíssima maquina de dobrar camisas!


Um Caracter Inconveniente
Tue, 12 Jun 2007 17:19:00 -0300

Não é incomum passar pelo problema de tentar apagar um arquivo cujo nome começa com o caracter '-', como no exemplo abaixo:

$ rm -arquivo.txt
rm: invalid option -- a


Não adianta proteger a string pois não é o Shell que atrapalha a ação, e sim o próprio programa que reconhece o símbolo - de uma forma diferente. O programa rm aceita, alem de uma lista de arquivos para apagar, uma série de opções que modificam o seu funcionamento. As mais comuns são:

 -f ignore nonexistent files, never prompt
 -i prompt before any removal
 -r remove the contents of directories recursively
 -v explain what is being done


As opções normalmente pode ser colocadas em qualquer lugar da lista de parâmetros.

$ rm -v a.out
removed `a.out'

$ rm a.out -v 
removed `a.out'


Quem avalia os parâmetros normalmente é uma função chamada getopt (presente em várias linguagens, inclusive no Bash). Bom, vimos que o - é um caracter especial para o getopt, mas existe alguma forma de burlar isso?

Sim! O proprio getopt prove essa funcionalidade: o uso dos simbolos '--'. Eles interrompem a expansão de parâmetros e tudo o que vier depois desses dois caracteres será interpretado literalmente pelo programa.

Assim sendo:

$ rm -v -- -arquivo.txt
removed `-arquivo.txt'


Esta dica está no help do comando rm e vale para todos os programas que usem getopts.
Comments


La Batalema Pitonisto

É Tiago,

Nunca caí nessa do arquivo começado com sinal de menos, não por ser mais esperto que os outros, mas porque sou uma traça de manual. =)

Basta um man rm para resolver o problema (foi o que fiz na primeira vez em que me deparei com um arquivo desses).

Mas sabia que existe um livro que muitos chamam de «A Bíblia Negra do Hacker» (creio que a alcunha correta seria «o livreto negro de bolso do lammer»)? Esse livro apresenta a questão do «ataque» (ó! pretenção) onde o «atacante» (uf!) usa :> para criar arquivos começando com sinal de menos, cuja única forma de resolver o problema, segundo o livro, é mover todos os demais arquivos para outro diretório e apagar (argh!) o diretório onde estão os arquivos maliciosos.

É de se escangalhar de rir… um verdadeiro livreto de piadas sujas.

[]'s
Cacilhas




Transformers
Tue, 12 Jun 2007 14:58:00 -0300

Estréia em Julho:



More Than Meet The Eyes!


Ola Mundo!
Mon, 11 Jun 2007 16:42:00 -0300

Quando aprendemos uma nova linguagem de programação, normalmente o primeiro exemplo é o famoso "Hello World!", ou seja, um pequeno código que imprime uma mensagem na tela do computador.

Em C, ele seria assim:

/* Um comentário */
#include <stdio.h>

int main ()
{
 puts ("Hello world!");
 return 0;
}


As vezes o puts é substituido pelo multifacetado printf no exemplo, mas o efeito é o mesmo. Vejamos como seria em Java.

/* Comentarios, igual ao C */
package Hello;

public class HelloWorld {
 public static void main(String[] args) {
 System.out.println("Hello world");
 }
 }


As diferenças são várias, apesar da estrutura ser semelhante. Em C nós temos funções parametrizadas, enquanto em Java nós temos objetos (System.out) e métodos (println). 

Por fim, vamos ver um exemplo em Shell Script

#!/bin/bash
# comentario
echo "Hello World!"


Diferente de uma linguagem de programação, aqui o interpretador de comandos (normalmente) chama um programa capaz de escrever mensagens para o usuario. Ou seja, alguem ja escreveu um "Hello World!" genérico o suficiente para nós. 

Cada linguagem possui um propósito. Enquanto vc projeta sistemas operacionais e drivers em C, Java ocupa uma área no desenvolvimento de grandes sistemas corporativos enquanto o shell está presente na administração de determinadas tarefas de um servidor (normalmente rodando algum sabor de *nix). 

Não basta comparar um hello world, pois é preciso ver muito além da sintaxe e recursos da linguagem, mas normalmente se começa por ele.

Outros exemplos podem ser encontrados aqui.

Abraços