É por essas e por outras que não gosto de PHP:
<?php
if ("6 Galinhas" + "4 Gansos" == "10 Aves") {
echo "PHP estúpido\n";
} else {
echo "Seria inteligente se caísse aqui\n";
}
?>
Olha só que legal o presente que ganhei do Papai Noel...
Encontrei na rua de repente um amigo meu que eu já não via há mais de cinco anos, o Bruno!
(Aliás, acho que já faz quase sete anos...)
Feliz Natal, Bruno! Pra você e para todos vocês meus amigos!
[]'s
PS: A Luciana disse que as meninas mandam recado pro Fausto por você, Bruno, porque você é Alexandre (o Grande) só em segundo (nome). Hehehehehehehehehe =D
Neste final de ano estão todos pensando em amigo oculto...
Meu professor de Java passou como trabalho criar um serviço de amigo oculto, o pessoal lá do trabalho está fazendo amigo oculto e um colega meu estava com um problema com um programa (acho que em PHP) de amigo oculto.
O Silvio me sugeriu fazer um algoritmo de sorteio para amigo oculto em Lua, já que estamos envolvidos com um Kepler.
Bem, vamos então brincar um pouco com isso. =)
A primeira coisa que precisamos é uma lista dos amigos. Isso pode ser feito via web (sinceramente não estou com muito saco para ficar fazendo a UI, quem quiser que se vire), linha de comando ou GUI, ao gosto do frequês. Depois esta tabela precisa ser passada para o algoritmo de sorteio.
Todos os recursos para criar uma interface web (e até para armazenar os dados em banco de dados) são fornecidos por Kepler, portanto não fiquem acanhados! Quem quiser bricar de fazer isso é só dar uma olhada nos manuais (mais tarde publico um artigo sobre como usar alguns recursos).
Bem, digamos que a tabela – indexada, um vetor – tenha sido passada para a variável amigos.
Vamos agora embaralhar essa brincadeira:
local temp = amigos
amigos = {}
while table.getn(temp) > 0 do
-- Pega um índice aleatório
local i = math.random(table.getn(temp))
table.insert(amigos, table.remove(temp, i))
end-- tabela global amigoOculto
amigoOculto = {}
table.foreachi(amigos, function(i, v)
amigoOculto[v] = amigos[i + 1] or amigos[1]
end)amigoOculto["José das Couves"]. Isso pode então ser guardado num banco de dados, por exemplo.
Gostaria de exclarecer a mudança de apelido.
Atualmente não estou trabalhando mais tanto com Python (daí a esperantização Pitonisto = Pitona programisto = «programador Python») quanto com Lua. Estou num projeto de pelo menos um ano e meio de Kepler, portanto preciso me dedicar mais a Lua do que a Python.
Não que eu tenha deixado de ser La Pitonisto! Apenas estou sendo mais lunatika (lunático) do que pitonista, por isso da mudança de apelido.
Reiterando: não larguei Python, que considero uma das melhores linguagens de programação já concebidas, apenas estou trabalhando mais com Lua – outra linguagem entre as melhores – do que com Python.
Consequentemente, é muito provável que eu passe a postar mais exemplos de Lua do que de Python, o que não deve ser problema para programadores, pois algoritmos e conceitos (o forte dos artigos) continuam sendo os mesmos.
Eventualmente alguma coisa de Python vai surgir, pois é minha linguagem do coração.
[]'s
PS: Tanto batalema (brigão) quanto lunatika são palavras de cunho pejorativo em Esperanto, mas gosto de ser provocativo.
Incrível como algumas pessoas acreditam que uma comunidade judaica migrou «magicamente» para o América do Norte durante a era pré-cristã, fundando uma comunidade rica e próspera que desapareceu sem deixar qualquer rastro cultural ou arqueológico.
Também é interessante como as pessoas consideram Plutão como um planeta quando ele não possui qualquer característica em comum com os demais planetas, fora o fato de ser esférico, como aliás muitos meteoritos – aliás, o que além da afirmação arbitrária da NASA define um corpo celeste como um planeta?
Bem, estes questionamentos são só uma introdução para chegarmos ao ponto verdadeiramente interessante.
Não posso entender como uma sociedade tão crédula e ingênua assim rejeita outras afirmações que possuem embasamento empírico.
Abrindo aqui um parênteses: já perceberam como em nossa sociedade científica a palavra «empírico» é quase um palavrão?
Os cientistas não-empíricos inclusive inventam causos para ridicularizar o Empirismo, atribuindo-lhe características esdrúxulas que não condizem com suas bases (o nome disso é FUD: fear, uncertain and doubt, medo incerteza e dúvida, que pode ser traduzido perfeitamente por desinformação).
Mas isso só acontece porque os postulados e os axiomas científicos simplesmente desmoronam sob a luz do Empirismo. Então o medo de estar errado leva as pessoas a agirem assim.
Certa vez Sakuraten perguntou a mestre Dori:
— Qual é a verdadeira essência do Budismo?
Mestre Dori respondeu:
— Não faças o mal, pratica somente o bem. Praticar o bem é muito simples. É a essência do Budismo.
Qual religião possui ideais tão sublimes?
Mas ideais assim são encontrados em quase todas as religiões. O grande mal vem quando uma religião se institucionaliza, então seus princípios são torcidos para satisfazer os objetivos de seus líderes.
Isso ocorre sempre que há institucionalização, seja qual for a instituição.
De qualquer forma, segue uma ótima recomendação de leitura: A Tigela e o Bastão. Se você não «entender» os koans, pelo menos irá se divertir muito com os mondos, mesmo se você não tiver nada a haver com Budismo.
[]'s
Um colega meu (Silvio) me passou esse link interessante: gadgets agitados do Google.
Acho que vou colocar alguns gadgets desses aqui na página... =)
[]'s
Faz mais de um mês que não escrevo nada sobre Informática! Como já faz tempo que quero escrever sobre Tcl/Tk, vamos lá!
Tcl (Tool Command Language) é uma linguagem de script de código aberto muito poderosa. Desenvolvido por John Ousterhout, é costume dizer que é uma linguagem fácil, mas discordo.
É baseada em comandos (há uma variante orientada a objetos, chamada [incr Tcl]) com uma proposta interessante: tudo são strings!
Uma string em Tcl não precisa de delimitador, a menos que possua caracteres não-permitidos, como espaço e mudança de linha. Neste caso, o delimitador padrão é " (ou chaves).
Vamos a alguns exemplos...
Para se alterar ou ler o valor de uma variável usa-se o comando set. No exemplo a seguir, o script lê o valor da variável e retorna o dobro:
puts -nonewline stdout {Informe um número: }
gets stdin num
set num [expr [set num] * 2]
puts stdout "O dobro é [set num]"puts) grava na saída padrão (stdout, a tela) a string «Informe um número: » sem mudar de linha (-nonewline). As chaves ({...}) também delimitam uma string, mas não interpretam colchetes (veja adiante).gets lê da entrada padrão (stdin, o teclado) um valor e atribui à variável num.set, usamos colchetes ([...]). Os colchetes interpretam um comando e são substituídos por seu retorno.num, no comando:expr [set num] * 2set num, retorna o valor de num, portanto 123, então os colchetes serão substituídos, recriando a string do comando assim:expr 123 * 2expr avalia uma expressão matemática e retorna seu valor. Então:set num [expr [set num] * 2]num e atribui a num.O dobro é [set num]», substituindo os colchetes pelo valor de num.puts, a string está protegida por chaves, e no segundo por aspas. Sempre dou preferência ao uso de chaves, mas as chaves protegem a string de interpretação, enquanto que aspas permitem a interpretação de colchetes (e cifrão, veja a seguir).set num com cifrão ($):puts -nonewline stdout {Informe um número: }
gets stdin num
set num [expr $num * 2]
puts stdout "O dobro é $num"if. Sua estrutura é assim: if condição bloco1 [else bloco2]. Aqui, condição, bloco1 e bloco2 são strings (como não poderia deixar de ser). Então:if {$sair == 1} {
puts stdout Tchau
exit
}sair for igual a um, exibe Tchau e sai. Como em outras linguagens, o bloco do else é executado se a condição for falsa.==) é usada para comparar valores numéricos. Para a comparação de strings, é usado o comando string com a opção equal:if [string equal $var1 $var2] {
puts stdout {São iguais!}
} else {
puts stdout {São diferentes!}
}string equal -nocase. Repare que aqui a string interpretada pelo if como condição não é o comando em si, mas seu resultado.for.for inicialização condição passo bloco. Novamente cada termo é uma string.for {set i 0} {$i < 10} {incr i} {puts stdout $i}loop.loop i 0 10 {
echo $i
}echo de TclX é equivalente a puts stdout de Tcl. Em loop é possível passar mais um argumento entre o máximo e o bloco como passo (tipo: loop i 0 20 2 {...).while, switch e foreach.proc, que recebe como primeira string a lista de argumentos (separados por espaços) e como segunda string o bloco de comandos. Ex.:proc fib n {
set a 0
set b 1
set c 1
while {$c <= $n} {
set aux $a
set a $b
incr b $aux
incr c
}
return $b
}fib vai calcular a sequência de Fibonacci:for {set i 0} {$i < 10} {incr i} {
puts stdout [fib $i]
}wish (e para usar TclX com Tk é wishx)..).#!/bin/sh
#\
exec wish "$0" "$@"
tk appname Ola
tk_setPalette gray
label .lbOla -text {Olá Mundo!!!}
button .btOk -text Ok -command exit
pack .lbOla .btOktk appname) define o nome da aplicação (Ola), e o comando seguinte (tk_setPalette) diz pra usar como cores variantes de cinza (gray).label cria um rótulo (label) chamado lbOla na janela raiz (.) com o texto «Olá Mundo!!!». O comando button cria um botão chamado btOk na janela raiz (.) com o texto «Ok» e que, ao ser clicado (-command), executa exit (sair).pack indica que será usado o geometry manager pack. Geometry managers são gerenciadores de widgets (objetos gráficos) e geometria. Tk usa três: pack («empacota» em relação a posições esquerda, direita, em cima, em baixo, e tenta manter estas relações), grid (usa uma tabela – grade – colocando os widgets nas células da tabela) e place (desaconselhável: coloca os widgets em posições absolutas).pack por padrão coloca os widgets a partir de cima (top), um de baixo do outro, centralizando (é possível mudar isso usando -side).-side left, a partir da direita: -side right. Para «amarrar» um widget em baixo, usa-se -side bottom.grid prende os widgets centralizados (é configurável) em células. A célula exata é informada através dos números de linha (-row) e coluna (-column). É possível que um widget ocupe mais de uma coluna (-columnspan) ou mais de uma linha (-rowspan).grid assim:#!/bin/sh
#\
exec wish "$0" "$@"
tk appname Ola
tk_setPalette gray
label .lbOla -text {Olá Mundo!!!}
button .btOk -text Ok -command exit
grid .lbOla -row 0 -column 0
grid .btOk -row 1 -column 0(n) (new) das manpages, mas um macete indispensável é digitar o seguinte comando no shell de um xterm:tcl <<< tclhelp
Estes dois textos abaixo são traduções dos primeiros parágrafos do último artigo respectivamente para o Esperanto e para o Arcaicam Esperantom (em Esperanto: Arĥaika Esperanto, criado por Manuel Halvelik).
São apenas exemplos. =)
Antaŭ iom da tempo mi volas skribi pri la Esperanto.
Kutime traktata per antaŭjuĝo, nekonfideco kaj nesciigo, la Esperanto estas la planlingvo plej parolata kaj plej bone planita el la homa historio. Estis planita de Ludwik Zamenhof je 1887 (mil okcent okdek sep), sed akiris propran vivon tra la jardekoj.
Ĝia lernado estas dekope pli rapide ol la lernado de la angla, kaj eble estas akiri bonecgradon neakireblan en la angla (aŭ alia ajn etna lingvo) de nenata parolanto.
— Kial?
Nur ĉar neniam iu estos pli bona fluparolanto ol nata parolanto. Ĉiam estos parolmaniero – ne signifas, ke ne estas parolmaniero de nata parolanto, sed ĝia estas la «ĝusta parolmaniero»...
Antez iohem da tempo mihi volams scribir pri Esperantom.
Cutime tractatam per antezyughom, necomphidetzom cay nestziagom, Esperantom estat planlingvom pley parolatam cay pley bone planitam el homam historiom. Estit planitam de Ludwik Zamenhof ye 1887 (mil octzent ocdec sep), sed aquirit propran vivon tra la yardecoym.
Eghies lernadom estat decope pli rapide ol lernadom angles, cay eble estat aquirir bonetzgradon neaquireblan en anglam (aw alia ayn etnam lingvom) de nenatam parolantom.
— Cuyal?
Nur char nemyahem iu estot pli bonam phluparolantom ol natam parolantom. Cheyahem estot parolmanierom – ne signiphat, que ne estat parolmanierom de natam parolantom, sed eghies estat «ghustam parolmanierom»...
Faz tempo que quero escrever alguma coisa sobre o Esperanto.
Geralmente tratado com preconceito, desconfiança e desinformação, o Esperanto é a língua artificial mais falada e mais bem planejada da história humana. Foi idealizado por Ludwik Zamenhof em 1887, mas ganhou vida própria ao logo das décadas.
Seu aprendizado é dez vezes mais rápido do que o do inglês, e é possível atingir um grau de excelência impossível de ser conseguido no inglês (ou qualquer língua natural) por um falante não-nato.
— Por quê?
Simplesmente porque ninguém nunca terá a mesma fluência numa língua que tem um falante nato. Sempre terá algum sotaque – não que o falante nato não tenha sotaque, mas seu sotaque é o «sotaque correto»...
Quando se fala de uma língua artificial, todos os sotaques e regionalismos são «corretos», visto que nenhum é o sotaque nativo.
Uma prova disso é o nascimento do Globish.
Além do mais, o uso de uma língua natural para comunicação internacional resulta necessariamente na supremacia cultural dos países que possuem tal língua como nativa/oficial. Exemplos disso são, além do efeito destrutivo das dominações inglesa na Índia e espanhola na Galiza; situações constrangedoras em reuniões da ONU, como quando um representante de um governo do Leste Europeu disse «my government sinks» («meu governo afunda») em vez de «my government thinks» («meu governo acha», obviamente por uma natural dificuldade com o fonema þ) ou quando houve uma má interpretação do termo «period», que causou o fim de uma audiência séria, terminada em uma mal-educada crise de risos dos representantes dos EUA e da Inglaterra.
Bem, tendo sido explicados os motivos, vamos esclarecer alguns equívocos.
Algumas pessoas dizem que a intenção do Esperanto é substituir as demais línguas do mundo. Isso é ridículo. O Esperanto é uma ferramenta de comunicação internacional e não pretende substituir nenhuma língua nativa, mas sim ser uma segunda língua para todos os povos do mundo.
Na verdade o efeito do Esperanto é justamente o contrário. Historicamente sabemos que o uso de uma língua natural para comunicação internacional resulta na destruição de outras línguas e consequentemente de suas respectivas riquezas culturais. Um bom exemplo é a influência do latim na cultura européia – alguém sabe alguma coisa sobre a língua ibérica pré-latina? Ninguém. Nada sobreviviu, a não ser alguns nomes de localidade que hoje não fazem sentido algum.
Devido a suas características peculiares, o uso do Esperanto como ferramenta de comunicação internacional fomenta a preservação das línguas naturais, preservando assim também a Cultura Humana.
Agora vamos ver um pouco do Esperanto em si.
O Esperanto é sistematicamente regular e possui apenas dezesseis (16) regras gramaticais, a saber:
Gente, este texto que segue a baixo me foi enviado por um amigo meu de mente aberta e é de autor desconhecido. Na verdade o autor postou o texto num fórum e não quis se identificar, portanto o mais correto seria dizer que é de autor anônimo.
Não concordo como todos os pormenores do texto e não tenho a pretenção de fazer-lhe apologia, mas concordo com o sentido geral e gostaria de dar a você leitor a chance que tive de refletir sobre o assunto. Acho esse tipo de crítica muito importante para todo religioso.
Segue então o texto:
QUANTOS O DIABO JÁ MATOU? ZERO! E DEUS? LEIAM
O Antigo Testamento é um receituário de dominação prescrito pelos judeus aos povos reféns do banditismo israelita. O próprio nome Israel significa: simaquia com Deus (Deus como seu aliado em guerra).
Raciocine: No Antigo Testamento, Deus é retratado como uma propriedade exclusiva dos judeus (hebreus). Por quê? Porque foram eles quem inventaram Deus! A mulher é descrita como um objeto do homem, no pentateuco. Por quê? Porque aquele conjunto de livros foi escrito integralmente por homens, daí o cunho machista. Ora, se o corpo humano consta de 206 ossos, como poderia a mulher se resumir à fração de 1/206 de um homem, já que Eva foi feita duma costela? (Gen. 2:22).
Outra incoerência: ainda, no Antigo Testamento, Deus aparece na condição de precursor dos métodos de destruição em massa (o aniquilamento de Sodoma e Gomorra), Gen. 19:1-29, algo assemelhado a uma explosão nuclear. Nas dez pragas do Egito, (Ex. 7:14 e 11:10), Deus teria sido o preconizador da guerra química (envenenando as águas do rio Nilo), e da guerra biológica (disseminando gafanhotos pelo reino de faraó). Será se Deus, onisciente e todo-misericordioso, teria cometido aquelas barbáries? Mesmo porque o Senhor já sabia previamente que, no segundo milênio do nascimento do Seu filho unigênito, Seus ensinamentos genocidas iriam habilitar o Bin Laden para atentar contra uma nação protestante, os EUA, que se dizem ser habitados por um povo "santo e escolhido"?
A Deus também o papel de pivô do primeiro fratricídio lavrado na bíblia, ao ficar grato pelas ovelhas recebidas de Abel, e se mostrando indiferente para com as batatas de Caim. Percebendo que o Senhor não reconheceu a sua humilde oferta na mesma medida das ovelhas doadas pelo seu irmão Abel, isso despertou um sentimento de inveja em Caim; levando o segundo a assassinar o primeiro. (Gen. 4:8).
Aqueles escritos são apenas malícias humanas. Em estando sentenciadas nas Sagradas Escrituras, todas as atrocidades perpetradas pelos judeus às outras tribos recebiam uma conotação "divina" e, como tal, eram legitimadas e justificadas. Ainda hoje, israelenses (judeus) e árabes (muçulmanos) se arrastam em um conflito milenar e sangrento, nas terras da Palestina. Tudo teria começado com a interpretação preconceituosa de uma lenda bíblica. Ismael, filho bastardo de Abraão com a escrava egípcia, Agar, teria dado origem ao povo árabe (Gen. 16:5-15). E Isaac, filho legítimo de Abraão (ex-Abrão) com a sua verdadeira esposa, Sara (ex-Sarai), haveria sido o progenitor dos judeus (Gen. 21:1-7). Então, para desqualificá-los, os judeus tacham os árabes de descenderem do filho duma puta. Com efeito, se considerarmos aquelas narrativas nefastas (assassinatos, seqüestros, estupros, pilhagens; por exemplo, leiam: Num. 31:17-18; Deut. 20:10, 13 e 14; 23:13; 25:11 e 12; 2º Reis 19:35; Juízes 8:10; 2ª Cron. 28:6; 13:17 e 14:19; Isa. 37:36......); uns executados pelo próprio Deus, outros pelos Seus jagunços: Davi, Moisés etc., (cumprindo ordem divina), então, temos de dar a mão à palmatória, e concordarmos com o Santo Ofício, como tendo sido um cumprimento fiel às Sagradas Escrituras por parte da Igreja Católica. Acaso, imitar os ensinamentos bíblicos constitui um pecado ou uma virtude? Inquisição que não foi exclusiva apenas do catolicismo, o protestatismo também valeu-se de morticínios para fazer valer seu proselitismo. João Calvino, o pai dos presbiterianos, mandou queimar na fogueira o médico espanhol, Michel Servert Grizar. E tantos outros atos sangrentos promovidos pelos protestantes.
Hoje muitas pessoas ficam horrorizadas ao saberem que, nas favelas das grandes cidades, os comerciantes são obrigados a pagar pedágios para os chefes do tráfico local, se quiserem continuar exercendo suas atividades mercantis. Ora, ora esse critério de sujeição extorsiva já era praticado pelos "capangas de Deus", quando submetiam determinadas comunidades à condição de Cidades Tributárias. Para sobreviverem sem serem molestadas pelos judeus mandões, mafiosos, tais comunidades-reféns tinham de transferir grande parte de sua força de trabalho e riquezas aos seus "protetores". (Vide em 1ª Cron. 18 e 2º Sam. 8).
O mais gozado e incoerente de tudo isso é que Deus, retratado como bandido e sanguinário no Antigo Testamento, ainda assim, Ele personifica a figura do BEM. Ao passo que o diabo, embora nunca tenha matado ou roubado alguém, paradoxalmente, foi eleito como a fonte do MAL.
(Autor anônimo)
Ontem me perguntaram em quem pretendo votar para governador. Cometi o erro de responder.
Fui então duramente criticado, segundo meus críticos porque vou jogar meu voto fora.
Mas tenho então de votar no candidato que lidera as pesquisas? Ou no segundo lugar? Pensei que o voto fosse um exercício de cidadania, não de dominação (na verdade, escravidão intelectual)!
Tudo bem, não concordo com essa quantidade enorme de candidatos a um cargo único, acho que isso só visa dividir os votos, mas nem por isso vou me render aos líderes de pesquisas. =P
Algumas dicas para quem vai votar:
Recentemente o sítio NotíciasLinux.com.br divulgou uma lista das «10 linguagens de programação que você deveria aprender agora mesmo».
Nós (Rodrigo Cacilhas e Walter Cruz) conversamos e decidimos fazer nossas próprias lista. Qual não foi nossa surpresa ao descobrir que estas só divergiam em duas linguagens!
Então resolvemos escrever um artigo sobre as «12+». =)
Segue então a lista em ordem alfabética.
Um dos grandes problemas que eu vejo em Java é sua quase onipresença. Tem um problema? Não importa qual, mas a solução é Java. Outro grande diferencial é que essa é a linguagem que fala empresariês. É a linguagem que tem mais siglas, mais nomes e expressões complicadas, que no final acabam por se mostrar coisas simples na maioria dos casos. Não me entendam mal – depois de anos, resolvi aprender Java, e de fato estou até gostando. Existem na verdade duas coisas chamadas Java: a plataforma Java (JVM) e a linguagem Java. Apenas recentemente, com o advento do .NET a comunidade Java se tocou que nem todos gostavem de Java e passaram a alardear que outras linguagens poderiam rodar na JVM. Será que isso veio tarde demais? Espero que não.
(Walter)
Sem contar que Lua tem méritos próprios. Metatabelas e orientação a objetos em Lua são coisas totalmente originais.
(Walter)
Na minha opnião, é uma das melhores linguagens pra ensino.
(Walter)
Embora seja muito semelhante a Python na superfície, são bichos de espécies diferentes. Ruby nasce do cruzamento de Perl com Smalltalk, e Python herda da linguagem ABC. Isso é algo importante de se lembrar.
(Walter)
Considero uma ironia que PHP tenha tido um grande sucesso e Smalltalk tenha ficado sempre em segundo plano. É particularmente chatinha de aprender – eu tentei fazer qualquer coisinha aqui e sempre me atrapalho. Isso porque a mente da maioria dos programadores já está viciada em sintaxes C-like. A história da informática seria certamente muito diferente se Smalltalk tivesse alcançado o merecido sucesso. Mas isso é díficil para quem está sempre um passo à frente.
(Walter)
Omissões Notáveis.
PHP
PHP é na minha opinião uma linguagem de desenho ruim, e que o passar do tempo apenas acentua isso.
JavaScript
Embora seja praticamente impossível desenvolver para a web sem ela, creio que ela já fica coberta pelo tópico Lua. Lua é muito semelhante à JavaScript, com objetos de primeiro nível, closures, e sintaxe parecida.
(Walter)
Uma das linguagens mais poderosas que há é Perl. Criada por Larry Wall em 1987 com base em C, Lisp, AWK e sed, Perl se tornou a base de diversas linguagens modernas, como Python e Ruby.
Possui uma abordagem sintática ligeiramente diferente, resultante de seu lema: «há mais de uma forma de fazer algo». Sua tipagem estupidamente fraca (só três tipos básicos, escalar, vetor e vetor associativo ou hash, mais alguns menos usados, como soquete) ajuda mais do que atrapalha, devido a sua abordagem, o que deixa os defensores da tipagem forte vermelhos de raiva.
Só que a implementação Perl de orientação a objetos é no mínimo excêntrica. Não usei outro adjetivo, como «alienígena», ou «transcendental», porque prefiro reservar estes para a implementação Perl de multithreading (vide as manpages perlthrtut e perlothrtut).
Há uma reformulação de POO para Perl chamada reform, mais parecida com Ruby, mas ainda não consegui fazer funcionar direito.package (óbvio =P). O final do pacote é onde termina o arquivo ou onde é declarado um novo pacote. Caso o programador queira começar o programa em si no mesmo arquivo onde são criados os pacotes, basta declarar o início do pacote main:package main;.pm (por exemplo, exemplo.pm) e importanto o pacote no arquivo .pl (use exemplo;).new e o destruidor DESTROY (com letras maiúsculas mesmo). Há um procedimento padrão no construtor, que deve ser executado invariavelmente: (1) determinar a classe, (2) criar a instância, (3) transformar a instância numa instância «real» da classe (com o operador bless) e (4) retornar a instância pronta.Pessoa, com os atributos nome e ano_nasc (ano de nascimento):package Pessoa;
sub new {
my $this = shift;
my $class = ref($this) || $this;
my $self = {
nome => shift,
ano_nasc => shift
};
return bless $self, $class;
}@_. No caso de métodos, o primeiro argumento é a instância escopo do método, assim como Python.shift retorna o «próximo» elemento do vetor – não sendo informado qual vetor, o padrão é @_. Se for a primeira execução de shift, retorna o primeiro elemento, se for a segunda, retorna o segundo elemento, e assim por diante.$this recebe o primeiro argumento, que é o escopo de execução, ou seja, uma representação da própria classe (diferente de todos os demais métodos =P). O próximo comando refina este dado.$self cria escopo escalar semelhante a um hash, cujas chaves são nome e ano_nasc, e os valores são respectivamente o segundo e o terceiro elementos de @_.$self em uma instância verdadeira de $class (bless) e retorna a instância (return).nome e outro para retornar a idade (calculada a partir de ano_nasc). Primeiro o nome:sub nome {
my $self = shift;
my $v = shift;
$self->{nome} = $v if ($v);
return $self->{nome};
}$self, depois a variável escalar $v recebe o próximo argumento (se não houver, recebe undef, equivalente a null de Java). Se foi passado algum parâmetro, este será atribuído à chave (atributo) nome, depois o valor deste é retornado.$inst->nome retorna nome. =)sub idade {
my $self = shift;
my (
$seg, $min, $hora,
$dia, $mes, $ano,
$dsem, $dano, $isdst
) = localtime(time);
return (1900 + $ano - self->{ano_nasc});
}$self.localtime(time) retorna a hora local na forma de um vetor de nove posições, onde as três primeiras são a hora e as três seguintes a data (as três últimas também não são complicadas, e são até bem úteis). Assim conseguimos atribuir o número do ano a $ano.106.1900 + $ano) e o ano de nascimento atribuído à instância (ano_nasc).@ISA.Retangulo, com o método desenhar e as chaves (atributos) altura e largura, e será criado um pacote filho Quadrado:package Retangulo;
sub new {
my $this = shift;
my $class = ref($this) || $this;
my $self = {
altura => shift,
largura => shift
};
return bless $self, $class;
}
sub desenhar {
my $self = shift;
foreach (1 .. $self->{altura}) {
foreach (1 .. $self->{largura}) {
print '(*)';
}
print "\n";
}
}
package Quadrado;
@ISA = qw/ Retangulo /;
sub new {
my $this = shift;
my $class = ref($this) || $this;
my $lado = shift;
my $self = new Retangulo($lado, $lado);
return bless $self, $class;
}
1[update 2008-09-09]Fica mais claro fazendo assim:[/update]package Quadrado;
use base qw/ Retangulo /;
…
Retangulo. Talvez o foreach, que repete o loop para cada elemento do vetor informado (o elemento atual é atribuído à variável especial $_). Veja a manpage perlintro.Quadrado. Logo de cara temos a atribuição de @ISA. O operador qw «quebra» a string fornecida (entre / /) em um vetor, onde cada palavra (qw = queue of words, lista de palavras) é um elemento. É aconselhável usar qw sempre que for feita uma atribuição a @ISA.Retangulo foi atribuído a @ISA de Quadrado, tornando este filho do primeiro.$lado está recebendo o primeiro parâmetro (segundo argumento, o primeiro é o escopo).$self, que chama o construtor do pacote (classe) pai. Repare que, da forma como está sendo feito, as duas chaves (altura e largura) receberão o valor de $lado (definição de quadrado, lembra?).formas.pm, então crie um arquivo teste.pl:#!/usr/bin/perl
use formas;
print "Qual o tamanho do lado do quadrado? ";
chomp($_ = <>);
my $sq = new Quadrado($_);
$sq->desenhar;
exit;$ perl teste.pl
Qual o tamanho do lado do quadrado?
Brincando na aula de PRJ no ISTCC-P, surgiu o assunto singleton (a página em inglês é muuuuito mais completa), que é quando queremos que uma determinada classe tenha somente uma instância, e esta instância seja retornada na tentativa de se criar novas conexões.
Complicado? Que nada! Vou dar o mesmo exemplo que o professor deu: imagine que seu programa tenha uma conexão com um banco de dados. Cada vez que uma função do programa tente criar uma conexão, esta receberá a conexão que já foi criada.
Simples! Em Java isso é feito «bloqueando» o construtor da classe e usando um método para intermediar esta requisição:
class Conexao {
//Atributos
...
private static Conexao inst = null;
//Metodos
private Conexao() {
// O construtor é privado!
...
}
public static Conexao nova() {
// Este método fará as vezes do construtor
if (inst == null)
inst = new Conexao();
return inst;
}
...
}new, mas o método nova():Conexao conn = Conexao.nova();new, que é a forma natural de se obter uma instância de classe. =Prequires 'singleton'
class Conexao
include Singleton
...
endinclude! Isto é incrivelmente simples, prático, mas tem um pequeno problema pra quem está tentando entender: como é que funciona?Singleton que implemente a funcionalidade (feature) desejada e herdar as demais classes desta.__init__(), mas há um método que é chamado antes do construtor, que é __new__(), e funciona de forma muito parecida com new de Perl. Ele cria a nova instância e a retorna.a = X(b, c)a = X.__new__(X, b, c)
a.__init__(b, c)__new__() retorne esta instância em vez de uma nova:class Singleton(object):
__inst = None
def __new__(cls, *args, **kw):
if cls.__inst is None:
cls.__inst = object.__new__(cls)
return cls.__inst
def __copy__(self): #(trecho novo de código!)
return self
def __deepcopy__(self, memo=None):
return self__inst que contém nada (None) na criação da classe, mas depois será uma referência à instância única.__new__() está preparado para receber argumentos genéricos (*args, **kw), mas não fará nada com eles – é problema do __init__(). A função do __new__() é verificar se já existe a instância única, se não existe, cria, depois retorna ela.class Conexao(Singleton):
...type. Metaclasses são classes filhas de type, portanto suas instâncias também são classes.__call__().unique em vez de singleton (Por quê? Porque eu gosto, ora pois!):class unique(type):
def __init__(cls, name, base, dict):
super(unique, cls).__init__(name, base, dict)
cls.__inst = None
cls.__copy__ = lambda self: self #(nova linha!)
cls.__deepcopy__ = lambda self, memo=None: self #(nova linha!)
def __call__(cls, *args, **kw):
if cls.__inst is None:
cls.__inst = super(unique, cls).__call__(*args, **kw)
return cls.__instsuper (construtor da classe pai, type) e depois, a única coisa que faz de diferente é criar um atributo privado de classe __inst. Só que este atributo é «mais privado» do que os normais. =)unique (a metaclasse). Podem imaginar o nível de proteção disso? É como em C++, só que funciona. =)__call__() faz exatamente o mesmo que __new__() no exemplo que usa herança, só que de forma mais eficiente. A implementação disso poderia ser:class Conexao(object):
__metaclass__ = unique
...autoprop?class Conexao(object):
__metaclass__ = type("__metaclass__", (autoprop, unique), {})
...type não é tão intuitivo... =Pclass Conexao(object):
class __metaclass__(autoprop, unique):
pass
...
Resolvi escrever sobre este assunto somente agora, pois somente agora consegui digerir o caso...
Steve Irwin, mais conhecido como o Caçador de Crocodilos, foi o diretor do Australia Zoo, fundado por seus pais Bob e Lyn Irwin em 1970.
A notícia de sua morte me foi dada da seguinte forma: «dá uma olhada no Google... aquele idiota dos crocodilos morreu»...
Tenho pena dessas pessoas que pensam assim. Vivem num mundo pequeno e sem sentido. Aquele «idiota» foi uma das pessoas mais admiráveis de nosso tempo, comparável a Jacques Cousteau.
Para dar uma pista da falta que Steve Irwin fará no mundo, segue uma citação dele:
Preservação ambiental é meu trabalho, minha vida, é tudo que sou. (Steve Irwin)
Algumas pessoas – de respeito até – dizem por aí que não existe vírus para GNU/Linux porque ele ainda não é tão usado quanto o Windows®, porém basta que o GNU/Linux se difundir mais para que comecem a aparecer os vírus.
Mas pensem só: por que então não há vírus para outros sistemas operacionais famosos?
Existem outros tipos de programa malicioso para GNU/Linux (e outros sistemas operacionais), como os worms, e com o aumento do uso do GNU/Linux consequentemente haverá o aumento desses tipos de programas. Mas não vírus.
O fato é o seguinte: não existe vírus pra GNU/Linux e nem nunca vai existir. Na verdade, «vírus» só existe pra Windows® e ponto.
Bem, é uma afirmação meio radical, não é? Mas ela tem base e vamos defendê-la neste artigo.
O Windows® possui um recurso em seu gerenciamento de processos que nenhum outro sistema operacional possui (pelo menos nenhum que eu conheça). O vírus é um mau uso desse recurso.
Mas que recurso é esse?
Quando um programa é executado, ele se torna um processo (task), ou seja, processo é um programa em execução. O sistema operacional mantém um controle de quais são os processos executados e o estado de cada um.
Cada processo possui pelo menos um fluxo de procedimentos, que é uma execução linear de comandos. Este fluxo é chamado thread. Alguns processos possuem mais de um fluxo – o que é chamado multithreading.
Só que multithreading é transparente para o sistema operacional! Quem gerencia os fluxos concorrentes é o próprio processo – inclusive o programador deve programar isso explicitamente.
Então cada processo possui um controle de quais são os fluxos atuais. Porém, reiterando, isso é transparente para o sistema operacional.
No caso do Windows®, a coisa é um pouco diferente.
No Windows® quem controla os fluxos dos processos é o cerne. É um recurso interessante, pois o sistema operacional pode iniciar novos fluxos em um processo ou interferir no processo encerrando alguns fluxos.
Agora, este recurso abre uma possibilidade de mau uso: um programa pode acessar o cerne e, através dele, se propagar para dentro de outros processos em execução.
Um vírus é isso! É um fluxo (thread) dentro de um processo que se replica para dentro de outros processos.
Em outros sistemas operacionais isso não é possível, pois o sistema nem sabe dos threads, então cada processo só possui threads que lhe pertencem. Já no Windows® o sistema pode interferir nos threads dos processos.
Não podemos de todo culpar a Microsoft por querer acrescentar recursos especiais – e inusitados – em seu sistema, de modo a criar um diferencial, mas que eles realmente pensaram mal, ah isso sim! E agora já é tarde para voltar atrás.
[]'s
PS: Valeu pela dica, Fábio!
Adivinha só que político brasileiro é este...
Vou dar uma dica: é de um partido que começa com P e termina com RONA...
[]'s
PS: A intenção aqui não é ofender ninguém! É uma brincadeira inocente!
Parece estranha a afirmação, mas eu odeio Informática.
Não estou falando da «ciência» em si, mas da comunidade. Vejo que os informatas são divididos em alguns grupos e não me encaixo em nenhum deles, talvez por isso eu odeie Informática.
As pessoas tentam me classificar: quem está de um «extremo» diz que pertenço ao extremo oposto e vice-versa, mas não.
Posso definir alguns grupos:
Há aqueles que só pensam na melhor tecnologia. Há outro grupo que só pensa no retorno financeiro.
Há ainda os fanáticos, que defendem suas «filosofias» acima de qualquer bom-senso.
Todos pecam num ponto: crêem que os fins justificam os meios.
Que se dane se a economia nacional vai pro brejo, se o desemprego aumenta, se companhias nacionais vão à falência, se há escravização tecnológica... que se danem todos estes efeitos colaterais, o importante são os fins.
Olha só que horror isso!
Quando comento isso, sou comunista, fanático, reacionário... isso é tapar o sol com a peneira.
Não sei se me fiz entender – mesmo porque não estou com muito tempo para me explicar melhor –, mas gostaria de saber sua opinião.
Se você também «odeia Informática», deixe um comentário e explique por quê. Se não, deixe um comentário defendendo sua posição. Prometo que serei bonzinho e tolerante com a moderação. =)
[]'s
Saiu o release candidate 1 (rc1) do Python 2.5!!!
Pra quem programa em Python, a versão final – programada para 12 de setembro – é o evento mais esperado do ano. =)
As mudanças mais sensíveis são:
Hoje vou fazer algo do qual não sou muito fã: vou dar uma de «reblogger». =)
O Silvio me enviou o seguinte endereço: Code your way to Gotham, falando do 2006 Google International Code Jam, uma espécie de maratona de programação promovida pelo Google, cuja a final este ano será realizada no centro de Manhattan.
O primeiro lugar levará US$10.000 e todos os finalistas receberão pelo menos US$750. Ainda por cima, obviamente o pessoal do Google estará procurando por novos talentos para contratação durante a competição.
Alguém se habilita?
[]'s
Lua é uma poderosa linguagem de programação procedural, orientada a objetos, de tipagem dinâmica, baseada em tabelas associativas e semântica extensível, projetada e implementada no Tecgraf, Grupo de Computação Gráfica da PUC-Rio, em 1993.
Foi projetada para ser uma linguagem de extensão, para que fosse possível que os usuários reconfigurassem aplicações sem necessidade de recompilação das aplicações.
Atualmente é a linguagem de script mais usada para programação de jogos (em segundo lugar está Python).
Uma curiosidade de Lua é não haver um módulo de suporte a números complexos. Vamos então implementar um.
__add() (adição), __sub() (subtração), __mul() (multiplicação), __div() (divisão) e __pow() (potência). Ainda há os métodos __unm() (inversão de sinal), __tostring() (conversão para string) e __concat() (concatenação).__eq() (igualdade), __lt() (menor que) e __le() (menor ou igual). Alguém pode perguntar «e quanto a ‘maior que’ e ‘maior ou igual’?». A resposta é simples, se a > b então b < a, capicci? A mesma idéia é para diferença (a ~= b é o mesmo que not a == b).{}) para criar a metatabela com alguns valores default e em seguida criaremos o construtor próprio para números complexos:local cmt = { real = 0, img = 1 }
cmt.__index = cmt
function cmt:new(o)
o = o or {}
setmetatable(o, self)
return o
endcmt:new(o) é um açúcar sintático para cmt.new(self, o) e é usada para métodos.setmetatable(o, self) define que a metatabela de o será self e o elemento __index informa de onde a tabela deve retirar os valores default (para elementos não definidos), e será a própria metatabela.local function new(...)
if arg.n == 0 then
-- nenhum argumento retorna i
return cmt:new { real = 0, img = 1 }
elseif arg.n == 1 and type(arg[1]) == “number” then
-- um argumento: numero real
return arg[1]
elseif arg.n == 1 and getmetatable(arg[1]) == cmt then
-- um argumento: numero complexo
return cmt:new { real = arg[1].real, img = arg[1].img }
elseif arg.n == 2 and
type(arg[1]) == “number” and type(arg[2]) == “number” then
-- dois argumentos reais
if arg[2] == 0 then
return arg[1]
else
return cmt:new { real = arg[1], img = arg[2] }
end
else
error “parse error”
end
endlua> print(numero)
table: 0x80725e0lua> print(numero)
3 + 2i__tostring(). Mas não será tão fácil assim!function cmt:__tostring()
local a, b = self.real, self.img
if b == 0 then
return tostring(a)
elseif b == 1 and a == 0 then
return “i”
elseif b == -1 and a == 0 then
return “-i”
elseif b == 1 and a ~= 0 then
return a .. “ + i”
elseif b == -1 and a ~= 0 then
return a .. “ - i”
elseif b ~= 0 and a == 0 then
return b .. “i”
elseif b > 0 and a ~= 0 then
return a .. “ + “ .. b .. “i”
elseif b < 0 and a ~= 0 then
return a .. “ - “ .. (-b) .. “i”
else
error “unexpected (a + bi) combination: contact author”
end
end(a + bi)-1).(a – bi) / (a – bi).a / (a2 + b2) e imagem -b / (a2 + b2).local function inv(v)
if getmetatable(v) ~= cmt then
return v ^ (-1)
else
local a, b, q = v.real, v.img
q = a ^ 2 + b ^ 2
return new(a / q, -b / q)
end
endlocal a, b, q = v.real, v.imga, b e q são definidos como variáveis locais. a recebe v.real, b recebe v.img e q recebe nil.b, queremos que -b retorne um número complexo com os sinais do real e da imagem invertidos:function cmt:__unm()
return new(-self.real, -self.img)
enda == b, sendo a e b tabelas, na verdade está verificando se a e b são exatamente a mesma tabela, não se seus elementos são iguais. O quer queremos quando comparamos dois números complexos é se representam o mesmo valor, ou seja, se seus reais são iguais e se suas imagens também são.function cmt:__eq(v)
if getmetatable(v) == cmt then
return self.real == v.real and self.img == v.img
else
return self.img == 0 and v == self.real
end
end+), subtração (-), multiplicação (*), divisão (/), potência (^) e concatenação (..).function cmt:__add(v)
local a1, b1, a2, b2, a3, b3 = self.real, self.img
if getmetatable(v) ~= cmt then
a2, b2 = v, 0
else
a2, b2 = v.real, v.img
end
a3, b3 = a1 + a2, b1 + b2
return new(a3, b3)
enda1 recebe self.real e b1 self.img. Todas as demais variáveis recebem nil.function cmt:__sub(v)
return self + (-v)
endfunction cmt:__mut(v)
local a1, b1, a2, b2, a3, b3 = self.real, self.img
if getmetatable(v) ~= cmt then
a2, b2 = v, 0
else
a2, b2 = v.real, v.img
end
a3, b3 = a1 * a2 – b1 * 2, a1 * b2 + a2 * b1
return new(a3, b3)
endfunction cmt:__div(v)
return self * inv(v)
endfunction cmt:__pow(v)
if v == 0 then
-- expoente 0 retorna 1
return 1
elseif v == 1 then
-- expoente 1 retorna uma cópia de si mesmo
return new(self)
elseif v < 0 then
-- expoente negativo retorna inversao
return inv(self ^ (-v))
else
local aux, cont = new(self)
for cont = 2, v do
aux = self * aux
end
return aux
end
endreturn inv(self ^ (-v))__pow() para self, mas desta vez com argumento -v.function cmt:__concat(v)
return tostring(self) .. tostring(v)
endlocal function sqrt(v)
if type(v) ~= “number” then
error “value must be a number”
end
if v >= 0 then
return v ^ .5
else
return (0, (-v) ^ .5)
end
endlocal function iscomplex(v)
return getmetatable(v) == cmt
endlocal). Vamos então criar uma tabela pública onde colocaremos somente as partes que nos interessam:complex = {
iscomplex = iscomplex,
new = new,
sqrt = sqrt,
i = new()
}complex.lua no diretório atual e execute o interpretador lua. Execute os seguintes comandos e veja se funciona:lua> require “complex”
lua> for c = -4, 7 do print(c, complex.i ^ c) end
-4 1
-3 i
-2 -1
-1 -i
0 1
1 i
2 -1
3 -i
4 1
5 i
6 -1
7 -i
lua> a = complex.sqrt(-9) + 2
lua> b = complex.new(3, 2)
lua> print(a, b)
2 + 3i 3 + 2i
lua> print(a + b)
5 + 5i
lua> print(a * b)
13i
lua> print(a / 2)
1 + 1.5i
lua> print(b ^ 2)
5 + 12i
Recomendação de filme (velho =D) bom! Quem não viu ainda, tente ver, quem já viu, vale a pena a reprise.
[]'s
Doctor Who foi uma série de ficção científica da década de 1960 produzida pela BBC de Londres.
O programa original durou de 1963 a 1989 e atualmente está passando remake no canal People+Arts às 22:00 na sexta-feira.
Simplesmente é a melhor série de ficção científica desde Star Trek!
Trata das viagens do último dos «senhores do tempo» como historiador, mas também procura e corrige desvios no fluxo do tempo.
Ele gosta muito de visitar a Terra, onde eventualmente escolhe um «mono imbecil» – «stupid ape», como ele costuma chamar os seres humanos quando comentem erros estúpidos – para acompanhá-lo.
Recomendo ao leitor que, se possível acompanhe a série.
[]'s
Depois de muita propaganda aqui está o artigo sobre desempenho de algoritmos. =)
Os programadores sabem que sempre há mais de um jeito de obter o mesmo resultado, mas cada um vai apresentar um desempenho diferente.
Uma das melhores sequências para a comparação de diferentes implementações é a sequência de Fibonacci. Primeiro por ser possível usar diversos algoritmos clássicos, como recursão e reiteração, segundo porque é uma sequência que existe naturalmente, o que a torna fascinante em si.
Caso alguém não conheça a sequência de Fibonacci, ela começa assim:
1 1 2 3 5 8 13 21 34 55 89...
Os matemáticos gostam de começar de zero (0 1 1 2 3...), o que não está errado e funciona da mesma forma – aliás fica mais fácil de calcular –, no entanto se considerarmos a essência natural da sequência em vez de seu comportamento matemático (Leonardo Pisano Fibonacci era naturalista e viajante antes de matemático, mais ou menos como Wallace e Darwin), veremos que não é possível que o zero participe da sequência.
Cada elemento é igual à soma dos dois elementos anteriores, e os dois primeiros valores são 1 e 1.
def fib(n):
if n < 2:
return 1
else:
return fib(n - 2) + fib(n - 1)fib(0) = fib(1) = 1. Os demais valores são calculados somando-se os dois anteriores.def fib(n):
a, b, c = 0, 1, 1
while c <= n:
a, b, c = b, a+b, c+1
return by (tempo). Outra coisa que podemos reparar é que seu desempenho cai aritmeticamente (o tempo cresce em linha reta), favorecendo seu uso mesmo para índices mais altos.class memoize:
def __init__(self, f):
self.__cache, self.__func = {}, f
self.__doc__ = f.__doc__
for e in dir(f):
if not e.statswith('_'):
setattr(self, e, getattr(f, e))
def __call__(self, *args, **kw):
i = repr((args, kw))
try:
r = self.__cache[i]
except KeyError:
r = self.__func(*args, **kw)
self.__cache[i] = r
return r@memoize
def fib(n):
if n < 2:
return 1
else:
return fib(n - 2) + fib(n - 1)matriz = Matriz_2x2(1, 1, 1, 0)
def fib(n):
return pow(matriz, n)[0]
e 
.
.def fib(n):
n += 1 # incrementa o índice
sqrt5 = pow(5., .5) # raiz quadrada de cinco
autovalor = (1 + sqrt5) / 2, (1 - sqrt5) / 2
resultado = (
pow(autovalor[0], n) - pow(autovalor[1], n)
) / (
autovalor[0] - autovalor[1]
)
return int(resultado + .5) # arredonda o resultado__pow__() da classe Matriz_2x2), caso contrário se torna muito ineficiente. De qualquer forma, a partir dos autovalores da matriz característica, é possível calcular a função fechada, que resolve a sequência por álgebra linear, método altamente eficiente e que não sofre muita variação ao longo da projeção cartesiana.
CC-BY: Os textos deste blog podem ser reporduzidos contanto que sejam informados autor e origem, exceto os marcados com a tag 
Reblogging, que pertencem a outros autores, sob suas próprias licenças.
