sábado, 21 de abril de 2007

Ping pong na Matrix!

Olá a todos.

Bem... quem gosta de ping pong? Muita gente... Olha o show desses doidos...

Link do video no YT.
Edit: Olha esses outros vídeos dos mesmos kras:
- Salto com vara
- Karate

Kra por isso que eu digo q japa são os kras mais doidos! Só tem maluco japa sinistro.

Abraços, até.

Artigo completo (View Full Post)

sexta-feira, 20 de abril de 2007

Blado blado blado blado blado com filtro .. iuitobiu .. iutome.

Chorei de rir ... me fez lembrar o bom e velho saduiche iche

Artigo completo (View Full Post)

Quer me enviar um código? Cola nesse site

Olá olá a todos.

Neste post vou falar sobre um site interessante que eu encontrei passeando um pouco no IRC do Debian.

Vocês já se depararam com uma situação onde vocês precisem mostrar um código ou um texto para várias pessoas (talvez uma só) e não têm onde colocar este texto? Quem usa IRC sabe hehe.

Bem um cara criou esse site que é muito legal. Você escolhe seu nick, seleciona o tipo de texto (ele pinta código xD), coloca uma descrição e pronto. É só mandar a url para qualquer um.

Eu acho uma super ferramenta para trocar códigos ou informações com um número bom de gente.

Imagina: 5 pessoas no MSN conversando sobre um programa e precisam mostrar partes de código umas para as outras... Com esse site é possível.

Então valeu. abraços para todos e aproveitem. Ia me esquecendo. Como diz o FAQ o cara apaga a parada em 24 horas. Mas vale a moral e a idéia do cara. Foi para o meu del.icio.us na hora. Em tempo: criem e divulguem os seus favoritos também para a galera saber quais sites cada um gosta de acessar e conhecer algo novo.

Agora sim, abraços a todos.

Artigo completo (View Full Post)

quinta-feira, 19 de abril de 2007

Introdução - Object Pascal

É uma linguagem de programação declarativa, fortemente tipada.
Declarativa: Significa que cada declaração possui uma seção especifica para tal.
Contém todo o conceito da orientação a objetos:


  • Abstração.

  • Encapsulamento.

  • Herança.

  • Polimorfismo.



Algumas extensões foram incluídas para otmizar o uso tais como:

  • Conceitos de propriedades, particulares e públicas.

  • Tipos de informações em modo run-time: RTTI.

  • Manuseamento de exceções, e referências de classes.




Além disso a Object Pascal consegue suportar as características de baixo nível de programação, tais como:

  • Controle e acesso das subclasses do Windows© (API);

  • Passar por cima das mensagens de loop do Windows©;

  • Mensagens semelhantes as do Windows©;

  • Código puro da linguagem Assembler.



A base de toda a programação Delphi é a linguagem Object Pascal, hoje em dia rebatizada de Delphi Language. Neste artigo trataremos exclusivamente de uma introdução a esta linguagem de programação.

Símbolos Especiais


A ceita os seguintes caracteres ASCII:

  • Letras - do Alfabeto Inglês: A até Z e a até z.

  • Dígitos - Decimal: 0 até 9 e HexaDecimal: 0 até 9 e A até F (ou a até f)

  • Brancos - Espaço (ASCII 32) e todos os caracteres de controle ASCII (ASCII 0 até ASCII 31), incluindo final de linha e Enter (ASCII 13).

  • Especiais - Caracteres: + - * / = < > [ ] . , ( ) : ; ^ @ { } $ #

  • Símbolos - Caracteres: <= >= := .. (* *) (. .) //



O colchetes esquerdo ( [ ) e equivalente ao (. e o colchetes direito ( ] ) e equivalente a .). A chave esquerda ( { ) e equivalente ao (* e a chave direita ( } ) e equivalente a *).

Palavras Reservadas

Utiliza-se das seguintes palavras reservadas, não podendo as mesmas serem utilizadas ou redefinidas:

And Exports Library Set
Array File Mod Shl
As Finnaly Nil Shr
Asm For Not String
Begin Function Object Then
Case Goto Of To
Class If On Try
Const Implementation Or Type
Constructor In Packed Unit
Destructor Inherited Procedure Until
Div Initialization Program Uses
Do Inline Property Var
Downto Interface Raise While
Else Is Record With
End Label Repeat Xor
Except


Uma outra lista a seguir, apresenta as diretivas que são utilizadas em contextos de identificação de objetos:

Absolute Export Name Published
Abstract External Near Read
Assembler Far Nodefault Resident
At Forward Override Stored
Cdecl Index Private Virtual
Default Interrupt Protected Write
Dynamic Message Public


Números


É possível definir variáveis e constantes de tipos de Inteiro ou Real através de qualquer decimal ordinário (0 a 9), mas a Object Pascal também aceita a notação Hexadecimal utilizados com o prefixo dollar ( $ ) ou a notação científica (E).

Constantes


Uma constante é um identificador com valor(es) fixo(s). Um bloco de declarações constante possui a seguinte expressão:
[Declaração Constante]  [Identificador]  (=)  [constante] (;)

A lista abaixo apresenta um conjunto de funções que podem ser utilizadas para a declaração das constantes:

Ab Length Ord SizeOf
Chr Lo Pred Succ
Hi Low Ptr Swap
High Odd Round Trunc


Alguns exemplos para a definição de Constantes:

  • const Min = 0;

  • Max = 100;

  • Centro = (Max - Min) div 2;

  • Beta = Chr(225);

  • NumLetras = Ord('Z') - Ord('A') + 1;

  • MensOla = 'Instrução inválida';

  • MensErro = ' Erro: ' + MensOla + '. ';

  • PosErr = 80 - Length(MensErro) div 2;

  • Ln10 = 2.302585092994045684;

  • Ln10R = 1 / Ln10;

  • DigNumericos = ['0'..'9'];

  • LetrasAlpha = ['A'..'Z', 'a'..'z'];

  • AlphaNum = LetrasAlpha + DigNumericos;



Expressões


As expressões em Object Pascal (como em qualquer linguagem) é formada por operadores e operandos; os operadores são divididos em quatro categorias básicas:

Únicos @, Not
Multiplicativos >, /, div, mod, and, shl, shr, as
Adicionais +, -, or, xor
Relacionais =, < >, <, >, < =, > =, in, is

As expressões obdecem as regras básicas de lógica para a precedência da execução das operações.

Identificadores


Identificadores podem ser constantes, tipos, variáveis, procedures, funções, unidades, programas e campos de registros.
Não existe limite de caracteres para o nome de um identificador mas apenas os 63 primeiros caracteres são significantes (não podendo ser idêntico ao nome das palavras reservadas). O nome de um identificador deve ser iniciado por Letras ou o carácter underscore ( _ ). O resto é formado por Letras, Dígitos, carácter underscore (ASCII $5F). Não é permitido a utilização de espaços para a formação do nome.
 Exemplo de identificadores válidos: Form1, SysUtils.StrLen, Label1.Caption

Estruturas


with... do...;
Delimita um determinado bloco de declarações para um identificador específico evitando a declaração deste identificador. A sintaxe do comando é: WITH {nome do identificador} DO {comandos};. Ex:

begin
{ ... comandos iniciais ... }
with form1 do
begin
Caption := ‘Teste’;  Equivalente a Form1.Caption
BorderStyle := bsSizable;  Equivalente a Form1.BorderStyle
end;
end;


Declarações descrevem ações de um algorítmo a serem executadas.


begin... end;
Prende um conjunto de declarações em um bloco de comandos determinado. A sintaxe do comando é: BEGIN {comandos} END;. Ex:

begin
{ ... comandos iniciais ... }
begin
{ ... bloco 1 ... }
end;
begin
{ ... bloco 2 ... }
end;
{ ... comandos finais ... }
end;

if... then... else...;
Esta expressão escolhe entre o resultado de uma condição booleana o caminho verdadeiro (then) ou falso (else). A sintaxe do comando é: IF {condição} THEN {bloco de comandos} ELSE {bloco de comandos};. Ex:

begin
{ ... comandos iniciais ... }
if x > 2 then
{ ... Bloco verdadeiro ... }
else
{ ... Bloco falso ... };
end;

goto... ; (OBS: Nunca usem isso)
Transfere a execução de um programa para o ponto determinado pelo Label. A sintaxe do comando é: GOTO {Label};. Ex:

label
primeiro;
begin
{ ... comandos iniciais ... }
if x = 2 then
goto primeiro;
{ ... outros comandos ... }
Primeiro:
{ ... comandos do Primeiro ... }
end;

case... of... else... end;
Consiste de uma lista de declarações que satizfaz a condição de um seletor de expressões, se nenhuma parte da lista satisfizer ao seletor executa os comandos do sub-comando else. Para o seletor serão válidos os tipos definidos, tipo Inteiros ou LongInt. A sintaxe do comando é: CASE {seletor} OF {Expressão 1}: {comando da expressão 1}; {Expressão 2}: {comando da expressão 2}; {Expressão n}: {comando da expressão n} ELSE {comando}; end;. Ex:

begin
{ ... comandos iniciais ... }
case x of
1: { ... Bloco para x = 1 ... }
2, 3: { ... Bloco para x = 2 ou X = 3... }
4..6: { ... Bloco para 4 <= x <= 6 ... }
else { ... Bloco para x <> 6 ... };
end;
end;

repeat... until;
Repete um determinado bloco de declarações até a condição booleana do subcomando until ser satisfeita. A sintaxe do comando é: REPEAT {comandos}; until {condição};. Ex:

begin
{ ... comandos iniciais ... }
x := 0;
repeat
x := x + 1
until (x = 2);
end;

for... to (downto)... do...;
Incrementa em 1 uma determinada variável inteira, repetindo um bloco de comandos, até que esta atinja o valor final do intervalo, o subcomando downto realiza o incremento reverso. A sintaxe do comando é: FOR {variavel} := {valor inicial} to (downto) {valor final} do {bloco de comandos};. Ex:

begin
{ ... comandos iniciais ... }
for i := 1 to 10 do  Executa o [comandos A] para i = 1,2,3,4,5,6,7,8,9 e 10
{ ... Comandos A ... }
for s := 10 downto 1 do  Executa o [comandos B] para i = 10,9,8,7,6,5,4,3,2 e 1
{ ... Comandos B... }
end;

while... do...;
Repete um bloco de comandos enquanto que determinada condição booleana seja satisfeita. A sintaxe do comando é: WHILE {condição} DO {bloco de comandos};. Ex:

begin
{ ... comandos iniciais ... }
while i := 1 do  Repete o [Bloco de comandos] enquanto i = 1
{ ... Bloco de comandos ... }
end;

break; ou continue...;
O comando break interrompe um bloco de repetição for, while ou repeat saindo do bloco. A sintaxe do comando é: BREAK; enquanto que o comando continue retorna a primeira instrução do bloco de repetição for, while ou repeat. A sintaxe do comando é: CONTINUE;. Ex:

begin
{ ... comandos iniciais ... }
for i := 1 to 10 do
begin
if i = 8 then
break;  Salta para os [comandos C]
{... comandos A...}
if i = 5 then
continue;  Retorna para o comando for pulando os [comandos B]
{... comandos B ...}
end;
{... comandos C ...}
end;

Artigo completo (View Full Post)

quarta-feira, 18 de abril de 2007

RSS, ATOM e FEED For Dummies


Acessar informação de forma rápida parece estar se tornando coisa do passado. Hoje em dia , as pessoas estão preferindo acessar a informação de forma instantânea. Pois é exatamente a isso que se propõe as tecnologias a que estamos nos referindo neste post. Observamos freqüentemente, cada vez mais comum nos sites, blogs, web pages em geral, os termos: Syndicate, RSS, Atom, XML, Feed. Até eu, que trabalho com tecnologia, fui pego se surpresa. Calma ae ... o que que é isso?

Falando de forma simples, essas siglas são tecnologias que oferecem novas formas de acesso a um conteúdo de um site. Uma forma instantânea de acesso dinâmico, ou seja se o contudo do site é atualizado, dinamicamente, sem que vc precise clickar me nada esse novo conteúdo é atualizado automaticamente no seu navegador, ou web page.
Para um entendimento inicial dessa tecnologia imagine que podemos organizar o conteúdo de uma página em duas partes distintas: Uma parte é de informação, e a outra, de apresentação, formatação. Por exemplo, normalmente o padrão adotado para os Blogs: temos os posts e o template. Os códigos que montam a apresentação de uma página HTML no browser, parte deles se preocupam e apresentar o conteúdo, outra parte se preocupa em como apresentar o conteúdo. Poderíamos chamar de meta-informação. Nós, humanos, convencionalmente considerados “evoluídos” e “inteligentes”, conseguimos facilmente diferenciar uma coisa de outra quando lemos o código fonte de um site. É óbvio se vc souber interpretar os códigos e tags ali dispostos. Mas para um computador interpretar isso, depende de mais um nível de protocolação. Digamos assim. Do contrário é praticamente impossível para o computador saber qual código é referente ao conteúdo que interessa aos humanos e que não é. Por exemplo: Imagine como um sistema, ou programa, poderia identificar, ou diferenciar, quando um site foi atualizado do seu conteúdo, ou de quando, por exemplo, um banner de propaganda ou um contador de vistas e comentários foram alterados?
O formato RSS é basicamente um arquivo XML cujo objetivo é informar as últimas atualizações no conteúdo de um site.
A partir do RSS outros formatos para acessar o conteúdo de um site apareceram, como o RSS 2.0 e o Atom. Todos eles, no que tange a usabilidade pelo usuário final, fazem a mesma coisa. Entretanto, apesar disso, há quem prefira um formato em detrimento de outro. Contudo, praticamente todos os programas aceitam mais de um formato. Portanto isso não é grande problema. Feed: Nome genérico da tecnologia descrita acima.


Ok, agora você quer disponibilizar o feed do seu blog.

O que precisa? Nada, praticamente todos os sistemas de blog já disponibilizam feeds automaticamente, em diversos formatos. Consulte a documentação do seu sistema de blog para mais detalhes.
Links:
Feed readers
Feed Brasil

Artigo completo (View Full Post)

Aula de Funk

Olá a todos os queridos freqüentadores do blog.

Vocês conhecem o funk carioca? Sabem dançar o funk carioca?

Vejam essa aula com os professores Josicreuda e Magalhãese:

Artigo completo (View Full Post)

Aplicações Robustas II: Desenvolvendo a técnica


Esse artigo é continuação do post “Robustez no Delphi

Dando continuidade a seqüência de artigos sobre tratamento de exceções.....

A Estrutura “Try…Finally…End”:

Bloco protegido:
É impressindível garantir que, em tempo de execução, os recursos alocados por vc, na codificação de um módulo, sejam desalocados, mesmo ocorrendo um erro. Que recursos me refiro? Arquivos, memória (alocação dinâmica), recursos do Windows, objetos (instâncias de classes, que entram tb no quisito memória).
Para garantir a desalocação dos recursos, usamos a estrutura abaixo:


{Aqui vc aloca os recursos}
try
{Aqui temos comandos que usam os recursos}
finally
{Libera os recursos de forma gsarantida}
end;



Como já falamos antes, a aplicação sempre executará os comandos inseridos na parte Finally do bloco, mesmo que uma execeção ocorra. Quando um erro ocorre no bloco protegido, o programa pula para a parte “finally”, chamada de código limpo, que é executado. Mesmo que não ocorra um erro, estes comandos são executados.
No código a seguir, alocamos memória e geramos um erro, ao tentarmos uma divisão por 0. Apesar do erro o programa libera a memória alocada:


procedure TForm1.Button1Click(Sender:TObject);
var
ZnMyPointer : Pointer;
ZnInteger, ZnDividend : Integer;
begin
ZnDividend := 0;
GetMem(ZnMypointer, 512);
try
ZnInteger := 10 Div ZnDividend;
finally
FreeMem(ZnMypointer, 512);
end;
end;


A Estrutura ‘Try…Except…End”:

Com ela podemos tratar erros que ocorrem dentro de blocos protegidos. Para definir um tratamento de exceção, utilize a seguinte construção:


try
{Comandos que você deseja proteger}
except
{Comandos de tratamento de erros}
end;

Mais uma vez repassandoo que vimos no post anterior, o progrma irá executar os comandos na parte “except” somente se ocorrer uma exceção. Se na parte “try” você chamar uma rotina que não trata erros, e uma exeção ocorrer, em decorrencia de algum comando dentro do escopo dela, ao voltar para este bloco a parte “except” será executada. Uma vez que a aplicação localiza um tratamento para exceção ocorrida, os comandos são executados, e o objeto exceção é destruído e o fluxo do programa sai do bloco protegido. A execução continua se houver mais comandos após o bloco protegido até o fim do módulo.
Dentro da parte “except” definimos um código a ser executado para manipular tipos específicos de exceção. Um exemplo mais que batido, contudo didático, o código abaixo trata o erro de divisão por zero, através da exceção EDivByZero:


function ZnDivisao (const ZnSoma, ZnNum : Integer) : Integer;
begin
try
Result := ZnSoma div ZnNum;
except
on EDivByZero do Result := 0;
end;
end;

Falamos ainda a respeito da palavra reservada “on”. Ela define respostas para uma exceção. “on” está sempre junto de “do”; eu chamo de estrutura “on ..do, para manipular a exceção.
Para recuperar informações específicas sobre a exceção ocorrida, você usa uma variação da estrutura “on…do”, que provê uma variável temporária cujo o tipo pode ser quaisquer uma das classes derivadas de Exception, inclusive a própria. Nesse caso, você poderá personalizar tanto a string da mensagem da exceção, quanto a janela que exibirá a mensagem:


try
{* Comandos * }
except
on E: EInvalidOperation do
MessageDlg(‘Personalizando a exceção – Minha mensagem é ... a da exceção é:‘+E.Message,
mtinformation,[mbOk],0);
end;


Você deve cuidar para que, havendo mais de uma, as estruturas “on..do” estejam dispostas do tipo de exceção mais específico para o mais genérico como foi exemplificado no post anterior.



Técnicas avançadas

Tipo genéricos de Execções:
1° Caso: você pode utilizar as classes de exceções genéricas para tratar um erro, em vez de uma específica. Por exemplo, se você quer tratar um erro relacionado a uma operação com inteiros, mas não sabe exatamente o erro, poderá utilizar a exceção EIntError, que é a exceção genérica da qual derivam outras exceções relacionadas a inteiros:

function Divisao (const ZnSoma, ZnNum : Integer) : Integer;
begin
try
Result := ZnSoma div ZnNum;
except
on EDivByZero do Result 0;
on EIntError do
MessageDlg('Outro erro com inteiros aconteceu', mtError, [mbOk],0);
end;
end;


2° Caso: Você pode estruturar ainda um tratamento padrão de erro para tratar exceções que não tenham tratamentos especificados. Para isto, adicione uma parte “else” na parte “except” do bloco:



try
{Comandos}
except
on EintOverFlow do
{Código especifico para o primeiro tipo de erro]
on EintError do
{Código específico para o segundo tipo de erro}
else
MessageDlg('Um erro aconteceu, mas com certeza está relacionada com inteiros',
mtError, [mbOk],0);

end;


Toda técnica está fundamentada num conhecimento específico. No que tange o objetivo do artigo em questão, a pesquisa que apresento a seguir, considero ser alicerce para o refinamento da técnica de tratamento de exceções:


Exceções da RTL:
run-time library, as exceções geradas pela RTL estão definidas na unit SysUtils. Há sete tipos de exceções geradas pela RTL:


Exceções de conversão.
Exceções de entrada e saída.
Exceções de Hardware.
Exceções de memória heap.
Exceções matemáticas envolvendo inteiros.
Exceções matemáticas envolvendo pontos flutuantes.
Exceções de typecast.


Exceções de Conversão

Podem ocorrer quando usamos funções de conversão de um tipo para outro. A exceção chamada EConvertError é lançada quando isto ocorre, avisando que a conversão não pode ser feita. Exemplo:


var
ZnNumInteriro: Integer;
begin
ZnNumInteriro := StrToInt(Edit1.text);
end;


Dependendo do valor que possuir a propriedade “Text” do Edit1, poderá ocorrer uma exceção de conversão. Na vida real, posso garantir que o código exemplificado acima certamente irá, em algum momento, sofrer uma. Basta que não seja digitado nada no “Edit”.


Exceções de Entrada e Saída

Quando seu código tenta acessar arquivos ou dispositivos de entrada e saída.
A exceção genérica de entrada e saída, EinOutError, que contém um atributo, ErrorCode que indica o erro ocorrido.


Exceções de Hardware

Ocorrem em dois tipos de situação: quando o processador detecta uma falha, ou quando a aplicação gera uma interrupção intencional.
A Unit SysUtils define uma exceção genérica chamada EprocessorException, com as exceções derivadas:

 
Efault (Exceção Base),
EGPFault (Falha Geral de Proteção),
EstackedFault (acesso ilegal ao seguimento stack do processador),
EpageFault (O windows não está conseguindo realizar o swap),
EinvalidOpCode (O processador encontra uma instrução indefinida),
EbreakPoint (A aplicação gerou uma interrupção breakpoint),
Esinglestep (A aplicação gera uma interrupção single-step).


Exceções de Memória Heap

Quando alocamos memória dinamicamente podem ocorrer exceções. Para essa situação existem dois tipos de exceção: EoutofMemory (indica que não há memória suficiente) e EinvalidePointer (Ponteiro Inválido).


Exceções Matemáticas para Inteiros

Podem ocorrer quando se realiza operações com números inteiros. Está definida na SysUtils a exceção genérica EintError, com três tipos de exceção derivadas: EdividByZero (Divisão por zero), ErangeError (Número fora do intervalo, fora de faixa), e EintOverFlow (Estouro na operação com inteiro).


Exceções de Pontos Flutuantes

Quando se realiza operações com dados do tipo real. A SysUtils define uma exceção genérica chamada EMathError, e as seguintes exceções derivadas: EinvalidOp , EZeroDivide, EOverFlow , EUnderFlow.


Exceção de TypeCast

Para proteger seu código quando em tempo de execução vc precisa assumir que um determinado objeto possa ser de um tipo de classe. Caso ocorra um cast de tipo, ou seja, conversão de tipo, inválido, usando o operador de typecast “as” é gerada a exceção EinvalidCast. Exemplo:


(* para esse exemplo coloquei um edit e um button, palheta standard, num form. *)
procedure TForm1.Button1Click(Sender: TObject);
begin
(Sender as TBitBtn).Glyph.LoadFromFile('C:\Img.bmp');
end;


Basta que vc confunda a classe do botão, faça um cast de um TButton para um TBitBtn, pronto: “Invalid typecast”.



Exceções da VCL

Alguns exemplos de exceções definidas na VCL:

EDBEditError: Definida na unit “Mask”. Diz respeito a erros ocorridos com o uso do componente TDBEdit.


EDataBaseError: Gerado sempre que ocorre um erro no Banco de Dados

EDBEngineError: Gerado sempre ocorre um erro no BDE.

EPrinter: Gerado quando ocorre um erro com a impressora.

EDDEError: Gerado a aplicação não consegue encontrar um servidor DDE.

EMCIDeviceError: Gerado quando ocorre um erro ao tentarmos
acessar um dispositivo multimídia.

Exceções Silenciosas

A procedure Abort gera uma exceção do tipo Eabort. Isso, é claro, “abortará” a operação, sem exibir mensagem alguma.
O exemplo abaixo aborta a operação de inclusão de itens em um Listbox:
Inicie uma nova aplicação no Delphi:
Adicione os seguintes componentes da palheta standard: um Button (Button1: TButton) e um ListBox (ListBox1: TListBox).
Na seção “private” do Form1 declare um procedimento como no trecho de código abaixo:


type
TForm1 = class(TForm)
Button1: TButton;
ListBox1: TListBox;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
procedure ExcecaoSilenciosa;// Ao terminar de digitar, pressione “Ctrl+ Shift + C”
public
{ Public declarations }
end;

var
Form1: TForm1;

implementation

{$R *.dfm}


A seção “type” do seu forme deve estar igual ao trecho acima. Conforme o comentário ao lado da procedure “ExcecaoSilenciosa”, quando vc pressionou “Ctrl+ Shift + C”, em resposta, o Delphi automaticamente criou o corpo da procedure. Portanto, vamos codificar, continue conforme o trecho a seguir:


procedure TForm1.ExcecaoSilenciosa;
const
ATexto = '%d° Elemetnto';
begin
Listbox1.Items.Add(‘Preparando para adicionar’);
//Estrutura de repetição, utilizada para adicionar os itens
Repeat
// adicionado os elementos
Listbox1.Items.Add(Format(ATexto, [ListBox1.Items.Count]));
// um teste louco pra forçar a exceção silenciosa
if (ListBox1.Items.Count mod 21 = 0) then Abort;
until ListBox1.Items.Count > 50;
end;


Cada vez que um item é adicionado na ListBox, a propriedade Count, da propriedade itens é incrementada. Ou seja, a propriedade “Count” retorna quantidade de itens que existem na ListBox.
Agora vamos codificar a chamada a esse procedimento e obviamente fazer o tratamento de exceção que vai dar o groove no nosso exemplo.

 
procedure TForm1.Button1Click(Sender: TObject);
begin
try
ExcecaoSilenciosa;
except
on Exception do
begin
Self.Color := clRed;
Self.Caption := 'Exceção Silenciosa!'
end;
end;

end;




Continuamos falando sobre este assunto no Estação ZN.

Artigo completo (View Full Post)

segunda-feira, 16 de abril de 2007

Vamos jogar pedra, papel e tesoura?

Olá a todos os amigos.

Esse post traz algo realmente nada a ver. Eu estou postando só porque eu e minha mulher adoramos: jogar perda, papel e tesoura.


Felipeeeee... O que é pedra, papel e tesoura?
Bem. Conhecem o famoso par-ou-ímpar? É parecido. É um jogo de mãos em que há três elementos (advinha quais são):

Pedra - mão fechada (como se fosse zero)
Papel - mão aberta (como se fosse cinco)
Tesoura - dois dedos (indicando dois)

Aqui estão as regras:
Papel embrulha a Pedra (Papel > Pedra)
Pedra quebra a Tesoura (Pedra > Tesoura)
Tesoura corta o Papel (Tesoura > Papel).

Simples assim. Quem já teve o prazer de jogar no Master System o jogo Alex Kidd in Miracle World (Há... esse é da antiga! xD) já enfrentou duelos de Pedra-Papel-Tesoura em alguns chefões. Huahuahauahauhaua bons tempos aqueles...

Para quem acha que isso é só brincadeira, confira esse artigo na Wikipedia.

Eu achei na net até um artigo sobre táticas e (acreditem) trapaças em Pedra-Papel-Tesoura. O conteúdo dos links está em inglês.

Sempre que eu e minha mulher estamos num impasse nós recorremos ao Janken (esse é o nome japoronga do jogo). Posso dizer uma coisa: Ou eu sou péssimo ou ela é muito boa! pq ela ganha toda hora xD.

Tentem jogar e vejam se não é muito melhor que par-ou-ímpar...

xD Abraços e até mais.

Artigo completo (View Full Post)

sábado, 14 de abril de 2007

Aplicações Robustas: Conhecendo mais sobre Exceções

Esse artigo é continuação do post “Robustez no Delphi

Conforme vimos no post anterior, sobre a importância de cuidarmos para que os softwares que venhamos a desenvolver sejam robustos, daremos mais um passo no intuito de conhecer com mais profundidade o mecanismo de tratamento de exceções nessa ferramenta. Fizemos uma introdução sobre o emprego das estruturas “Try, finally” e “try, except” como elas funcionam e como empregá-las. Associado a essa questão, chamamos a atenção também para as vantagens que podemos colher, quando efetivamente aplicamos os recursos existentes no Delphi para o tratamento de exceções e proteção de bloco de código. Além da garantia de execução segura do seu aplicativo, o que por si só já justifica seu emprego, obsevamos vantagens quanto a organização do código, facilidade de entendimento e manutenibilidade.
Vimos que as classes de exceções são definidas na exatamente como as demais classes existentes no Delphi. É recomendado que qualquer exceção que o desenvolvedor venha a criar seja derivada da classe “Exception”, que está definida na “SysUtils”. Quando seu programa faz uso da unit Sysutils todos os erros de runtime (erros em tempo de execução) automaticamente são traduzidos em exceções. Erros estes que eventualmente podem comprometer o funcionamento da sua aplicação, tais como: “insuffient memory”, ou “division by zero” e etc.


Trabalhando com Exceções parte II


1 – Criando uma exceção: Raise é a palavra reservada para se criar uma exceção (uma instância da classe Exception, ou qualquer uma de suas extenções) que é passada para o manipulador de exceções do Delphi. Para criar um objeto da classe “Exception” basta chamar o construtor da classe com o statement “raise”. Exemplo:

raise EMathError.Create(‘Erro: EMathError’);// Específico

Ou simplesmente

raise Exception.Create(‘Erro bla: Exception’);// Genérico


Quando vc cria uma exceção, como no exemplo acima, imediatamente o fluxo de código é interrompido e essa exceção passa a ser gerenciada pelo manipulador de exceção. Caso vc não a trate, o manipulador de exceções do Delphi irá exibir a string que foi passada como parâmetro para o construtor da classe exception, em seguida tentará retornar a execução normal do programa. Exemplo:

(* para esse exemplo coloquei um edit e um button, palheta standard, num form. *)
procedure TForm1.Button1Click(Sender: TObject);
begin
if Edit1.Text = '' then
raise EMathError.Create('Digite um número.');

end;


Salve o exemplo (simultaneamente pressione: “Ctrl + Shift + S”) e compile (sequencialmente digite: “Alt, p, b”), na pasta aonde vc salvou rode o programa a partir do executável e teste. Caso vc seja iniciante, e não saiba reconhecer o executável, basta procurar no diretório um arquivo de extenção “.exe”. Para executar, dê um duplo click no executável.


Vamos agora colocar algum nível de tratamento para essa exceção que acabamos de criar. Para reforçar a idéia do manipulador de exceção vamos codificar esse tratamento em outro procedimento. Vamos adicionar no Form1 mais um botão, Button2, e no vento OnClick do mesmo chamaremos o evento Button1Click que codificamos para o exemplo anterior.

procedure TForm1.Button2Click(Sender: TObject);
begin
try
Edit1.Text := '';// atribui vazio para forçar a exceção
Button1Click(Button1);// chama o procedimento que vai criar a axceção.
Form1.Color := clYellow;
except
Edit1.Text := '2'; // Ocorrendo a exceção, atribui ‘2’ para a prop. text de edit1.
Form1.Caption := 'Exceção ocorrida.'; // atribui valor para o captio do From1
Button2.Caption := 'Pressionado!';
end;

end;

Novamente, salve o exemplo e compile, rode o programa a partir do executável e teste. Lembre-se agora vc deve pressionar o Button2.



Note que o form1 não fica amarelo. Claro, a exceção interrompe a execução e desvia para o fluxo do “except” executando todos os comandos dispostos ali. Nenhuma mensagem é exibida, pq quando vc está trabalhando com um estrutura “try/except”, é como se vc falasse pro Delphi: Deixa que essa exceção eu trato. Ou seja, vc é responsável por esse tratamento, agora a manipulação dessa exceção é da sua competência, não mais do manipulador do Delphi Mas como podemos manipular a exceção? Vamos mudar um pouco o código para exemplificar isso:
.
(* Adicione mais um botão, TButton da palheta standard *)
procedure TForm1.Button3Click(Sender: TObject);
begin
try
Edit1.Text := '';
Button1Click(Button1);
Form1.Color := clYellow;// executado somente se não ocorrer a exceção
except
on MyVar: Exception do
MessageDlg(‘A msg capturada foi: ’ + MyVar.Message, mtWarning, [mbOK], 0);
end;
end;




Com a palavra reservada “on” podemos manipular a exceção. Ela permite usar uma variável (no exemplo eu usei MyVar), sem a necessidade de uma declaração prévia, numa seção var, para que possamos acessar a propriedade “message” da classe exeption capturar a mensagem e exibi-la no formato que desejarmos. Se eu quiser, ainda para esse tratamento executar mais de um comando, basta delimitar o bloco por “begin ... end”. Exemplo:

procedure TForm1.Button3Click(Sender: TObject);
begin
try
Edit1.Text := '';
Button1Click(Button1);
Form1.Color := clYellow;// executado somente se não ocorrer a exceção
except
on MyVar: Exception do
begin
Form1.Caption := MyVar.Message;
Button3.Caption := 'Pressionado!';
MessageDlg('A msg capturada foi: ' + MyVar.Message, mtWarning, [mbOK], 0);
end;
end;
end;


Para testar: salve e compile, rode o programa a partir do executável. Lembre-se agora vc deve pressionar o Button3.


2 - Estrutura “on ... do”: A idéia de tratamento de exceção comporta também a ação do programador recuperar em tempo de execução (run time) a exceção que ocorreu, identificar seu tipo e transformar a mensagem de erro que ela exibiria numa mensagem mais amigável, inteligível para o usuário. É justamente isso que fazemos os quando empregamos as palavras reservadas “on ... do”. Logo, podemos fazer tantos testes quanto necessário, dependendo da quantidade de tipos de exceções diferentes possam ocorrer.

(* Adicione mais um Edit, Edit2, e um Button, Button4. Ambos da palheta standard *)
procedure TForm1.Button4Click(Sender: TObject);
var
AuxInteiro: Integer;
begin
try
AuxInteiro := StrToInt(Edit2.Text);
if (Edit1.Text <> '') and (Edit2.Text <> '') then
raise Exception.Create('Exceção genérica!');

Edit1.Text := '';
Button1Click(Button1);

except
on Bl: EMathError do
begin
Form1.Color := clRed;
Form1.Caption := E.Message;
MessageDlg('Msg capturada: Edit1 ' + Bl.message, mtWarning, [mbOK], 0);
end;

on E: EConvertError do
begin
Form1.Color := clGreen;
Form1.Caption := E.Message;
MessageDlg('Msg (EConvertError): ' + E.message, mtConfirmation, [mbCancel], 0);
end;

on E: Excetpion do
begin
Form1.Color := clWhite;
Form1.Caption := '';
MessageDlg(E.message, mtInformation, [mbAbort], 0);
end;
end;
end;

Vamos testar: salve, compile, em seguida rode o programa a partir do executável. Se vc simplesmente apenas clicar o Button4. Vai acontecer um erro de conversão, visto que o processador vai tentar converter a string “Edit2” para inteiro. Portanto serão executados os comandos onde testamos se a exceção e do tipo “EConvertError”.

Entretanto, basta vc digitar qualquer número no Edit2 para que sejam executados os comandos da última estrutura “on ..do , onde testamos o tipo mais genérico de todos, “Exception”.



Agora, se vc digitar um número no Edit2 e limpar o conteúdo do Edit1 serão executados os comandos da primeira estrutura “on ..do , onde testamos o tipo da exceção “EMathError”.



Ok, até agora tudo parece simples. Concordo, de fato é simples, entretanto, devemos prestar muita atenção num pequeno detalhe que pode fazer toda a diferença na hora de tratarmos exceções: As estruturas “on ... do” devem sempre ser organizadas testando do tipo mais especializado para o mais genérico. Do contrário o processador jamais irá testar o mais especializado se ele encontrar um teste de um tipo genérico o qual extende a exceção corrente. Para exemplificar isso, altere o código do exemplo anterior colocando a últuma estrutura “on ... do” para ser a primeira linha após o “except”. Ao testar, vc poderá perceber que, embora a mensagem mude, nunca mais serão executados os comandos das outras estruturas não importe o que vc faça durante o teste.


(* trocando a estrutura de lugar *)
procedure TForm1.Button4Click(Sender: TObject);
var
AuxInteiro: Integer;
begin
try
AuxInteiro := StrToInt(Edit2.Text);
if (Edit1.Text <> '') and (Edit2.Text <> '') then
raise Exception.Create('Exceção genérica!');

Edit1.Text := '';
Button1Click(Button1);

except
on E: Excetpion do
begin
Form1.Color := clWhite;
Form1.Caption := '';
MessageDlg(E.message, mtInformation, [mbAbort], 0);
end;

(* não importa o que vc faça, essas linhas nunca serão executadas *)
on Bl: EMathError do
begin
Form1.Color := clRed;
Form1.Caption := E.Message;
MessageDlg('Msg capturada: Edit1 ' + Bl.message, mtWarning, [mbOK], 0);
end;

on E: EConvertError do
begin
Form1.Color := clGreen;
Form1.Caption := E.Message;
MessageDlg('Msg (EConvertError): ' + E.message, mtConfirmation, [mbCancel], 0);
end;
end;
end;


Como já falamos antes, a classe “Exception” é a mais genérica de todas as classes de exceção. Isso quer dizer que, ela é o ancestral mais alto de todas as outras exceções. Por isso, não importa que tipo exceção ocorra (todas, ou herdam diretamente de “Exception”, ou herdam de algum nível de herdeiro de “Exception”), quando vc for verificar que tipo de exceção ocorreu, se para isso vc tomar como referência “Exception”, isso será verdadeiro para qualquer descendente, sendo irrelevante o grau da descendência. Mas, pergunto eu, todas as demais estruturas “on ... do” não serão verificadas pelo processador? Não. Ele executa somente um bloco de código da estrutura “on ... do” dentro de um “try ... except”. Ao terminar de executa a última linha de comando do “on ..do”, cujo a classe de exceção ocorrida é igual, ou hierarquicamente inferior, ele sai do “try ..except ” para continuar a execução dos outros comandos que por ventura possam existir após o “end” delimitador da estrutura. É por isso que se o tipo mais genérico das classes de exceção estiver sendo verificado no primeiro “on .. do” os posteriores jamais serão executados. Retirei um trecho de código da SysUtils, fiz uma pequena adequação para exemplificar melhor a herança, na definição das classes de exceção:

Type

EExternal = class(Exception)
EExternalException = class(EExternal);
EIntError = class(EExternal);
EDivByZero = class(EIntError);
ERangeError = class(EIntError);
EIntOverflow = class(EIntError);
EMathError = class(EExternal);
EInvalidOp = class(EMathError);
EZeroDivide = class(EMathError);
EOverflow = class(EMathError);
EUnderflow = class(EMathError);
EInvalidPointer = class(EHeapException);
EInvalidCast = class(Exception);
EConvertError = class(Exception);
EAccessViolation = class(EExternal);
.
.
.


Artigo completo (View Full Post)

sexta-feira, 13 de abril de 2007

Turbine seu firefox - e os sites que você acessa

Olá a todos os freqüentadores do nosso blog. Eu peço muitas desculpas a todos por não ter postado durante uns 10 dias... Eu estive em pequenas férias e aproveitei um pouco xD

Vim trazer um post bem light e uma recomendação.

Muita gente por aí já usa o Firefox. Talvez nem tanta gente saiba que no site há milhares (centenas na verdade xD) de extensões e temas para personalizar o navegador e também dar novas funcionalidades. Eu, por exemplo, navego por horas na net só procurando boas extensões. Vou recomendar algumas agora.

Adblock Plus - Não exibe no navegador algumas propagandas e banners chatos que ocupam o lugar do conteúdo de alguns sites.

Fasterfox - Aumenta a performance do navegador (que já é boa).

Firefox Showcase - Bem... eh... Vocês sabem o Ctrl+Q do IE7? Pois é... eh... [sem graça] Não é tão bonito, mas é muito legal. Mostra todas as abas numa janela com preview.

MeasureIt - Quer saber quais são as dimensões daquela imagem? Daquele div? Essa extensão permite desenhar um retículo em qualquer parte da página e ele dá as dimensões. Para mim é muito útil.

Por último e não menos importante...

Greasemonkey - Essa extensão é uma doideira...

Há um site onde pessoas criam scripts em JavaScript que interagem com praticamente todos os sites da internet.

Como assim Felipe? Eu explico...

Imagina o GMail... Imagina se você pudesse tirar algumas partes, adicionar outras e mudar o tema dele? Pois é, já criaram este script.

Imagina você lendo um artigo na internet e quer pesquisar determinada palavra na wikipedia? Como seria fácil se você selecionasse a palavra e apertasse 'w' no teclado e abrisse uma barra do lado com o conteúdo da Wikipedia? Pois é, já criaram este script.

Eu podia ficar aqui meia hora listando as 223 páginas de scripts que esse site tem, mas acho que já deu pra pegar a idéia.

Mas Felipe, você estava falando de extensões do Firefox, lembra? Lembro. O ponto é: Esta extensão - Greasemonkey - permite você instalar estes scripts e toda sua experiência de navegação muda completamente!

Vou mostrar algumas imagens:



Este é meu GMail atual




Aqui eu selecionei a palavra activeX e pressionei 'w' e aquela barra no lado direito apareceu com o artigo da Wikipedia sobre ActiveX. Legal, não.

Por aí vai... Você encontra download de vídeos do YT (e todos os outros sites similares também), remodelador de margens, mostrar 100 resulados por página no Google, exibir resultados do Google em duas colunas, mostrar o vídeo do YT direto mesmo que no site haja apenas a url... Para sites de blog e notícia tem quilos... Tem até uma que troca o nome do George Bush! Hehe... Realmente há milhares de scripts para mudar completamente a maneira de navegar na internet.

Como é JavaScript logo eu também vou tentar criar alguma parada dessas, mas por enquanto eu só estou abrindo os fontes dos outros e fazendo umas pequenas modificações. Estou gostando muito.

Bem, então valeu... Divirtam-se com o Firefox e 'redescubra a web'!

P.S.: Vocês repararam que o meu Firefox está muito parecido com um navegador bem conhecido? É assustador. Tem gente muito talentosa por aí galera...

Artigo completo (View Full Post)

 
BlogBlogs.Com.Br