Vitor Rubio Developer - Dicas de programação

Method Error 500 - Maximum Length Exceeded with AJAX web service call

2012-02-22T04:26:00.000-08:00

Eu estava codificando um clássico formulário de cadastro, e resolvi usar Cascading Dropdown do Ajax Control Toolkit para a seleção de Estados e Cidades.
O conceito é simples: ao selecionar um Estado no ddlEstados o ddlCidades será populado apenas com as cidades desse estado.

O problema se manifestou da seguinte forma: para os estados que continham mais cidades, como MG, o ddlCidades era populado apenas com a mensagem "Method Error 500", porém essa não era uma exception disparada, e não era possível debugar o projeto e encontrar o disparo da exception. (Talvez se eu usasse o source do Ajax Control Toolkit em vez da biblioteca compílada seria possível debugar).

Tudo indicava que a exception estava sendo tratada, e no tratamento ela escrevia esse erro 500 nos itens.

Esse problema é causado porque existe um limite máximo de itens JSON que uma página pode mandar ou receber. Para alterar esse valor deve-se acrescentar as seguintes linhas no web.config:

Lembre-se que esse 5000000 é um exagero, apenas de exemplo. Dependendo do caso 2000 está de bom tamanho.

Links que podem ser úteis:

http://www.asp.net/ajaxLibrary/AjaxControlToolkitSampleSite/CascadingDropDown/CascadingDropDown.aspx
http://www.asp.net/ajaxLibrary/AjaxControlToolkitSampleSite/Walkthrough/CCDWithDB.aspx
http://harriyott.com/2007/07/method-error-500-maximum-length.aspx

Have Fun ;)

Empregos DEV - Lá e de volta outra vez!

2012-02-15T13:16:00.001-08:00

Pois é pessoAll,
Saudades de vocês .... mais ou menos

Passei uns bons 3 ou 4 meses sem postar nada (e com minha vida digital totalmente jogada às traças).

Para me desculpar com meus (poucos) leitroes: é que eu fui demitido. Sim, é frustrante, e pode acontecer com qualquer um. Só que eu fui demitido em uma época em que além de uma fatura medonha de cartão de crédito eu tinha (e ainda tenho) um TCC da pós graduação para fazer.

Fiquei os 45 primeiros dias fazendo de 2 a 3 entrevistas por dia durante o dia, e a noite me candidatanto a TODAS as vagas possíveis.

Depois entrei em uma empresa chamada Lider Telecom, que presta serviço para a Telefônica (sim, eu me tornei aquilo que mais odeio na minha vida, e todo dia me auto flagelo com uma agulha de tricô incandescente direto no fígado.)
Nessa empresa tenho que entrar as 8:00, sair as 18:00 todo dia, sem horário flexível, sem atrasos, sem carnaval, com hora extra na conta do abreu e .... já entendeu né?
Sem contar que a empresa fica a 1:30 h da minha casa. Acordar todo dia as 5:30 para conseguir chegar no trampo as 8:00 pegando a linha vermelha do inferno lotada e o Cidade Tiradentes <-> Metrô Penha é tão agradável quanto uma dose de quimioterapia. (não exagerei na hipérbole, quem me conhece sabe porquê).

Por isso o blog ficou para as cucuias.

Mas isso foi bom, aprendi um monte de coisas nessa busca por emprego, e vou deixar as dicas aqui:

1) Todas as dicas que você já viu em revistas da área de RH, sites etc são válidas, porém nossa área tem umas peculiaridades interessantes.
2) Vestimenta: modéstia e bom juízo sempre. Mesmo se você for um ~~nerd~~ programador jovem que não terá contato com clientes e fornecedores, eu garanto que um terno nunca será a vestimenta errada, peque por excesso. Ainda mais se você for um velho obeso mórbido de 400 quilos como eu, pega mau aparecer de calça jeans e camiseta "nerdpower" ou "bsod" na entrevista, de boa, um terno emagrece.
3) Faça um cartão pessoal. É bom, bonito, elegante, mostra suas habilidades e seu interesse comercial, é um mini-cv e tem os seus contatos sempre à mão. Eu entreguei "uma pá", e como isso é vendido em doses de 1000, eles estão se multiplicando em meu armário.
5) Seja muito atento a listas enumeradas que pulam um número.
6) Não, você não tem inglês fluente, ainda mais se quem for entrevistas você em "inglês" for um argentino, ou um texano.
7) Fuja de PJ, a não ser que você queira mesmo (e muito) abrir uma empresa e tocar seu próprio negócio. Muita dor de cabeça com impostos e compromissos fiscais.
8) Fuja de cooperativas igual o diabo foge da cruz.
9) Tenha um CV em inglês.
10) Tenha um segundo CV resumido. Principalmente se você for entrevistado por várias pessoas da empresa, deixe o CV mais técnico com a equipe técnica ou com quem faz a pré seleção, e o CV resumido, com formação e qualidades pessoais/profissionais você entrega para o pessoal administrativo/RH.
Eu programo em um monte de linguagens (algumas mais outras menos), conheço um monte de tecnologias e bancos de dados, assim como você. Não dá pra colocar tudo isso no CV, polui muito, além disso eu posso programar até em Fortran (que eu nunca tentei) tendo acesso ao google e um bom livro. Além disso tecnologias no CV confundem o pessoal de RH.
Já vi funcionário de RH despensando um CV que constava habilidades em C# porque a empresa estava precisando de .Net (se o cara tivesse escrito .Net em vez de C# estava empregado.) Vi também a mesma pessoa dispensar um cara mestre em Interbase porque ela precisava de alguém fera em Firebird (WTF? o.O). Ou seja, você pode falar qualquer abobrinha para essas pessoas do RH porque elas são totalmente desqualificadas para julgar, avaliar ou medir um profissional de TI, principalmente de desenvolvimento de software.
11) Um portfólio vale mais que um currículo. Se você tiver blog, sites na web, códigos, componentes e programas feitos por você mostre, inclusive o fonte, não deixe de mostrar o seu estilo de codificação. Mesmo que você não seja contratado isso pode render boas sugestões.

Alguns sites que você talvez já conheça e que são bons (ou não) para arranjar emprego.

Monster --> http://inicio.monster.com.br/
O sistema é muito bem feito, mas falta um link para o seu profile, para você poder entregar o link em vez do CV. Falta um http://inicio.monster.com.br/SeuNome/ sabe? Fora isso o CV fica muito bem diagramado nele, ele tem muitas opções e informações para preencher, e muitos campos. Dá um certo trabalho preencher, mas no final você terá um CV em inglês, uma carta de apresentação e por aí vai.

Catho --> http://www.catho.com.br/
Uma droga. Resumindo é isso. Não que o sistema deles seja ruim, muito pelo contrário, o sistema é o melhor, mas é bom para quem quer vagas administrativas, liderança e assim por diante. Na parte técnica/tecnológica tem muitas vagas falsas, e não adianta denunciar.
Já cheguei a pegar vaga oferencendo salário de 13.000 CLT e na hora da entrevista era 4.500 PJ. Ou oferecendo salário de 6.000 CLT e nos campos customizados (que as empresas põe para você preencher dados que elas julgam relevantes e que não tem no cadastro padrão) perguntam qual sua pretenção salarial PJ.
Fora isso a amostra grátis/degustação de 7 dias não rende entrevista nenhuma, e se você esquecer de cancelar você terá de pagar. E quem, em sã consciência, estando ~~fodido~~ desempregado gastaria dinheiro em um serviço que teve 7 dias para mostrar resultados e provou que não funciona? Você pode procurar meu CV lá, está mais apresentável que na Monster.

APInfo --> http://www.apinfo.com/
Esse é legal, é do estilo "se vira, procura, manda e-mail e espera retorno", foi o que mais rendeu entrevistas, mas também foram quase todas entrevistas para PJ, Cooperado, enrolado etc. Quando era CLT os salários eram risíveis, nível estagiário a Júnior.

ProgBr --> http://www.progbr.com
Esse é para nós programadores, mas assim como o APInfo, ele é meio caótico. O gerenciamento de qual vaga você se candidatou, qual não, trocas de mensagens e envio de CV é manual. Melhorou MUITO de uns tempos pra cá, porém dois dos empregos que já tive foram pela APInfo.
O progBr tem perfil http://www.progbr.com/user/index.php?u=vitorrubio

Trabalhando.com --> http://www.trabalhando.com
Bonitinho, com perfil, mas nunca me rendeu uma entrevista sequer. Aliás, para nossa área é o pior de todos. Tem um sisteminha de perfil legal também http://www.trabalhando.com/cvpub/7706j4585cba64429a4e605e82967ab6804040441/vitor-rubio/

http://oportunidades.ixdasp.org
É do Universia Empregos e está integrado ao Trabalhando.com.

Vagas --> http://www.vagas.com.br
Se você quiser trabalhar em um banco como Itaú esse é o caminho. Muitas vagas legais vem daqui, mas são vagas de empresas que tem o processo seletivo engessado e dividido em váaaaaarias etapas. As empresas podem disponibilizar questionários e testes para você responder online. Fiz um teste de inglês (leitura e interpretação de texto) onde você tinha 30 segundos para responder cada questão. Também há testes de matemática e lógica assim (pff, dá só 5 seg. somos todos fodões né?).

Também tem um tal de Manager.com e http://www.pagepersonnel.com.br. Não testei e particularmente acho que já cadastrei meu CV em lugares demais.

Sempre pegue os nomes das empresas top 10 nas revistas Exame, Info Exame, CerTIficação e Gestão de Carreira etc... Nessas fontes podem vir sugestõs de boas empresas para se enviar CV.

Todos os sites de vagsas podem ter arapucas. Cuidado. Tem esquemas de pirâmide, gente que promete um salário e paga outro, gente que promete um emprego CLT e é PJ e assim por diante. Por falar nisso eu também sou "distribuidor independente" de uma famosa empresa de shakes para emagrecer. Quer perder peso, ~~eu também quero~~ pergunte-me como.

Locais onde fiz entrevista: na casa do chapéu, onde Judas perdeu as meias, Tão Tão distante.
Tempo para encontrar um emprego novo: 45 dias.
Tempo para encontrar em emprego decente igual ao que eu estava antes: 195 dias e contando ......

Não me conformo como foi difícil para um cara, com faculdade, pós graduação, certificação microsoft (tudo bem, só a mcp-zinha, mas ainda assim uma) e inglês, diga-se de passagem, "marromeno" (cursando ainda, mas já fasso entrevistas em inglês, naquelas, mas faço) demorei tanto e/ou tive tanta dificuldade para arrumar emprego.
É, cara, a concorrência está f..., tem sempre alguém melhor que você disposto a ganhar menos que você. Se você tem 30 anos ou mais então, pior ainda, isso é considerado a terceira idade da TI. Estou preocupado, acabei de fazer 29. Não acho trampo assim tão fácil agora. (lembro que os 4 primeiros cairam do céu, praticamente me chamaram).

Dicas em entrevistas e formulários de RH. Quando te perguntarem quais são suas qualidades, seja modesto porém honesto na hora de responder. Quando te perguntarem suas fraquezas, responda "kriptonita" sem hesitar.

Pontos positivos e aprendizado:
O baque me tirou da "zona de conforto" e me deu oportunidade para eu aplicar algumas coisas que eu tinha aprendido, e estudar outras que eu gostaria de aprender. Acabei me envolvendo com nHibernate e adorei. Criei na empresa um pequeno CMS com o nHibernate, com postas, páginas, links etc. Também faz alguns controles da empresa e emite o holerite do funcionário on-line. Estou começando a estudar o C# e o .Net mais a fundo e aprendendo um monte de coisa legal que vou postar aqui.

É isso. Próximo post será sobre SQL. Até lá!

Formatando datas no SQL e no C#

2011-10-24T06:45:00.000-07:00

Muitas vezes é necessário exibir datas em um determinado formato no GridView. Muitos programadores convertem a data para o formato desejado já na consulta SQL ou procedure. Isso não está correto por uma série de motivos, entre os quais podemos citar:

1) A responsabilidade de formatar a data deve ser totalmente da view, ou seja, da camada de apresentação.
2) Datas formatadas pelo SQL não são mais datas, são varchars, e não podem ser ordenados como datas.
3) Trazendo sempre a data integral do banco de dados pode-se fazer qualquer operação desejada com ela.

Veja o link abaixo para tirar qualquer dúvida que você possa ter a respeito.
http://weblogs.sqlteam.com/jeffs/archive/2007/04/13/format-date-sql-server.aspx

Dito isso, algumas considerações interessantes:

Para formatar strings diretamente em uma GridView adicione a coluna (bound column) e defina um valor para a propriedade DataFormatString:

<asp:BoundField DataField="Data" DataFormatString="{0:dd/MM/yyyy}" HeaderText="Data" />
<asp:BoundField DataField="Hora" DataFormatString="{0:HH:mm:ss}" HeaderText="Hora" />

dd - Dia com dois dígitos
MM - Mês com dois dígitos, deve ser maiúsculo
yyyy - Ano com quatro dígitos

hh - Hora no formato de 12 horas (necessário AM e PM)
HH - Hora no formato de 24 horas
mm - Minuto
ss - Segundo

Função para extrair a data de um datetime, com hora 0:00:00

CREATE  function [dbo].[sudf_Common_DateOnly]
(
@dtDateTime DateTime
)
returns datetime
as
begin
    return dateadd(dd, 0, datediff(dd, 0, @dtDateTime))
end

Função para extrair a hora de um datetime, com data 01/01/1900

CREATE function [dbo].[sudf_Common_TimeOnly]
(
      @dtDateTime datetime
)
returns datetime
as
begin
    return dateadd(day, -datediff(day, 0, @dtDateTime), @dtDateTime)
end

Fonte:
http://www.lazerwire.com/2011/10/ms-sql-date-only.html
http://www.lazerwire.com/2011/10/ms-sql-time-from-datetime.html

Melhor fonte de informação sobre esses formatos:
http://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.boundfield.dataformatstring.aspx

Funções para lidar com datas:
http://msdn.microsoft.com/en-us/library/aa258863(v=sql.80).aspx

Conversão de datas com Convert no SQL Server:
http://www.sql-server-helper.com/tips/date-formats.aspx

Have fun ;)

Factory Reset do Samsung Galaxy S

2011-09-12T12:31:00.000-07:00

Neste endereço http://www.clangsm.com.br/vb/android-os/9802-aparelhos-android-hard-reset.html também há um procedimento para resetar o Galaxy S e apagar tudo, servindo para desbloqueá-lo.

Reproduzindo:
Para hard reset seu Samsung I9000 Galaxy S:

1. Desligue o aparelho. Se o seu celular Samsung Galaxy S está congelado, retire a bateria e recoloque-a.
2. Segure o botão Diminuir Volume.
3. Pressione e solte o botão Power.
4. Você está agora confrontado com um menu que permite Fastbook, recuperação Clear Storage, e Simlock.
5. Selecione Clear Storage, pressionando o botão Diminuir Volume.
6. Pressione e solte o botão Power.
7. Agora, basta confirmar a sua decisão: Volume para cima para confirmar e Volume para baixo para negar a ação.

Se SIM for selecionada, todos os dados, incluindo aplicações de terceiros serão apagados do seu Samsung I9000 Galaxy S. Uma vez que a limpeza for concluída, o telefone irá reiniciar a suas configurações de fábrica.

ou

-Botão do volume para cima+botão home+power
-Espere piscar I9000, solte o power (continue segurando home +volume)
-Com o botão do e volume selecione wipe data/factory.reset
-Home para confirmar
-Com o botão do volume vá até : yes - delete all user data
-Home para confirmar novamente
-Espere voltar e reboot system now
-Home para confirmar

É isso. Usei esse menu para outras coisas, como acesso de root, mas não para resetar. É por sua conta e risco.

Criando um lookup que chame uma de suas forms

2011-08-15T10:41:00.000-07:00

Um leitor deu a dica de fazer um lookup que chame uma das forms do projeto. Há várias maneiras de se fazer isso, mas uma que encontrei foi usar formulários registrados com RegisterClass. Depois é só usar FindClass para encontrar o formulário, e FindComponent para encontrar o componente onde reside o valor a ser trazido. Se o componente for um TPersistentField, melhor ainda. Ele pode ser achado, e com um typecast para TField seu valor (o valor encontrado e escolhido no formulario de procura/cadastro padrão) pode ser trazido para o keyvalue.

Abaixo um exemplo de como isso pode ser feito. Primeiro o registro do formulario:

initialization

  RegisterClass(TfrmConsulta);

Depois a chamada dele. Repare que ele é desconhecido para o formulário principal: não está no uses.

procedure TfrmPrincipal.Button1Click(Sender: TObject);
var
  NewFormClass: TFormClass;
  NewForm: TForm;
begin
  NewFormClass := TFormClass(FindClass( 'TFrmConsulta' ));
  //detalhe: esse  string 'TFrmConsulta' pode vir de um campo, edit, banco de dados, arquivo de configuração etc
  try
    NewForm := NewFormClass.Create(nil);
    NewForm.ShowModal;
  finally
    FreeAndNil(NewForm);
  end;
end;

Esse exemplo mostra como registrar formularios e chamá-los sem colocar no uses e sem que o "cliente" saiba da sua existencia.
Assim que tiver um tempo coloco isso encapsulado em um lookup.

Bancos de dados gratuitos parte 2

2011-08-11T16:31:00.000-07:00

Saiu na Clube Delphi 132 a parte 2 do artigo sobre bancos de dados gratuitos. Espero que todos gostem.

Esta edição ainda traz um artigo sobre Nota Fiscal Eletrônica 2.0, muito útil.

Não se esqueça que agora os códigos GTIN (códigos de barra a serem preenchidos nos campos cEAN e cEANTrib) agora são obrigatórios.

Um artigo que eu lerei com bastante curiosidade é o artigo sobre Morfik, que permite desenvolvimento par Web com Object Pascal, semelhante ao Delphi. Mas com o Morfik você também desenvolve código "client-side".

Espero que todos tenham boa leitura!

Artigos sobre bancos de dados gratuitos e lookups

2011-08-11T15:43:00.000-07:00

Saiu na revista Clube Delphi 131 dois artigos meus: um sobre bancos de dados gratuitos e outro sobre a criação de um componente lookup genérico.

Lokups são campos utilizados para fazer a ligação entre duas entidades, duas tabelas. Em uma tabela de venda, por exemplo, há informações sobre o código do cliente para quem a venda está sendo feita, o código da forma de pagamento, e assim por diante. Um formulário não deve ter campos para se digitar os códigos diretamente, e sim campos lookup, que possam ser usados para procurar a forma de pagamento, o cliente e as outras informações em questão pelo nome e não pelo código. Neste artigo fizemos um lookup, usando um ButtonedEdit e um formulário com grid, que pode funcionar em múltiplos bancos de dados e que traz os registros filtrando-os, usando para isso uma instrução SQL montada sob demanda. Isso ajuda a diminuir o tempo de abertura dos formulários e o tempo de carregamento dos lookups, bem como a quantidade de registros trazida nesses tipos de campo.

O outro artigo publicado fará parte de uma série de 3 artigos sobre bancos de dados gratuitos e ferramentas de acesso. Além do postgre, mysql e firebird ainda existem as versões gratuitas do DB2, Oracle, SQL Server entre outros. Além disso o artigo abordará como criar bancos SQLite e se conectar a eles.

Você sabia que além do DBXpress também há outras formas de se conectar a múltiplos bancos de dados? Existe o AnyDac, Zeos, Unidac, dezenas de drivers OLEDB ou ODBC, a possibilidade de usar ODBC com o DBXpress (que será recurso nativo do Delphi XE2) entre outros. Mas a suite de componentes de conexão mais rápida que eu já via é a Unidac.

Ambos os artigos terão uma continuação extra-oficial neste blog. O artigo sobre bancos de dados gratuitos terá um teste de performance mais profundo, fazendo também inserts e updates e usando clientdatasets em conjunto com outros tipos de datasets que não sejam o SQLDataset do DBX. Esse servirá como um catálogo definitivo de conexão com qualquer banco de dados.

Um leitor da Clube Delphi me deu uma dica interessante de colocar uma propriedade do tipo string no lookup e fazer com que ele chame um formulário de consulta ou cadastro que tenha o mesmo nome preenchido nessa propriedade. Isso faria com que o lookup pudesse "chamar" qualquer formulário do sistema sem que ele conhecesse suas units ou sequer soubesse que elas existem. Funcionalidade extra sem acoplamentos desnecessários.

Espero que tenham uma boa leitura.

erro "ora-12154: tns: não foi possível resolver o identificador de conexão especificado"

2011-07-15T15:10:00.000-07:00

Para se conectar uma aplicação Delphi no Oracle é necessário editar o arquivo tsnames.ora, geralmente na pasta C:\oraclexe\app\oracle\product\10.2.0\server\NETWORK\ADMIN caso seu oracle seja o XE.
Esse erro pode acontecer tanto em runtime como em design-time, com qualquer tipo de componente: DBX, ADO e assim por diante. É mais comum que aconteça em tempo de design em um windows de 64 bit.
Em alguns casos onde essa mensagem de erro aparece é porque o arquivo não existe ou está em uma pasta que o Delphi ou o seu aplicativo não tem permissão de acesso.
Na grande maioria dos casos o erro ocorre apenas em design-time e nunca em runtime. Se esse é o seu caso então provavelmente a culpa é do windows de 64 bit, mais especificamente o fato de o Delphi estar instalado na pasta "Arquivos de Programas (x86)". Explicando, o driver de conexão ao oracle não suporta caminhos contendo parênteses "()", esses que tem no "(x86)". Ele não consegue encontrar nem o driver de conexão nem o arquivo tsnames.ora por causa desses parênteses. Instale o Delphi em uma pasta tipo "Arquivos de Programas" "normal" ou até mesmo em uma pasta direto na raiz, como c:\Delphi.
Se o Delphi já está instalado nesta pasta problemática ainda assim é possível copiar toda a pasta do RAD STUDIO (geralmente C:\Arquivos de programas (x86)\Embarcadero\RAD Studio) para uma pasta qualquer, tipo c:\rad studio, e execute o Delphi dali. (ele se encontra na pasta 7.0\bin se for o 2010 ou 8.0\bin se for o XE, é o arquivo bds.exe).
Ele vai executar normalmente, mesmo no local "errado", já que tudo que ele precisa em matéria de bibliotecas está no registro e ele consegue encontrar no diretório original, e isso não impedirá de que uma conexão DBX com o oracle funcione normalmente. Vai funcionar mesmo em design-time, e compilar sua aplicação normalmente.

Have fun ;)

Key Violation em nested datasets

2011-06-30T12:45:00.000-07:00

Resolva de uma vez por todas o problema de "key violation" em datasets "detail" ligados a datasetfileds através de providers.

Cenário: você tem duas tabelas num relacionamento 1:n tipo mestre-detalhe no seu banco de dados, por exemplo Pedidos e ItensDoPedido.
A chave primária de ambas as tabelas é auto-numerada, por exemplo com ajuda de um generator do firebird. A Tabela itens tem uma chave estrangeira PedCodigo, que é o código do pedido, mas para controle interno também tem uma chave primária CodItem, autonumerada.
Você colocou no formulário dois SQLDatasets, um fazendo o select em Pedidos e outro fazendo o select em ItensDoPedido, com um "where CodPedido = :CodPedido" para fazer a "ligação". Você ligou o SQLDataset detalhe (ItensDoPedido) a um datasource ligado ao SQLDataset mestre. Você ligou também um DatasetProvider ao SQLDataset de Pedidos e ligou um ClientDataset cdsPedidos a esse provider, criando um dataset field (campo do tipo dataset), talvez chamado sqlItens, e ligando o ClientDataset cdsItem a este dataset field, criando assim o cdsDetahle.

Você talvêz tenha recebido alguma mensagem de que o campo CodItem é requerido e não pode ser deixado null, então tomou providências para deixar a propriedade required do campo = false ou atribuido algum valor randômico a ele. Se fez isso é sinal de um design fraco. Há maneiras mais elegantes de se resolver isso, veja as soluções 2 e 3.

Problema: Quando você insere o segundo item no ClientDataSet cdsItem recebe a exception "Key Violation".

Causa: O cdsItem (detalhe) também possui uma chave primária, CodItem. Quando você dá o post no segundo item ele é gravado com o mesmo valor do registro anterior: null ou zero se você definiu para atribuir zero no evento "onNewRecord" ou "beforepost". Como chave primária ele não pode se repetir no cdsItem, mesmo sabendo que os códigos serão criados no banco de dados automaticamente depois do applyupdates e do commit da transação. Antes disso não há valor definido para a chave primária do item.

Há 3 maneiras de solucionar:

1) Atribua um número randômico (pode até ser negativo) ou GetTickCount à chave primária no evento OnNewRecord.
Desvantagens: essa é a gambiarra mais feia e porca que existe. Além de poluir o código, caso o número randômico se repita, o que estatisticamente pode acontecer, ocorrerá o key violation. Caso use GetTickCount este pode trazer um número maior do que o suportado pelo integer field, já que retorna um cardinal sem sinal, podendo causar o erro de integer overflow. Portanto a solução 1 está aqui para fins "didáticos" (ou não). Nunca a use.

2) Para que você precisa trazer o campo da chave primária do item? Na maioria das vezes isso não é necessário. Você pode incluir todos os campos no select exceto a PK, já que ela ainda não está definida. E você não precisa exibi-la caso ela esteja null. Isso resolve o problema de uma maneira performática e elegante.

3) Metadados: Como o ClientDataset sabe que tal campo é chave primária se ele não é conectado diretamente ao banco de dados? Ele "sabe" isso porque provavelmente a propriedade GetMetadata do SQLDataset deve estar true. Colocando essa propriedade para false o ClientDataset não "saberá" que esse campo não pode se repetir, muito menos que ele é requerido. Além disso o ClientDataset abre muito mais rápido caso essa propriedade esteja false, pois não tem que fuçar nos metadados da tabela. Essa técnica é ideal para quando você precisa mostrar o número da PK logo depois da inserção e persistência. Como por exemplo mostrar um número de comanda num sistema de restaurante ou mostrar o número da "carteirinha" de um cliente recém inserido.
Desvantagem: se por algum motivo, como campo requerido, not null ou qualquer outro você precisa que os metadados sejam trazidos para que sejam tratados no client e não no server esta técnica não deve ser usada, recorra à 2.

Mencionei o problema ocorrendo em nested datasets mas ele pode ocorrer em ClientDatasets "normais" ligados a uma única tabela.

Uma mistura das soluções 2 e 3 quando aplicável é a melhor e mais performática solução. Quando nenhuma das duas pode ser usada, ou seja, você precisa dos metadados por algum motivo e ainda precisa exibir a chave primária criada logo depois do registro salvo, considere usar um outro tipo de arquitetura, ou usar chaves primárias definidas via programação em vez de generators.

Happy Coding \(^.^)/

O que você melhoraria no Delphi? - parte 2

2011-06-27T11:00:00.000-07:00

Na parte 1 desse post, há muito tempo, fiz uma pequena descrição do que eu acho que poderia ser melhorado no Delphi.

Resumindo:
1) Alguns componentes e bibliotecas mais comuns "nativos" em vez de "incorporados".
2) Literatura orientada mais a POO e a boas práticas da Engenharia de Software do que a RAD. A literatura disponível nos helps, exemplos, snippets e consequentemente nos blogs e fóruns é toda voltada a RAD, arrastar e soltar componentes. E como todos sabemos RAD é bom para protótipos e projetos pequenos, ou com requisitos fixos, com baixa frequencia de manutenção.
3) O aspecto que eu acho mais importante é (a falta de) um framework de persistência nativo da Embarcadero, para se fazer o mapeamento objeto relacional de maneira padronizada e ao mesmo tempo rápida.

Continuando, uma coisa que eu acho muito importante são as ações de marketing. No Brasil parece que o Delphi está queimado justamente com quem mais deveria acreditar nele: os professores.
Digo isso por experiência própria, pois meu projeto de conclusão de curso da pós graduação passou por esse problema.
Minha monografia era para ser "frameworks de mapeamento objeto relacional em Delphi". Meu orientador, professor de engenharia de software e outras matérias. Delpheiro de carteirinha e especialista em Delphi me perguntou "Por Que Delphi?". Ele questionou que meu trabalho, focado em Delphi, seria para um público muito restrito e que o Delphi está fadado a cair no desuso (nas palavras dele).
Não concordo com o ponto de vista dele sobre o Delphi, mas concordei que eu teria que expandir meus horizontes se quisesse fazer um trabalho academicamente mais amplo. Por isso meu tema foi trocado para "Processo de criação de frameworks de mapeamento objeto relacional em ambientes open-source".

O ponto em questão é que os professores, em vez de recomendar Delphi, estão "des-recomendando" (se é que esse termo existe). E agora como convencê-los do contrário?

Outro ponto é quanto ao preço do Delphi, mais caro que a concorrência. Quando saiu a edição "starter" do Delphi realmente o preço saiu bastante tentador. Mais barato que uma licença do windows 7 ultimate. Mas meu interesse na versão starter despencou quando eu soube que esta verão não possui dbexpress. Qual a utilidade do Delphi, para se fazer sistemas de informação, sem o dbExpress? Se conectar com MySql através de ADO+ODBC? BDE? Não, obrigado. Terei que comprar a suíte de componentes Unidac (que eu recomendo, muito boa).

Conversando com uns amigos no evento de lançamento da Embarcadero no Brasil chegamos a seguinte conclusão: por que não vender o Delphi "pelado", apenas IDE e compilador, por um preço simbólico e vender os componentes e add-ons sob demanda? Pense nisso:
Hoje em dia estão na moda as AppStores, onde você compra uma aplicação a um preço justo, e esta aplicação é sua, sendo sincronizada em seus dispositivos com o mesmo sistema operacional. Se você formata / reseta seu sistema, suas aplicações já pagas/compradas da appStore são baixadas e instaladas novamente. Tudo é re-sincronizado automaticamente. O mundo da Apple funciona assim, com o iPhone, iPad, iPod e com o iMac. O mundo do Google Android também funciona assim, e até a Intel entrou na brincadeira.
Qual é o maior problema quando um desenvolvedor Delphi tem que formatar sua máquina? Ele perde um dia inteiro, ou dias, reinstalando, além do Delphi, todos os componentes, open-source ou não, bibliotecas e adds que precisa para trabalhar produtivamente. Muitos tentam exportar chaves de registro, e copiar diretórios de bpl's e dcp's a fim de criar uma instalação do Delphi personalizada para poder instalar depois, ou fazem ghost da máquina. A situação se torna pior se a empresa tem vários programadores Delphi, com várias máquinas diferentes e várias licenças pra instalar. Pior ainda se lida com versões diferentes do Delphi.
Solução: por que não criar um instalador mínimo do Delphi e um appStore de componentes e bibliotecas? Assim, bastaria instalar o Delphi e logar-se com a sua conta na Embarcadero para re-instalar e sincronizar todos os componentes. E isso serviria quem sabe para você publicar um componente seu e ganhar com ele, porque não? Até mesmo para se fazer "Component Contests".
Isso poderia ajudar a garantir o controle de qualidade, testes etc de um componente, além da procedência, e garantir, principalmente para os não-open-source, uma sobrevida e um tempo de suporte maior, além de tornar a instalação do Delphi muito mais fácil e a busca, aquisição e instalação de componentes muito mais fácil.
Quando eu digo componentes me refiro à bibliotecas "normais" também, daquelas que você precisa instanciar uma classe, ou usar uma função, mas que não tem um componente em uma paleta pra colocar na form.
A maioria dos componentes precisam que arquivos sejam colocados em certos diretórios, e que certos caminhos sejam adicionados ao library path e browsing path do windows. Além disso os instaladores dos componentes são todos diferentes, quando há instalador, pois a maioria você deve compilar a partir dos dpk's.
Agora imagine um ambiente com um gerenciador de componente que encontra o componente que você precisa, faz as devidas inclusões dos paths, compila e instala se for open-source ou simplesmente instala se não for, e te livra de todos os passos chatos, demorados ou complicados.

Essas são algumas coisinhas que eu acho que poderiam ser melhoradas. E vocês, o que acham?

Grande verdade sobre developers

2011-06-22T12:32:00.000-07:00

Além de encarar qualquer problema de frente, assumimos a responsabilidade pelos bugs, sejam eles nossos, de "estimação", ou não.

Que saudade das férias

2011-05-26T15:47:00.000-07:00

Estava limpando a bagunça do meu PC e encontrei uma foto que me deu saudade das férias.

Tudo ok com vocês peixinhos? Oh wait, isso não foi um gesto obsceno, aaaaargh.

Easter Egg de Fringe no site da Bardahl

2011-05-23T14:28:00.000-07:00

Entre no site da Bardahl, clique em história da Bardahl ==> Museu Bardahl 3d em flash, quando carregar um "mural" com vários anos clique em próximo para ver o próximo "mural/parede" e clique em 1962.

Veja quem está observando ...

Biblioteca MadCollection

2011-05-23T14:12:00.000-07:00

Saiu na edição 129 da Revista Clube Delphi meu artigo sobre a madCollection.

Francamente não sei como não é distribuída juntamente com o Delphi, ou com qualquer outra linguagem / IDE, uma biblioteca tão útil. Explico: ela te permite fazer o que as vezes nem a API do windows permite. Neste artigo dei algumas pinceladas, mas a biblioteca é muito maior do que eu demonstrei.

Mencionando os artigos que estou lendo AGORA: o artigo dbExpress 4 do Fabrício Kawata e o Padrões Criacionais do Rafael Stavarengo chamaram muito minha atenção.

Boa leitura.

Para descontrair hoje

2011-04-13T12:39:00.000-07:00

Uma boa tarde a todos!

Sobre livros

2011-04-13T11:29:00.000-07:00

Eu gosto de ler. Não sou um rato de biblioteca, não tenho leitura dinâmica e não leio tão rápido ou com tanta frequência (sem trema desta vez), mas gosto de ler.
Gosto de comparar uma boa leitura com uma boa refeição. Já percebeu que às vezes um prato simples, em um restaurante pequeno de um bairro não muito movimentado pode te surpreender? Pode ser exatamente igual ao que sua mãe fazia, por exemplo.
O mesmo acontece com livros. Às vezes não damos muita atenção para um livro, e ele nos surpreende. Não apenas pela história envolvente, mas pelas "notas". Sim, notas. Para quem degusta vinhos, café ou perfumes está acostumado a ouvir essa palavra, "notas", fora de um contexto musical. Nos vinhos, pratos e perfumes notas são características, que não são plenamente fixas ou mensuráveis, mas são nebulosas. Não têm extremos, mas têm infinitas gradações.
Quantas gradações de sabor podem existir entre o amargo do café e o doce do chocolate? Entre um perfume e outro?
Essas "notas" podem ser encontradas em livros. E não apenas em romances ou ficções, mas em livros técnicos, enciclopédias, trabalhos científicos, quadrinhos, livros religiosos etc... Elas atingem sua mente, ressoam no seu intelecto, reverberam no seu íntimo, retinem em sua alma, misturam-se a todas as suas crenças, filosofias, conhecimentos tácitos e personalidade. Por fim são incorporadas e tornam parte do seu próprio acervo, de você. Essas notas também são chamadas de memes, mas memes hoje ganharam um significado marqueteiro interneteiro muito aquém do seu real significado.
Se comparados à refeições uma revista é como um lanche em um fast-food americano. Um livro técnico é como um prato-feito de buteco: quantidade grande, comida demasiadamente comum (ou até ordinária), muita gordura e carboidrato, em frente ao seu trabalho, te preparando para o trabalho, pronto para o trabalho. Sim, da mesma forma que você só come o "pf" no buteco em frente à empresa quando está trabalhando, livros técnicos só servem para trabalho. Eles SÃO trabalho. Mas, da mesma forma que o pf, nem tudo será comido, e nem tudo será digerido. Ou você vai me dizer que devora com prazer os livros técnicos de capa a capa, mesmo as partes que você já está "saciado", mesmo sem fome desse conhecimento, e ainda assim fica mais "saudável"? Dirá que a cada livro técnico devorado seu salário aumenta 1%, 0,1%?
Livros técnicos são importantes, como o arroz, feijão, bife e salada. Mas não deveriam ser os únicos livros da sua vida.
Recentemente eu li um livro desses, baratinho, de bolso, comprado em banca de jornal, que não valorizei muito quando vi, mas que ele se mostrou uma macarronada de domingo, com direito a frango à passarinho.

O diário do chaves vai além do que é mostrado nos episódios do seriado e, sem perder o tom de comédia, mostra um lado mais dramático, triste e até lúgubre da história.
Não vou falar mais nada, porque irá estragar sua refeição. Apenas recomendo: experimente.

Atualização:

Meio esfomeado estou hoje não? É que minha inspiração para o texto acima foi esse livro-mangá aqui:
Sentimentos se misturam num belo prato, marcados por um ritmo, um passo, intenso como a correria da vida, onde apenas nos momentos de saciar o vazio em seu estômago é que o personagem se apercebe do seu vazio existencial.
Eu gostei.

Uma grande verdade sobre tecnologia

2011-04-07T07:12:00.001-07:00

Vai dizer que não é verdade.

Clube Delphi 128

2011-04-06T08:36:00.000-07:00

Saiu a Clube Delphi 128, e dessa vez o meu artigo é capa! Agradeço ao Guinther Pauli, editor da revista, pela paciência que tem com meus atrasos :p

Meu artigo sobre interoperabilidade explica como integrar sistemas Delphi Win32, .Net e talvez outros através de DLLs, COM, WebServices e troca de mensagens pela API do windows.

Mostro nesse artigo como consumir uma DLL feita em Delphi através do .Net, como consumir pelo Delphi uma DLL .Net através da integração COM, como consumir pelo Delphi um webservice feito em .Net e como fazer as aplicações se comunicarem via API do windows.

Lógico, sobre interoperabilidade fiquei devendo, por questões de tempo e espaço, algumas coisinhas que pretendo mencionar em artigos futuros, na revista e/ou neste blog:

.Net consumindo webservice em Delphi
Introdução do Lazarus na brincadeira
Integração por sockets
Integração por xml, json e txt

Por enquanto não vejo a hora de ler os artigos sobre programação Android com freepascal e o artigo sobreXML Data Binding.

Espero que todos tenham uma boa leitura ;)

Verdades sobre programação

2011-04-06T07:29:00.000-07:00

Esse blog, do @luisdalmolin, contém um excelente texto sobre verdades não tão conhecidas sobre programação. Não tão conhecidas talvez pelos nossos chefes / stakeholders, mas muito bem conhecidas por nós. O post foi traduzido desse aqui em inglês.

Basicamente, o texto fala sobre o que já sabemos:
1) Dez programadores não farão o programa em um décimo do tempo assim como nove mulheres não fazem um bebê em um mês. (apenas uma grande suruba lésbica).
2) Bons programadores passam muito mais tempo lendo, estudando, pensando, refatorando do que escrevendo, codificando e debugando. É fato! Scrum e XP pregam isso. O resto é XGH (eXtreme Go Horse).
3) Programadores (e hoje analistas de sistemas também) são tratados como peões, na rabeira do organograma da empresa, muitas vezes mesmo se destacando em sua área, possuindo graduação, pós graduação e certificações, o que significa que um programador é tratado como um operário mesmo tendo estudado tanto quanto (em alguns casos muito mais) um médico ou advogado, e continuar estudando ao longo de TODA sua carreira.
4) Planejamento é fundamental antes, durante e depois.
5) Mesmo os requisitos sendo flexíveis, isso não significa "festa do caqui" com os requisitos. E os prazos e escopo deveriam ser flexíveis proporcionalmente à flexibilidade dos requisitos.
6) Mudanças de requisitos geram entropia, ok, mas mudanças sem planejamento, sem levantamento de requisitos, direto no código, por meio de tentativa e erro até funcionar geram mais entropia ainda, tendendo ao caos, e inevitavelmente vão falhar. FALHARÃO MISERAVELMENTE.

Alguns quadrinhos humorísticos tirados do site Vida de Programador ilustram isso:

Essa outra ilustra bem a situação.

Não podemos esquecer do vídeo hug a developer! Ele ilustra de maneira bem humorada os problemas, desafios e DORES pelas quais um programador passa nas mãos e chefes porcos, cães sarnentos ignorantes ...

Enquanto isso, em algum lugar da internet

2011-04-05T07:09:00.000-07:00

Para descontrair...

E para quem trabalha com suporte:

IPS VIZINHOS

QA:
Oi, usuário tá conectando com o IP 189.21.22.23 e não tá funcionando
DBA:
Mas o IP aqui no banco de dados é o 189.22.23.25... Tem algo errado aí
QA:
Ah, não são iguais, mas são bem próximos né?

fonte: http://fuckyeahdementia.com/ e http://fuckyeahitbullshit.tumblr.com/

A API GetuserNameEx

2011-04-04T12:21:00.000-07:00

Primeiro de tudo, a função GetUserNameEx se encontra na dll Secur32.dll e, como outras funções da API do windows, possui duas versões, uma ANSI (GetUserNameExA) e uma WIDE (GetUserNameExW).

Abaixo segue o cabeçalho para importação dessas duas funções.

function GetUserNameExA(NameFormat: TEXTENDED_NAME_FORMAT; lpBuffer: PAnsiChar; var nSize: DWORD): BOOL; stdcall external 'Secur32.dll' name 'GetUserNameExA';
function GetUserNameExW(NameFormat: TEXTENDED_NAME_FORMAT; lpBuffer: PWideChar; var nSize: DWORD): BOOL; stdcall external 'Secur32.dll' name 'GetUserNameExW';

Atenção especial para o parâmetro NameFormat do tipo TEXTENDED_NAME_FORMAT. Ele é na verdade um Enum com alguns valores fixos. (no C também é um enum, e usa-se um ponteiro para ele)

  TEXTENDED_NAME_FORMAT  =
  (
    NameUnknown            = 0,
    NameFullyQualifiedDN   = 1,
    NameSamCompatible      = 2,
    NameDisplay            = 3,
    NameUniqueId           = 6,
    NameCanonical          = 7,
    NameUserPrincipal      = 8,
    NameCanonicalEx        = 9,
    NameServicePrincipal   = 10,
    NameDnsDomain          = 12
  );

Criei essas duas funções que me retornam uma string (UnicodeString no Delphi 2010) ou AnsiString para testar e facilitar o uso da GetUserNameEx (A ou W).

function TForm1.VtrGetUserNameExW(NameFormat: TEXTENDED_NAME_FORMAT): string;
var
  I: DWord;
begin
  I := 1000;
  SetLength(Result, I);
  GetUserNameExW(NameFormat, PChar(Result), I);
  Result := string(PChar(Result));
end;

function TForm1.VtrGetUserNameExA(NameFormat: TEXTENDED_NAME_FORMAT): AnsiString;
var
  I: DWord;
begin
  I := 1000;
  SetLength(Result, I);
  GetUserNameExA(NameFormat, PAnsiChar(Result), I);
  Result := AnsiString(PAnsiChar(Result));
end;

Estou alocando um espaço de 1000 caracteres para o resultado. É arbitrário. Quem souber uma maneira melhor de fazer isso, talvez usando outra api para saber o tamanho do nome do usuário de antemão, por favor me avise.

para testar chamo todas as funções, GetUserNameEx (A e W) passando todos os parâmetros possíveis de NameUnknown (0) a NameDnsDomain (12) e vejo o resultado.

procedure TForm1.Button2Click(Sender: TObject);
var
  enf: TEXTENDED_NAME_FORMAT;
begin
    Memo1.Lines.Add('Versão Wide -----------------------------------');
    enf := NameUnknown;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameFullyQualifiedDN;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameSamCompatible;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameDisplay;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameUniqueId;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameCanonical;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameUserPrincipal;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameCanonicalEx;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameServicePrincipal;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));

    enf := NameDnsDomain;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExW(enf));


    Memo1.Lines.Add('Versão Ansi -----------------------------------');
    enf := NameUnknown;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameFullyQualifiedDN;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameSamCompatible;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameDisplay;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameUniqueId;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameCanonical;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameUserPrincipal;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameCanonicalEx;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameServicePrincipal;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

    enf := NameDnsDomain;
    Memo1.Lines.Add(inttostr(integer(enf)) +' ' + VtrGetUserNameExA(enf));

end;

Api hooking para mudar o usuário logado

2011-04-04T10:13:00.000-07:00

Já está nas bancas a revista Clube Delphi 127 com meu primeiro artigo sobre a madShi Collection. Neste artigo eu explico o básico sobre API Hooking.

Neste post falarei sobre um exemplo que não se encontra no artigo, que é o hooking da API GetUserName.
Os motivos que levam a hookar essa API podem ser variados, e todos eles nada éticos a meu ver. Você pode desde tentar enganar um produto registrado para um usuário acessando-o como outro usuário ou simplesmente para tapear um usuário administrador, que quando olhar quem está logado verá um nome diferente (supondo que isso funcione, não testei).

A idéia é que dá para mudar a resposta que outros programas recebem quando perguntam quem é o usuário logado. Para isso é necessário conhecer quais são as api's que fazem isso e como interceptá-las.

O código dessa postagem mostra como usar a madCodeHook para interceptar a api GetUserName da api do windows.

Primeiro de tudo criei um programa que mostra o nome do usuário corrente:

function NomeUsuario: string;
var
  I: DWord;
begin
  I := 255;
  SetLength(Result, I);
  Windows.GetUserName(PChar(Result), I);
  Result := string(PChar(Result));
end;



procedure TForm2.btTestarClick(Sender: TObject);

begin
  Edit1.Text := NomeUsuario;
end;

Esse programa simplesmente mostra o usuário logado. Depois de injetada a DLL que faz o hook a chamada a GetUserName terá seu resultado mudado.
É preciso salientar que existe outra api chamada GetUserNameEx que não está mapeada na unit windows.pas e que aceita mais parâmetros, e devolve mais resultados.

Interceptar essas duas API's é certeza de que mudará os resultados às suas relativas chamadas. Não é garantia nenhuma de que será possível abrir um arquivo para o qual seu usuário atual não tem autorização, mas não custa nada tentar.

Como pôde ser visto nos artigos que escrevi para a Revista Clube Delphi, eis o código da dll a ser injetada.

Essa dll intercepta apenas a função GetUserName, deixo a cargo do leitor a GetUserNamneEx, que é mais complexa. Num post futuro trataremos da GetUserNameEx. Deixo apenas o esqueleto para quem quiser se aventurar.

Lembre-se de que se estiver usando a versão trial/demo da madCollectionHook deverá manter mchEvaluation rodando para que o hooking funcione.

library hook;

uses
  SysUtils,
  windows,
  Classes,
  madcodehook;

{$R *.res}


const
  USUORIGINAL =  'vitorrubio';    //       vitorrubio --> meu user
  USUTROCA = 'Administrador';       //       Administrador--> quem quero ser




var
  GetUserNameWNext:  function (lpBuffer: PWideChar; var nSize: DWORD): BOOL; stdcall;
  GetUserNameANext:  function (lpBuffer: PAnsiChar; var nSize: DWORD): BOOL; stdcall;


function GetUserNameWCallback (lpBuffer: PWideChar; var nSize: DWORD): BOOL; stdcall;
begin

  Result := GetUserNameWNext(lpBuffer, nSize);
  if (trim(string(lpBuffer)) = USUORIGINAL) then
  begin
    StrCopy(lpBuffer, USUTROCA);
    nSize := Length(USUTROCA);
  end;

end;

function GetUserNameACallback (lpBuffer: PAnsiChar; var nSize: DWORD): BOOL; stdcall;
begin

  Result := GetUserNameANext(lpBuffer, nSize);
  if (trim(AnsiString(lpBuffer)) = AnsiString(USUORIGINAL)) then
  begin
    StrCopy(lpBuffer, USUTROCA);
    nSize := Length(USUTROCA);
  end;

end;

begin
  HookAPI('advapi32.dll', 'GetUserNameW',  @GetUserNameWCallback, @GetUserNameWNext);
  HookAPI('advapi32.dll', 'GetUserNameA',  @GetUserNameACallback, @GetUserNameANext);
end.

Agora o código para injetar, desinjetar e testar a dll:

procedure TForm1.btInjetarClick(Sender: TObject);
begin
  InjectLibrary(ALL_SESSIONS or SYSTEM_PROCESSES, 'hook.dll');
end;

procedure TForm1.btTestarClick(Sender: TObject);
begin
  Edit1.Text := NomeUsuario;
end;

procedure TForm1.btDesinjetarClick(Sender: TObject);
begin
  UninjectLibrary(ALL_SESSIONS or SYSTEM_PROCESSES, 'hook.dll');
end;

Crie uma form com 3 botões e um edit e teste. Lembre-se de todas as medidas de segurança necessárias para se trabalhar com API hooking e lembre-se que toda a api do windows se invoca com stdcall.

Coloque a dll e o testador em um mesmo project group para facilitar.

É importante salientar que qualquer processo que use a GetUserNameEx para identificar o usuário não sofrerá nenhum efeito desse hooking. Além disso o windows tem outras formas, de baixo nível, para descobrir o usuário logado.

Have fun :)

Primeiro de Abril dos programadores

2011-04-01T12:10:00.000-07:00

Quem é do ramo de TI sabe o que são as normas RFC. São conjuntos de convenções onde são estabelecidos padrões para que computadores possam se comunicar e trocar dados entre si, e para que esses dados sejam reconhecidos por todos. Se não fossem essas normas o mundo da TI seria um caos (e já não é).

É insteressante o fato de que a norma RFC 2550 foi criada em 1° de abril de 1999, e tratava do bug y2k, o bug do milênio. Desde que a convenção de dadas expressa em 2 dígitos para o ano foi criada sabia-se que em 2000 isso ~~ia dar merda~~ parar de funcionar, mas mesmo assim a solução foi deixada para 1999, a véspera.

Lendo a norma, é possível encontrar o seguinte texto, bem - humorado apesar da seriedade e sobriedade das normas RFC:

" Nearly everyone now regrets the
   short-sightedness of the programmers of yore who wrote programs
   designed to fail in the year 2000.  Unfortunately, the current fixes
   for Y2K lead inevitably to a crisis in the year 10,000 when the
   programs are again designed to fail."

Numa tradução livre:

"Quase todo mundo lamenta a falta de visão dos programadores de antigamente, que criaram os programas já designados para falhar em 2000. Infelizmente, as correções correntes para o Y2K conduzirão inevitavelmente a uma crise no ano 10.000, quando os programas falharão novamente"

Sei lá, eu nunca esperaria encontrar esse tipo de ironia sutil numa norma RFC mas é a mais pura realidade: prepare-se porque todos os programas falharão no ano 10.000, o que fizemos foi uma gambiarra que tem 8000 anos de duração.

Há também na norma um padrão de nomenclatura para o bug do ano 10.000, chamado de YXK, em algarismos romanos (X) ou YAK, em hexadecimal (A = 10).

Seja pró-ativo, não espere o pior acontecer, antecipe-se, corrija agora mesmo o bug do ano 10.000 no seu software :)

Isso poderá gerar royalties e patentes para os seus tatatatatatatatatatatatatatatata (são 14 ou mais tatas?) ranetos.

O analista de sistemas

2011-03-28T10:35:00.000-07:00

Um homem anda por uma estrada próxima a uma cidade, quando percebe, a pouca distância, um balão voando baixo. O balonista lhe acena desesperadamente, consegue fazer o balão baixar o máximo possível e lhe grita:

- Ei você, poderia ajudar-me? Prometi a um amigo que me encontraria com ele às duas da tarde, porém já são duas e meia e nem sei onde estou. Poderia me dizer onde me encontro?

O outro homem, com muita cortesia, respondeu:

- Mas claro que posso ajudá-lo! Você se encontra em um balão de ar quente, flutuando a uns vinte metros acima da estrada. Está a quarenta graus de latitude norte e a cinqüenta e oito graus de longitude oeste.

O balonista escuta com atenção e depois pergunta-lhe com um sorriso:

- Amigo, você trabalha como analista de sistemas?

- Sim, senhor, ao seu dispor! Como conseguiu adivinhar?

- Porque tudo o que você me disse está perfeito e tecnicamente correto, porém esta informação me é Totalmente inútil, pois continuo perdido.

Será que você não tem uma resposta mais satisfatória?

O analista fica calado por alguns segundos e finalmente pergunta ao balonista:

- E você, não seria por acaso um Gerente?

- Sim, por um acaso sou um gerente. Porque?

- Ah, foi muito fácil! Veja só: Você não sabe onde está e nem para onde vai. Fez uma promessa da qual não tem a mínima idéia de como irá cumprir e ainda por cima espera que outra pessoa resolva o seu problema. Continua exatamente tão perdido quanto antes de me perguntar. Porém, agora, por um estranho motivo, a culpa passou a ser minha...

Laço for in no lazarus

2011-03-25T11:43:00.000-07:00

Já faz um tempinho que saiu esse feature, mas eu nem fazia idéia. Talvez mais pessoas não saibam.

Agora já é possível usar o laço for... in no free pascal. Outras alterações previstas para a versão 2.5.x e muito bem vindas é a adição de generics e a nova sintaxe para classes, permitindo class vars e class properties.

Segue abaixo um exemplo do operador for...in usando TStringList e Arrays Dinâmicos.

procedure TForm1.Button1Click(Sender: TObject);
var
   lista: TStringList;
   vetor: array of string;
   s: string;
begin
     lista := TStringList.Create;
     lista.Add('Delphi');
     lista.Add('Lazarus');
     lista.Add('C#');
     lista.Add('Java');
     lista.Add('PHP');

     for s in lista do
         Memo1.Lines.Add(s); //ou showmessage(s)

     SetLength(vetor, 5);
     vetor[0] := 'Laranja';
     vetor[1] := 'Maçã';
     vetor[2] := 'Pera';
     vetor[3] := 'Uva';
     vetor[4] := 'Cajá';

     for s in vetor do
         Memo1.Lines.Add(s); //ou showmessage(s)


end;

Have fun ;)

Leitura obrigatória sobre strings

2011-03-23T09:12:00.000-07:00

A maior facilidade das strings do Delphi em relação ao C e C++ é que elas não são baseadas em operações de "baixo nível" com ponteiros. Elas são facilmente quebradas, concatenadas ou copiadas. No caso das cópias, elas podem ser copiadas com performance pois mantém um contador de referências.

Em comparação com as linguagens interpretadas, gerenciadas e com "coletores de lixo" as strings nessas linguagens não são tão performáticas. Cópias de strings não são cópias de referências, mas da string completa mesmo, sem reference counting. Tratando - se de concatenação de strings então, o .Net Framework, até a versão 2.0, que eu saiba, encorajava o uso de StringBuilder em vez de strings dentro de um loop para montar um relatório ou tabela na web, por exemplo. Isso porque ao se concatenar duas strings o .Net Framework cria uma nova string com o conteúdo das duas, destruindo as outras duas, gerando um overhead.

Imagine quantas operações dentro de um loop não acontecem quando você faz um:

tabela += "<tr><td>" + col1 + "</td> <td>"+ col2+ "</td></tr>";

Só nesse trecho, bobinho e trivial, mas apenas um exemplo, foram concatenados 5 strings. Isso quer dizer que 5 "resultados" foram criados até chegar ao final, e que, duas a duas, de 5 a 10 strings foram marcadas para ser destruídas, pelo menos as constantes, excetuando-se as variáveis col1 e col2.

O simples fato de trocar o conteúdo de uma string gera a destruição da string atual e a criação de outra no .Net. O programador final não percebe isso porque a sintaxe é bastante "amigável" e para strings e loops pequenos realmente parece que o .Net é performático. Isso não acontece no Delphi.

Algumas leituras obrigatórias sobre strings:

Marco Cantu compara as strings do Delphi com outras linguagens, tanto no que tange à sintaxe como à performance. --> http://blog.marcocantu.com/blog/delphi_super_duper_strings.html

Meu artigo sobre strings --> http://blog.vitorrubio.com.br/2010/08/strings-e-delphi-2010-na-clube-delphi.html

Paper na Embarcadero sobre Unicode --> http://www.embarcadero.com/images/dm/technical-papers/delphi-unicode-migration.pdf

Artigo DrBob sobre strings --> http://www.drbob42.com/examines/examinA7.htm

Artigo na Embarcadero --> http://edn.embarcadero.com/article/38437

O que eu mais gosto é este: breve história sobre as strings no Delphi --> http://www.codexterity.com/delphistrings.htm

Have Fun ;)

A linguagem de programação do futuro

2011-03-17T09:35:00.000-07:00

         O empenho em analisar a execução dos pontos do programa desafia a capacidade de equalização das condições inegavelmente apropriadas. Podemos já vislumbrar o modo pelo qual a constante divulgação das informações oferece uma interessante oportunidade para verificação das formas de ação. Assim mesmo, o acompanhamento das preferências de consumo cumpre um papel essencial na formulação do fluxo de informações. O que temos que ter sempre em mente é que o comprometimento entre as equipes promove a alavancagem das diversas correntes de pensamento. Pensando mais a longo prazo, a determinação clara de objetivos faz parte de um processo de gerenciamento das novas proposições.

          Por conseguinte, a expansão dos mercados mundiais obstaculiza a apreciação da importância das condições financeiras e administrativas exigidas. Nunca é demais lembrar o peso e o significado destes problemas, uma vez que a crescente influência da mídia maximiza as possibilidades por conta dos conhecimentos estratégicos para atingir a excelência. Gostaria de enfatizar que a hegemonia do ambiente político representa uma abertura para a melhoria do investimento em reciclagem técnica. Não obstante, o consenso sobre a necessidade de qualificação afeta positivamente a correta previsão das direções preferenciais no sentido do progresso.

          A prática cotidiana prova que a percepção das dificuldades aponta para a melhoria dos relacionamentos verticais entre as hierarquias.

Fonte: http://padrelevedo.hpg.ig.com.br/lerolero/lerolero.html

sim, é um post troll ...

Nunca confie no TIOBE

2011-03-17T09:22:00.000-07:00

Em vários posts meus eu mencionei o índice TIOBE para relacionar a popularidade das linguagens. Mas eu não sabia como o índice TIOBE funcionava, achei que ele era sério, baseado em projetos, mas ele é mais furado que o IBOPE, muito mais.

O TIOBE classifica popularidade como número de resultados nos buscadores. Ele parte de vários pressupostos errados.

1) Assume que popularidade é o número de resultados de buscas de uma linguagem em um mecanismo de busca.
2) Assume que todos os buscadores tem o mesmo peso, embora os resultados sejam muito diferentes e o algoritmo também.
3) Não elimina ruidos. Se você pesquisar por java programming encontrará resultados relacionados com uma programação qualquer na ilha de Java, por exemplo.

Além do ruido ser problema, a pesquisa é sempre feita com os termos <linguagem> programming, mas termos diferentes relacionados a uma mesma linguagem podem trazer resultados várias ordens de grandeza maiores ou menores do que <linguagem> programming. Além disso certas linguagens como javascript ou perl as pessoas costumam definir seu trabalho como scripting em vez de programming.

Por favor leia esses artigos: (o derivado e a fonte) http://akitaonrails.com/2008/04/13/off-topic-nunca-confie-no-tiobe

Parei de acreditar que o Java está sempre no topo. Embora muito utilizado e muito bom acredito que tenha outras linguagens que quase empatam com ele, em uma ordem totalmente diferente da TIOBE.

Comecei a ver as estatísticas de linguagens dos projetos do GIT hub. Se o kernel do linux está lá e muitos projetos GPL estão lá também isso torna as medidas um tanto quanto confiáveis. Os resultados são bem diferentes do TIOBE. Mesmo assim ainda posso dizer que não são completamente confiaveis porque essa estatística é baseada em uma amostra viciada: a maioria dos amantes de Ruby também é fã de Git e os amantes do Git, em sua maioria, programam em Ruby, então existem muitos projetos em Ruby no Git Hub, mas existem muitos projetos em outras linguagens que não estão no Git Hub. Com o tempo e o crescimento da popularidade do Git Hub é possível que o índice fique mais apurado. Outro modo de se chegar a esse resultado seria considerar o número de projetos em cada linguagem do sourceforge e do google code também.

Mas como eu sempre digo, REPITO:
1 - a popularidade de uma linguagem nada tem a ver com sua utilidade
2 - a popularidade de uma linguagem não tem nada a ver com a empregabilidade de seu programador
3 - Mesmo Java, Ruby, Delphi ou C# sendo populares ou "modinhas" isso não vai te impedir de estudá-los ou estudar PROLOG caso a necessidade apareça

Uma coisa é certa, um amigo meu me indicou Ruby e eu estou bastante curioso para ver como ele funciona. Por outro lado a vontade de programar para Android está me guiando ao Java. Conclusão: JRuby :)

Qualquer que seja a linguagem, não vou mais conficar no índice da TIOBE

GEBRASA nunca mais - sobre e-commerce

2011-03-15T08:28:00.000-07:00

Trabalho com e-commerce, mas não farei aqui um post sobre desenvolvimento de e-commerce e sim sobre gerência de e-commerce.

Qual é a principal preocupação do cliente, e a principal dúvida ao comprar em uma loja "online"? A dúvida é sempre a mesma: "será que a empresa vai entregar?"

O pagamento se dá de maneira muito fácil, via cartão de crédito. Mas caso haja algum problema o cliente sabe que o estorno é um inferno. Se o pagamento é intermediado por uma dessas MOIP ou PagSeguro da vida é pior, pois existe mais uma camada intermediária para atravancar o estorno, que pode demorar até 45 dias e fazer com que a empresa simplesmente tome posse de dinheiro seu emprestado, sem juros.

Algumas empresas se confundem ou se enganam na hora de entregar um produto, o que é até aceitável, e entregam o produto errado. Depois demoram muito para devolver o dinheiro ou trocar o produto (Submarino, por exemplo). Mas talvez a demora seja causada pela massa: um volume muito grande de clientes, pedidos, produtos.

Outras empresas fazem a chamada venda de cauda longa: elas vendem um produto mesmo não tendo no estoque, mas É CERTEZA que o produto existe no estoque dos fornecedores, e não está esgotado. Com isso a empresa pode solicitar o produto do fornecedor sob demanda e mandar despachar para o cliente. É como "just in time".

Um e-commerce nunca, NUNCA deveria fazer venda de cauda longa de algo que depende de fabricante e não de distribuidor, ou seja, de um produto que deva ser FABRICADO. Tampouco deveria fazer venda de cauda longa de um produto sazonal .

Bom, essa bronca é para a GEBRASA, empresa na qual eu NUNCA MAIS COMPRAREI e DESACONSELHO FORTEMENTE.

Comprei um simples hack, um quadrado de madeira (ou coisa que o valha) para colocar meu pc, monitor e impressora, paguei, e não vi a cor até hoje, dois meses depois. Coisa que se eu tivesse comprado numa loja qualquer estaria levando pra casa no mesmo dia.

Se a empresa me mandasse periodicamente um e-mail me posicionando sobre o status do meu pedido, ou ligasse ou mandasse um e-mail se desculpando e mandando um prazo ou oferecendo a devolução do meu dinheiro eu não ficaria nervoso, pois sei que essas coisas acontecem. Mas a GEBRASA, além de não dar prazo e dizer que não tem previsão de entrega foi estupidamente mal educada no atendimento por e-mail, dizendo simplesmente: "você não leu no site? lá está escrito que há um prazo de 10 dias para verificar a disponibilidade do produto no estoque.". É verdade, mas não se passaram 10 dias, se passaram 58, para ser mais exato.

Como o pagamento foi feito via MOIP, teria que aguardar a MOIP entrar em "disputa" com eles. Não tenho paciência para isso, ficar ouvindo musiquinha em ura...

Perdoem-me meus leitores, eu nunca pronuncio palavras vulgares, de baixo calão e profanidades no meu blog técnico, mas .... pra puta que o pariu com essa merda.

Depois de 4 trocas de e-mails com muita desconsideração e descaso com o cliente entrei no reclame aqui, procon e entrei em contato com a VISA para estorno do meu pagamento, tudo de uma vez. Para a VISA ainda tive que mandar um FAX (o que é isso meu Deus? Falando a verdade, nunca tinha usado um desses antes....) enorme cheio de firulas e burocracias.

Espero sinceramente que a GEBRASA feche as portas da maneira mais humilhante possível. No mais, desculpem-me pelo desabafo, prometo que o próximo post será tech, com certeza.

madShi collection

2011-03-14T12:55:00.000-07:00

Saiu na revista Clube Delphi 127 meu artigo sobre a madShi Collection, uma coleção de bibliotecas muito úteis e interessante. Elas vão além do basicão fornecendo aos programadores funcionalidades bastante inusitadas, como api hooking, e funcionalidades que são uma mão na roda na hora de distribuir seu software ou na hora de encontrar bugs persistentes. O madExcept é um gerenciador de exceções que automaticamente gera um log com nome da unit e até a linha do código que disparou o erro. Seu usuário pode simplesmente clicar em um botão para te enviar o relatório de erros.

Espero que gostem do artigo. Boa leitura :)

Dicas de Inglês

2011-03-09T13:55:00.001-08:00

O inglês é essencial para programadores. Ponto. Não importa o pais em que você esteja, o inglês é o esperanto que deu certo, pelo menos nessa nossa era.

O site Tecla Sap tem muitas dicas interessantes para quem já cursa inglês mas quer sanar dúvidas, pegar dicas ou aprimorar seus conhecimentos.

Peguei essa dica hoje no site: Palavras com "L" mudo. Acontece também com outras letras, por isso muita atenção à pronúncia. Ensaie a pronúncia em diálogos reais.

ALMS /aams/
Esmola
BALM /baam/
Bálsamo
CALM /kaam/
Calmo
COULD /kud/
Passado do verbo auxiliar “CAN” (poder)
HALF /héf/
Metade
PALM /paam/
Palma; palmeira; palm
PSALM /saam/
Salmo
SALMON /SÉ m@n/
Salmão
SHOULD /shud/
Deveria (verbo auxiliar)
SOLDER /SÓ d@r/
Solda
TALK /tók/
Conversar
WALK /wók/
Andar
WOULD /wud/
Verbo auxiliar usado no condicional
I’ll have the salmon, please.
Vou querer o salmão, por favor.
Aluminum is also very difficult to solder. (Chicago Tribune)
É muito difícil soldar alumínio também.

Qual o problema dos Anglicismos?

2011-03-01T09:20:00.000-08:00

Muitas pessoas respeitáveis, lingüistas, professores, mestres, doutores em geral criticam o uso de anglicismos no dia-a-dia, quer como gírias quer como jargões de profissões emergentes.

Na área de Ciência da Computação, Ciência da Informação e outras áreas correlatas há a tendência de mestres e doutores renomados ter uma aversão a novos anglicismos(relacionados a novas tecnologias) propondo seus correspondentes em português.

Mas pense: se para designar nomes de seres vivos na Biologia (taxonomia) usa-se o latim, usando-se também na designação de vários termos jurídicos, mundialmente. Além disso usa-se palavras latinas ou gregas para vários termos técnicos da Química, Física, Matemática e Linguística porque não usar o Inglês para as Ciências da Computação e da Informação?

Matemática, Biologia, Química, Física e Direito são ciências que começaram a ser estudadas desde os primórdios da humanidade, atravessando a época em que o Grego e o Latim foram as línguas mundialmente predominantes e continuam sendo usadas após a "morte" dessas línguas. Optou-se, por padrões e convenções internacionais, usar por exemplo o Latim no Direito e na Biologia. Porque não usar o Inglês para as Ciências da Computação e da Informação? Tenho alguns motivos pra isso:

1) São ciências novas, que começaram a ser estudadas e desenvolvidas desde a década de 1950 para cá.
2) A maioria (mas não todas) das contribuições para essas ciências veio indiscutivelmente de países de língua inglesa.
3) Torno a dizer que o inglês é a língua predominante e mundialmente conhecida hoje, por isso nada mais justo do que ser usada para cunhar os nomes de novos termos e jargões de ciências também contemporâneas.
4) Lembre-se que um anglicismo para designar uma nova tecnologia também é um neologismo em seu país de origem, pois é um novo uso para uma palavra antiga, ou uma junção de palavras.

Concordo plenamente que palavras existentes no nosso português não devem ser substituidas por seus equivalentes em inglês. É o caso de performance em detrimento de desempenho ou acurácia em detrimento de exatidão. Mas dependendo da palavra isso se faz necessário, um exemplo:

Em inglês dá-se o nome de "framework" para um conjunto sólido e grande bibliotecas, exemplos, padrões e partes ou componentes de software pré montado para a elaboração rápida de outros softwares. Alguns tradutores traduzem framework como biblioteca, moldura, estrutura etc ... quando na verdade a palavra que mais se aproxima do significado de framework é "arcabouço", palavra pouco usada até mesmo por engenheiros civis.

Mas é simplesmente uma arrogância ou prepotência, um orgulho besta, países de língua portuguesa e doutores em diversas ciências querer designar sites por sítios (eu não planto abobrinhas nem crio vacas em meu site), mouse por rato e por aí vamos. Por acaso você usa viamole ou meiomole para software e meioduro ou "ferragens" para hardware? Dificilmente.

Outro motivo pelo qual eu não sou avesso a anglicismos é o seguinte: a língua é viva. Ela muda com o tempo, espontaneamente ou por absorção / cruzamento com outras línguas. Se não impedimos que certos animais ou vegetais absorvam características genéticas de outros ao se fazer cruzamentos e enxertos, muito pelo contrário, tentamos e encorajamos propositalmente isso, porque seria diferente com a língua? Nossa língua já poderia sofrer uma mutação só pelo isolamento geográfico de Portugal (é uma boa distância e um bom trecho de oceano no meio). Que dizer então das influências (cruzamentos) com as línguas indígenas, africanas, o francês, o holandês, o italiano que vaio depois etc ... Nossa língua é um ser vivo, vira - lata que seja, só nosso.

Tolkien era linguista e filólogo. Em seu trabalho ele criou todo um mundo, uma nação e uma língua. Na sua obra literária ele demonstra como o isolamento e os choques de cultura podem criar novas línguas, e usou suas histórias para embasar suas pesquisas. Nas suas histórias, desde O Silmarillion até o Senhor dos Anéis, essa nação e língua se divide em várias partes. Os Elfos primeiramente fogem da Terra Média para Valinor, no continente sagrado de Arda. Mas alguns Elfos permanecem na Terra Média. O isolamento geográfico dos dois grupos, por milênios, criou na Terra Média uma segunda língua, um dialeto. Os elfos então tinha duas línguas, o Quenya e o Sindarin. Parte do povo de Valinor, após séculos, voltou para a Terra Média. Lá encontraram duas novas raças, os Anões e os Homens. As duas Línguas sofreram mais fusões e divisões. Os meio-elfos foram para Númenor, ilha criada posteriormente pelos Deuses entre Valinor e a Terra Média. Mais tarde as línguas dos homens também sofreram mutações e divisões, uma vez que o homem mortal, por ter vida muito mais curta do que os elfos, era mais suscetível ao isolamento geográfico e social.

Não é exatamente isso que aconteceu na história de todas as línguas ao redor do mundo? Será que não tem influências da língua portuguesa em outras línguas, por exemplo o Japonês?

Esta é uma citação de Tolkien que eu considero interessante e verdadeira:

O Volapuque, Esperanto, o Ido, o Novial, são línguas mortas, mais mortas do que antigas línguas sem uso, porque seus inventores jamais criaram lendas para acompanhá-las.

Uma língua precisa ser embasada em uma história e cultura. Se uma língua for artificial ela deve ser embasada em histórias e culturas artificiais, senão ela já nasce morta. Parte desta "vida" ou desta "cultura" da língua se deve a fusões com outras línguas e as confusões e desentendimentos que isso pode causar.

Gostaria até de citar esse twit do dublador Nelson Machado, de quem sou fã e admiro muito o trabalho: (a própria palavra fã é um anglicismo)

Nós tínhamos o formal e responsável TRABALHO. Criamos o informal e libertário TRAMPO. Agora vivemos com o submisso JOB!!! Êêê, povinho!

Lógico que não conheço o contexto desse tweet, muito menos o que gerou a crítica. Mas é apenas um exemplo.

Ora, porquê submissão? O "job" é o trabalho do freelance. Se o nome de sua profissão é um anglicismo e a culpa nem é sua, porque o nome de parte do seu trabalho deveria ser diferente? Job pode ser também uma etapa de uma sequência de etapas de um programa que rode vários comandos em lote.

Terei que discordar (não confunda com descordar) um pouco do Machado. Não sei se o caso é submissão, mas analise os seguintes fatos:

1) Encare o Inglês como o esperanto que deu certo e você vai entender as próximas enumerações:
2) Job é mais curto, podendo ser melhor inserido em uma mensagem de 140 caracteres, seja ela um "torpedo" de celular ou uma "micropostagem" de um "microblog". Se a maioria das pessoas conhecesse chinês e o tivesse como sua segunda língua, ou seja, se o chinês assumisse o papel do que o inglês é hoje, aposto que a pessoa em questão, numa mensagem de texto, preferiria usar (??) que só tem 2 caracteres do que job que tem três ou trabalho que tem 8. Não sei como se pronuncia (??) usei o google translator. Aposto que isso pode ser comum nas regiões fronteiriças entre a China e outros países, ou em países colonizados pela China.
3) O uso de anglicismos como gíria na linguagem falada, desconsiderando-se o uso em sites e celulares e levando em consideração sociologia e psicologia, serve como identificação de um grupo: O grupo que sabe o que é e usa a palavra "Job" em detrimento de quem não usa. Pode parecer simplista, mas as pessoas que moram na extrema zona leste de São Paulo dizem a palavra "suave" a cada 3 ou 4 outras palavras, e "suave" como gíria, assume uma gama muito grande de significados e nuanças que variam de acordo com a entonação de voz e o contexto. Pode significar desde um "fácil" até uma pergunta "tudo bem?" (suave?).
4) Não defendo o uso de gírias e nem afirmo que ela faz parte (ou deva fazer parte) da lingua culta, mas, conforme os estudos de muitos linguistas e o legado que Tolkien deixou, as línguas são vivas e sofrem "mutações" expontâneas conforme o tempo passa. O isolamento de um grupo de outro grupo pode acelerar o processo de diferenciação das línguas. Por acaso existe maior isolamento do que o isolamento social que ocorre dentro de uma cidade, onde alguns tem acesso a um ensino de qualidade e línguas estrangeiras enquanto que outros, que já estão semi-isolados geograficamente, não tem acesso ao ensino básico? É por isso que a linguagem sofre tantas mudanças mesmo dentro de uma mesma cidade, variando de bairro para bairro.

Repito: Será que não tem influências da língua portuguesa em outras línguas, por exemplo o Japonês? Não seria submissão então do povo Japonês aos portugueses? Creio que não.

E por falar em submissão, não seria uma submissão de mais de 500 anos nós continuarmos falando português? Aliás, parando para pensar melhor, quem disse que falamos português?
Se você conversar com pessoas do Cabo Verde, Angola ou Guiné Bissau você verá que, salvo alguns regionalismos e palavras próprias, a língua em geral, sonoridade das palavras, consoantes e vogais é muito mais parecida com o português de Portugal do que o é nosso português brasileiro. Nossa língua portuguesa está muito distante do português de Portugal. Além da influência de outras linguas, africanas, indigenas e saxônicas (tivemos aqui alemães e holandeses também)
nosso isolamento foi maior. Não só o isolamento geográfico foi maior, como o isolamento intelectual também. Por séculos falamos português por aqui tendo poucos ou nenhum professor de português decente.
Você pode ver isso na prática, num exemplo até simplório, como abolimos os pronomes "Tu" e "Vós" enquanto que eles ainda são usados nos outros países que se fala Português.

Isso não é evidente só no português. O inglês americano, o qual estudamos e adotamos como "esperanto que deu certo", é muito diferente do inglês da Inglaterra, do Canadá, da Austrália etc... mesmo assim não parece ser tão diferente quanto o português do Brasil é dos outros "portugueses". O mesmo se dá com o espanhol.

O que tudo isso tem a ver com o blog? Linguagens de programação também são estudadas por linguistas e vice-versa. É uma área interdisciplinar e multidisciplinar. Linguagens de programação são línguas artificiais, com verbos predominantemente no imperativo, e formais, sem ambiguidades. Pode-se dizer que as linguagens de programação estão mais vivas que um esperanto, por assim dizer, porque são amplamente usadas no dia a dia de muitos profissionais e elas têm história: você sabe que o C é pai do C++, avô do Java e bisavô do C#. Você sabe que Oxygene é um filho bastardo do C# com o Object Pascal ... e por aí vai.

Antes de criticar anglicismos vamos analisar um pouco os fatos. Anglicismos vão ocorrer, quer sejam coibidos quer não.

Artigo sobre WordPress publicado na Clube Delphi 126

2011-02-23T04:57:00.000-08:00

Já está disponível no site da Dev Media a algum tempo, e logo chegará nas bancas a revista Clube Delphi edição 126.

Nesta edição saiu um artigo meu sobre o WordPress, como integra-lo com uma aplicação Delphi para postagens ou monitoria do que se fala sobre sua marca. Esse artigo foi uma pincelada no assunto. A integração ainda pode se dar via RSS, webservices e outros tipos de customização. Além disso o que foi apresentado não se aplica apenas ao WordPress, mas ao Magento e Joomla também.

Gostaria de destacar o artigo do Rodrigo Araújo sobre Expressões Regulares. Sempre quisemos ter isso no Delphi e agora temos nativo, o que é muito bom.

Padrão Strategy do Rafael Stavarengo é um dos que eu recomendo fortemente a leitura. Aliás, todos os artigos do Rafael Stavarengo são fortemente recomendados. O cara manja muito de POO eDesign Patterns.

O Datasnap XE é O DATASNAP. Tudo o que você esperava de melhorias nessa tecnologia agora estão aí, disponíveis. E o Rodrigo Carreiro Mourão, outra fera, fala de DataSnap associado a generics, RTTI e DAO.

O artigo de capa é indispensável para quem quer praticar XP. Os builds DEVEM ser automatizados.

Espero que todos tenham uma ótima leitura.

Delphi Prism, porque não vale a pena

2011-02-22T10:46:00.000-08:00

Antes de mais nada, Delphi Prism é uma excelente linguagem. Tem todos os recursos que uma linguagem moderna deve ter, é totalmente OO, tem sobrecarga de operadores, Generics, Lambda Expressions, Funções anônimas, é fortemente tipada mas permite type inference etc...

Longe de criticar a linguagem em si e quem investe nela, ou quem a concebeu, tenho algumas criticas com relação ao Delphi Prism que me levam a ponderar se vale mesmo a pena investir na linguagem, já explico o porque.

1) Você não vai economizar na curva de aprendizado. Se você acha que sendo um "Delpheiro" vai economizar na curva de aprendizado do Delphi Prism está enganado. Ao aprender, treinar e desenvolver em Delphi Prism você enfrentará os mesmos desafios que enfrentaria aprendendo C#. Isso se dá porque a maior parte desse aprendizado é referente à semântica (conjunto de bibliotecas, o como fazer) do que à sintaxe. A sintaxe você pega em um dia.

2) O Delphi Prism não é o Delphi .Net. O Delphi .Net (8, 2005, 2006 etc) morreu/foi descontinuado, uma pena. Mas este porduto ERA delphi. Não somente em termos de sintaxe e recursos da linguagem, mas em termos de semântica também. Afinal ele tinha uma "VCL", ou uma tentativa de se reimplementar a VCL no .Net Framework. Era um Framework dentro de outro. A migração do Delphi Win32 para o Delphi .Net era POUCO menos trabalhosa, e a curva de aprendizado um pouco mais suave.

3) Delphi Prism, ou Oxygene, é baseado em pascal, mas muito diferente se comparado com o Object Pascal. Não estou falando em termos de bibliotecas e frameworks que vem no pacote, mas sim de sintaxe. O uso da palavra method no lugar de function ou procedure na minha opinião é desnecessário. Agora, lembra do pascal? Para retornar o valor de uma função você fazia, no final do código da função, NomeFuncao := valor. Muito intuitivo, didático e inteligente. Internamente à função você pode usar o nome dela para atribuir-lhe o valor de retorno, como se ela fosse uma variável local dela mesma. Isso não impedia que se usasse chamadas recursivas ou ponteiros para função. No Delphi/Object pascal tivemos a introdução da variável artificial/implícita Result. Então se você tem uma função Soma, ela pode retornar o valor da maneira Soma := valor ou Result := valor. Result nada mais era do que um atalho, já que na época do pascal até meados do Delphi 1 todo mundo usava uma variável Result como acumulador temporário antes de retornar o valor da função. Mesmo assim Result ainda tem mais "cara" de variável do que de comando.
No Delphi Prism não existe mais a forma Soma := valor, ou método := valor. Você DEVE OBRIGATORIAMENTE usar Result. Result passou do status de "variável" para "comando". Result agora é para o prism o que o return é para as linguagens c-like. Só que sem a vantagem de abandonar imediatamente. Para isso você ainda deve forçar a saída do método. Na minha opinião tirar a sintaxe tradicional do pascal É UMA VIOLAÇÃO DO QUE É SANTO, sim, uma heresia.

4) Não existe (m) ferramentas, compiladores, alternativas gratuitas/open source para o Prism. (o command line tools não conta, seu uso é muito restrito). Também não existem cursos/disciplinas dessa linguagem nos cursos técnicos ou tecnólogos. Logo, você não deve esperar facilidade em contratar um estagiário ou júnior nessa linguagem, muito menos um Sênior autodidata hobbista. A única maneira de ser um autodidata hobbista com Delphi Prism é com pirataria, e eu não faço apologia a pirataria.

Veja bem, continuo achando Delphi Prism demais, gosto muito mesmo, é uma iniciativa legal da Rem Objects e tem todo um histórico de coisas legais por trás disso, mas não programaria com ela se não fosse pago pra isso. Não que ela não tenha futuro, muito pelo contrário, ela pode ter um futuro promissor, mas tudo vai depender de como a dupla RemObjects Embarcadero divulgar e liberar a ferramenta. E não se iluda: Delphi Prism não é Delphi. Se você acha que pode fazer aplicações para IPhone / IPad / IPod no Delphi Prism muito mais facilmente simplesmente porque é "parecido" com Delphi está muito enganado. Utilizando C# você tem a mesma dificuldade, com a vantagem de instalar uma ferramenta a menos. (você não precisaria do prism, mas apenas do visual studio, mono develop, mono e monotouch). Mesmo assim desenvolver para IPhone / IPod / IPad é tão diferente do ambiente Delphi / Win32 que a acentuação na curva de aprendizado, ou seja, a sua dificuldade, estaria no ambiente, no sdk e nas api's da Apple, e não na linguagem. A dificuldade não mudaria muito se você escolhesse o objective-C. E não espere muita portabilidade do código feito em Prism para dentro e fora do windows/mac/linux. Isso porque as bibliotecas e apis que você usa em um não encontrará no outro. A unica coisa que dá para migrar são classes de negócio, as mais abstratas possíveis, e bibliotecas de serviços/funções feitas por você que são algoritmos puros, sem o uso de outras bibliotecas. Nada de GUI ou comunicações.

Basicamente é isso. Se por um acaso a linguagem ganhasse uma implementação open-source (GPL de preferência) e talvez um plugin para integrar sua sintaxe no Eclipse, Sharp Develop ou Mono Develop tudo bem. Enquanto esse dia não chega o Prism não passará de mais uma linguagem .Net entre tantas, com a desvantagem de ser para minorias e de ser só mais uma linguagem fechada e cara dentre tantas abertas e/ou gratuitas.

Críticas? Serão bem vindas. Trollagem? Dê-me audiência.

Criando um arquivo unicode com BOM a partir do Delphi 7

2011-02-18T08:57:00.000-08:00

Hoje um colega que leu meu post sobre quebra de linhas no Delphi 7 e no Delphi novo teve uma dúvida: Ele não estava conseguindo criar um arquivo de conexão UDL válido. Todos eles davam erro ao abrir.

Ele me disse que usar widestring não resolveu.

Fiquei surpreso do porque ele precisaria gerar o udl pelo Delphi, já que é possível apenas criar um arquivo de texto vazio, renomear ara .udl, e o arquivo será criado normalmente. Mas, ele tinha essa necessidade.

Uma das coisas que descobri hoje é que este arquivo, além de começar com [oledb], deve obrigatoriamente ter o "comentário" abaixo. Ou seja, não é apenas um comentario.

[oledb]
; Everything after this line is an OLE DB initstring

O conteúdo deve ser idêntico a esse. Mas não é apenas o conteúdo. Mesmo que se grave os cabeçalhos corretamente e as strings de conexão, e mesmo que as strings sejam widestrings de dois bytes (unicode) o arquivo em si ainda precisa de alguma coisa.

Essa alguma coisa é o BOM: Abrindo um arquivo que funcione em um editor hexadecimal verá que o arquivo começa com os bytes FF e FE.

Esse FF FE se chama BOM, Byte order mark, (http://en.wikipedia.org/wiki/Byte_order_mark) e diz para o programa que estiver lendo o arquivo qual é o formato (unicode ou não) e qual a orientação (big endian ou litle endian).

O BOM em si é um único char, um widechar de 2 bytes. Como você sabe o tamanho do BOM de cara fica fácil escrever ele no stream: o tamanho será 2, ou 1 * sizeof(widechar). Não concatene o BOM, nem "tipe" ele, pois ele será deformado. Grave-o como um puro array de 2 bytes.

Há alguns programas que não precisam do BOM, pois tentam inferir o tipo de arquivo pelo conteudo. Mas outros, como o programinha do windows que le/edita os udl ou o proprio notepad++ salvam o arquivo já com o BOM, e precisam dele para ler.

Faça o seguinte: crie uma const chamada BOM e grave essa constante no arquivo antes de gravar o restante do conteudo. Repare que o problema não é a quebra de linha, mas sim o BOM.

Mas atenção: não é apenas só por causa do BOM.

Como ja dissemos antes o arquivo deve ter inicialmente 3 linhas onde a primeira é [oledb] e a segunda deve ter exatamente 52 caracteres e deve ser exatamente: "; Everything after this line is an OLE DB initstring"

Exemplo de arquivo udl que se conecta em bases dbase.

[oledb]
; Everything after this line is an OLE DB initstring
Provider=MSDASQL.1;Persist Security Info=False;Data Source=dBASE Files

Exemplo de código usando const ou array de bytes. Perceba que um char pode ser representado pelo seu valor hexadecimal contanto que seja precedido de #$. O BOM é #$FF#$FE.

procedure TForm1.Button1Click(Sender: TObject);
var
  teste: WideString;
const
//  BOM = #$FF#$FE;
    BOM: array[1..2] of Byte = ($ff, $fe); 
begin

  with TFileStream.Create(ExtractFilePath(Application.ExeName)+'\teste.udl', fmCreate) do
  try
    teste :=
      '[oledb]'+#13#10+
      '; Everything after this line is an OLE DB initstring'+#13#10+
      'Provider=MSDASQL.1;Persist Security Info=False;Data Source=dBASE Files';
    //você sabe que o BOM tem um tamanho fixo, que é 2 bytes. O bom é um único widechar de 2 bytes
    Write(BOM, 1 * sizeof(widechar)); //2
    Write(Pointer(teste)^, Length(teste)*SizeOf(WideChar));
  finally
    Free;
  end;

end;

faça o download do exemplo.

Have fun ;)

Coisas que eu aprendi no Delphi Meeting

2011-02-16T09:04:00.000-08:00

A apple é mesmo revolucionária.

Depois do Ipod

do IPhone

E do IPad

É hora do.....

IPim

Qual é sua segunda linguagem? E sua terceira?

2011-02-10T10:09:00.000-08:00

Bom pessoAll, antes de mais nada, minha primeira linguagem é Delphi/Lazarus/Object Pascal e ponto final.
Tirando o Delphi a que eu mais gosto e respeito é C/C++, porém nunca arrumei um projeto, pago ou hobby, nessas linguagens. Só coisa acadêmica mesmo.

Todos os posts que discutem sobre linguagens geram bastante polêmica, por mais bobo que seja o assunto.
Eu gosto de olhar o site da TIOBE freqüentemente http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

Position Feb 2011	Position Feb 2010	Programming Language	Ratings Feb 2011	Delta Feb 2010	Status
1	1	Java	18.482%	+1.13%	A
2	2	C	14.986%	-1.62%	A
3	4	C++	8.187%	-1.26%	A
4	7	Python	7.038%	+2.72%	A
5	3	PHP	6.973%	-3.03%	A
6	6	C#	6.809%	+1.79%	A
7	5	(Visual) Basic	4.924%	-2.13%	A
8	12	Objective-C	2.571%	+0.79%	A
9	10	JavaScript	2.558%	-0.08%	A
10	8	Perl	1.907%	-1.69%	A
11	11	Ruby	1.615%	-0.82%	A
12	-	Assembly*	1.269%	-	A-
13	9	Delphi	1.060%	-1.60%	A
14	19	Lisp	0.956%	+0.39%	A
15	37	NXT-G	0.849%	+0.58%	A--
16	30	Ada	0.805%	+0.44%	A--
17	17	Pascal	0.735%	+0.13%	A
18	21	Lua	0.714%	+0.21%	A--
19	13	Go	0.707%	-1.07%	A--
20	32	RPG (OS/400)	0.626%	+0.27%	A--

Lá tem gráficos e comparativos do uso das linguagens. Java e C/C++ são sempre absolutos, e com os novos smartphones, principalmente o Android, a tendência é a popularidade do Java aumentar.
Agora o que me surpreendeu foi o python!!! Eu queria que minha terceira linguagem fosse o Ruby, (já que a segunda é o C#, empatado com o PHP) mas o python está em quarto lugar.

Vocês repararam que embora o Java esteja em primeiro eu não tenho a mínima vontade de aprender Java, a não ser que seja por causa do Android? Pois é, eu não sigo modinhas.

E vocês, qual é a sua segunda e terceira linguagem?

O que você melhoraria no Delphi?

2011-02-10T04:28:00.001-08:00

Uma coisa que eu tenho dificuldade no Delphi é o seguinte: quando você tem muitas opções, muitas mesmo, você acaba com opção nenhuma. Toda vez que começa um projeto novo você perde um tempinho pra decidir qual vai ser o ambiente, os componentes de acesso, etc, etc ..., mas isso é positivo, já que o Delphi vem com muitas ferramentas.
Uma melhoria importante, na minha opinião, seria o Delphi já vir de fábrica com alguns componentes e bibliotecas para competir com o .Net framework. Por exemplo o Delphi já vem com Indy, mas a Indy não pertence à Embarcadero, a Embarcadero poderia compra-la. A mesma coisa com o Rave e outros componentes que são ultra necesários, que não ficamos sem eles. Do contrário você sempre é obrigado a "escolher" a Indy, "escolher" o Rave, vem junto, mas não é Nativo. Lembra do que aconteceu com os componentes da família nm (nmftp, nmsmtp... etc) do delphi 6 para o 7? Sumiram. O mesmo aconteceu com o quick report. Então você tem que confiar que o Indy e o Rave estarão lá para sempre. Se fossem "nativos" daria maior confiabilidade.

Outra coisa que pode melhorar: a literatura especializada conta muito com o arrastar soltar de componentes, mas não ensina os iniciantes a instanciar classes/componentes via código, sem usar os componentes, a fim de ter um código mais limpo e um form designer mais limpo também. Isso já começa diferente no .Net e no Java, que ensinam os iniciantes a usar classes e não componentes. Parece que tudo no Delphi é voltado a RAD, mas esse não é o único mercado. RAD é muito bom pra projetos rápidos e prototipação.

Uma terceira coisa que eu acho que falta é a existência de um framework de persistência e a existência de mediators para fazer databindings entre coleções e datasources, e entre estes e campos data aware (ou campos normais).
Isso é um recurso interessante do .Net framework: qualquer tipo de vetor, hashlist, collection é um datasource em potencial, e não existe componentes exclusivamente data-aware, mas qualquer componente pode ser bindável por um datasource.

Outra coisa: a biblioteca JEDI tem tudo o que a própria VCL tem, só que melhor, e open-source. Além disso tem outras coisas que nem imaginamos. Seria legal ter uma versão express ou community do Delphi sem nenhum componente além do básico, mas com a possibilidade de instalar componentes de terceiros. Assim você instala a JEDI e está garantido.
Se quiser outros componentes da VCL vc poderia pagar por pacote, sob demanda.

Recuperando classes, janelas e senhas com a API do Windows

2011-02-09T10:01:00.000-08:00

Com as API's GetWindowText, GetClassName e o parâmetro WM_GETTEXT de SendMessage é possível obter os textos de qualquer janela da API do windows, bastando ter seu handle. O handle pode ser obtido com WindowFromPoint passando-se como parâmetro a posição do mouse.

Quando você está criando um componente, property editor, component editor ou expert para o Delphi as vezes é necessário saber qual a classe de um Property Editor já existente, por exemplo, para sabermos de onde poderemos herdar para criar o nosso.

Este programa serve para 2 objetivos principais:
1) Obter os handles, nomes e classes de todas as janelas, controles e widgets em que passamos o cursor do mouse.
É especialmente útil para sabermos o nome e classe de uma janela, classe, component editor, property editor ou expert do Delphi, principalmente quando não temos acesso ao fonte ou não conhecemos nada a respeito da mesma e precisamos saber em qual DCU ou BPL compilada ela se encontra (basta pesquisar pelo nome da classe no google que você encontra a unit onde ela está).

2) Revelar ou recuperar senhas perdidas. É importante notar que esse método só recupera senhas que estão mascaradas com asteriscos ("*") mas não recupera senhas mascaradas com a bolinha preta, predominante do windows XP pra frente, graças às novas API's.

Este não é nenhum segredo hacker, na verdade esta API, e o método para obter as senhas, existem desde os primórdios do Windows, e foram muito difundidas e utilizadas até a época do Windows 98.

Onde a recuperação de senhas vai funcionar:

Todos os programas feitos em Delphi (qualquer versão) em que as senhas sejam digitadas em um Edit e nos programas feitos em VB6. Um programa que funcionará também é o Outlook 2007 (do office 2007). Vá no painel de controle e escolha alguma conta de e-mail pop3/smtp com a senha salva. Esta senha é possível de ser revelada facilmente. Não testei as outras versões.

No momento eu não sei como fazer para recuperar as senhas contidas naqueles campos apropriados para senhas (o dos bullets pretos). Se alguém quiser colaborar com essa dica por favor comente.

O sucesso na revelação da senha depende de como o edit e sua classe foram registrados, e com que parâmetros. Em muitos sistemas seria possível obter a senha apenas obtendo-se o "caption" com GetWindowText do controle em questão, já que ele é uma "janela". Em outros o controle deve estar em foco, ou deve ser clicado.

Um FAIL gigante nesse aspecto é que o Visual Studio .Net e o .Net Framework te proporcionam a possibilidade de usar o passwordchar do sistema, ou seja, os Bullets pretos, mas mesmo assim a senha é perfeitamente revelável.

Outra coisa interessante é que o edit do lazarus não revela a senha pelo "SendMessage(hWnd, WM_GETTEXT" e nem permite que o passwordchar seja modificado, mas mesmo assim revela a senha com GetWindowText.

Crie um formulário como o da figura e coloque um timer. A maior parte do código vai nesse timer.

Para usarmos a API do windows para obter respostas textuais temos 3 opções:
1 - Usar vetores de char fixos em x caracteres (usaremos 255)
2 - Usar strings normais, porém pré-setando seu tamanho com setLength para um tamanho obtido com a mensagem WM_GETTEXTLENGTH.
3 - Utilizando ponteiros para chars (pchars) não esquecendo de alocar e desalocar memória para os mesmos.

Usando vetores

unit pegatudo;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, StdCtrls, shellapi;

type
  TfrmPegatudo = class(TForm)
    Label2: TLabel;
    lbclasse: TLabel;
    tempo: TTimer;
    lbHandle: TLabel;
    Label4: TLabel;
    lbJanela: TLabel;
    Label5: TLabel;
    lbSenha: TLabel;
    Label7: TLabel;
    procedure tempoTimer(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  frmPegatudo: TfrmPegatudo;

implementation

{$R *.dfm}

procedure TfrmPegatudo.tempoTimer(Sender: TObject);
var
  hWnd: THandle;
  CrPos: TPoint;
  nomejanela,
  nomeclasse,
  senha: array[0..255] of Char;
begin
  try
    GetCursorPos(CrPos); // Identifica a posicao do mouse
    hWnd := WindowFromPoint(CrPos); // Pega o Handle do controle na posição do mouse

    if hwnd <> 0 then
    begin

      //preenche o conteúdo do vetor com char zeros
      FillChar(nomejanela, 255, #0);
      FillChar(nomeclasse, 255, #0);

      //pega o nome da janela
      GetWindowText(hWnd, NomeJanela, 255);
      //pega o nome da classe
      GetClassName(hWnd, nomeclasse, 255);

      //manda uma mensagem para o handle da janela
      //perguntando se ele possui um password char
      if SendMessage(hWnd, EM_GETPASSWORDCHAR, 0, 0) <> 0 then
      begin
        FillChar(senha, 255, #0);
        //Caso positivo manda a mensagem WM_GETTEXT
        SendMessage(hWnd, WM_GETTEXT, 255, integer(@senha)); //o integer aqui faz com que o parâmetro seja passado como ponteiro em vez de vetor
        lbSenha.Caption :=      string(senha);
        //Caso positivo seta o passwordchar para #0
        //o problema de fazer isso é que vai entrar uma vez só no if
        SendMessage(hWnd, EM_SETPASSWORDCHAR, 0, 0);
      end;

      //preenche os campos
      lbHandle.Caption :=     IntToStr(hwnd);
      lbjanela.Caption :=     string(nomejanela);
      lbclasse.Caption :=     string(nomeclasse);
    end;

  except
  end;

end;

end.

Usando Strings

unit pegatudo;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, StdCtrls, shellapi;

type
  TfrmPegatudo = class(TForm)
    Label2: TLabel;
    lbclasse: TLabel;
    tempo: TTimer;
    lbHandle: TLabel;
    Label4: TLabel;
    lbJanela: TLabel;
    Label5: TLabel;
    lbSenha: TLabel;
    Label7: TLabel;
    procedure tempoTimer(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  frmPegatudo: TfrmPegatudo;

implementation

{$R *.dfm}

procedure TfrmPegatudo.tempoTimer(Sender: TObject);
var
  hWnd: THandle;
  CrPos: TPoint;
  nomejanela,
  nomeclasse,
  senha: string;
  tamJanela,
  tamClasse,
  tamSenha: integer;

begin
  try
    GetCursorPos(CrPos); // Identifica a posicao do mouse
    hWnd := WindowFromPoint(CrPos); // Pega o Handle do controle na posição do mouse

    if hwnd <> 0 then
    begin

      //captura o tamanho dos elementos
      tamJanela := GetWindowTextLength(hwnd) + SizeOf(Char);
      tamClasse := 256;  //o resultado de GetClassName traz um integer com
      //o número de caracteres copiados. Se for maior que 255 a string ou
      //ponteiro pode ser realocado/redimensionado com setsize/malloc e
      //pode ser usado GetClassName novamente para pegar a string completa
      //caso ela tenha vindo truncada.
      //o mesmo pode ser feito com GetWindowText, mas nesse caso a
      //GetWindowTextLength nos ajuda a obter esse tamanho
      //só é trazido o número de caracteres sem contar o terminator null #0

      SetLength(nomejanela, tamJanela);
      SetLength(nomeclasse, tamClasse);

      //preenche o conteúdo do vetor com char zeros
      FillChar((@nomejanela[1])^, tamJanela, #0);
      FillChar((@nomeclasse[1])^, tamClasse, #0);



      //pega o nome da janela
      GetWindowText(hWnd, pchar(integer(NomeJanela)), tamJanela);
      //pega o nome da classe
      GetClassName(hWnd, pchar(integer(nomeclasse)), tamClasse);

      //manda uma mensagem para o handle da janela
      //perguntando se ele possui um password char
      if SendMessage(hWnd, EM_GETPASSWORDCHAR, 0, 0) <> 0 then
      begin

        tamSenha := SendMessage(hwnd, WM_GETTEXTLENGTH, 0, 0)+ SizeOf(Char);
        SetLength(senha, tamSenha);
        FillChar((@senha[1])^, tamSenha, #0);
        //Caso positivo manda a mensagem WM_GETTEXT
        SendMessage(hWnd, WM_GETTEXT, tamSenha, integer(@senha[1])); //o integer aqui faz com que o parâmetro seja passado como ponteiro em vez de vetor
        lbSenha.Caption :=      senha;

        //seta o passwordchar para #0 e
        SendMessage(hWnd, EM_SETPASSWORDCHAR, 0, 0);

      end;

      //preenche os campos
      lbHandle.Caption :=     IntToStr(hwnd);
      lbjanela.Caption :=     nomejanela;
      lbclasse.Caption :=     nomeclasse;


    end;

  except
  end;

end;

end.

Veja que SendMessage(hWnd, EM_SETPASSWORDCHAR, 0, 0); faz com que o edit que era do tipo password deixe de ser, e o password aparecerá desmascarado no edit.

As duas versões do código, bem como programinhas cobaia em Delphi, C# e Lazarus podem ser baixados aqui ou na minha página de download de exemplos.

Have Fun ;)

O Delphi está morto?

2011-02-09T09:34:00.000-08:00

Quem já viu o Delphi XE sabe: NÃO.

Na minha humilde opinião, morto está quem conhece ou usa uma linguagem só ou um ambiente só independente de qual seja, pois não consegue traduzir sua própria lógica e maneira de pensar para um produto ou artefato caso não saiba fazer na linguagem que ele conhece.

A melhor e mais rápida ferramenta de benchmark de DNS que eu já vi na minha vida era feita em assembly por um cara que fazia TUDO em assembly por hobby.

A linguagem que mais respeito, e é imortal sem dúvida é o C++. Mas eu não sou bom de C++, confesso.
A minha linguagem do coração, a qual eu mais manjo, é Delphi.

Se hoje eu estou pesquisando e aprendendo outros ambientes além do Delphi, como Java, C#, Python, Ruby, Prism e Lazarus não é porque esteja abandonando o Delphi, mas sim porque o Delphi acabou ficando caro demais pro meu bico, e todas essas outras linguagens que citei, inclusive o Prism, tem opções open-source.

Eu gosto de open-source não apenas por ter um custo menor mas por ter uma filosofia atraente. As vezes pode ser mais difícil atingir o mesmo objetivo, mas as recompensas e o aprendizado é maior porque ela te obriga a trabalhar com boas práticas desde o começo.

Não aceito críticas ao Delphi feitas por anônimos, a não ser que esses anônimos dêem a cara a tapa e mostrem um blog técnico que seja melhor que o meu, e pelo menos um artigo publicado em qualquer veículo impresso.

Se quem criticar o Delphi for um programadorzinho rad de VB6, VB.net ou C# ignoro, se for um programador Java amante de Design Patterns e POO ou um veterano do C++ que saiba fazer drivers de dispositivo em linux eu posso dar ouvidos, e respeito. Mas acho muito difícil um bom programador criticar qualquer linguagem a troco de nada. Quem critica uma linguagem, IDE ou ambiente é no mínimo um iniciantezinho arrogante.

Delphi é baseado em Pascal, que foi criado por Niklaus Wirth com fins didáticos. Isso não tem como morrer, uma linguagem de programação altamente produtiva com um apelo didático. Quem conhece o trabalho de Niklaus Wirth sabe do que estou falando.

Geralmente, preste bastante atenção, quem critica o Delphi nos blogs e fóruns por aí mal sabe escrever direito.

Nos vemos no Delphi Meeting!

Existem 1001 maneiras de preparar SINGLETON - parte 4

2011-02-08T10:06:00.000-08:00

Se você ler o livro Padrões de Projeto verá que há uma crítica quanto ao uso indiscriminado de Herança. Na verdade o livro mostra que existem outras maneiras de se incorporar ou agregar várias funcionalidades e depois conseguir incorporar ainda outras sem o uso de herança.

Lendo este livro você verá que há uma discrepância grande entre a Análise Orientada a Objeto (AOO) e a Programação Orientada a Objeto (POO).

Enquanto a AOO defende que não pode existir em código nenhum objeto que não seja representante ou modelo de um objeto do "mundo real" a POO, por restrições e questões técnicas, apresenta as figuras das classes de persistência (inexistentes no mundo real) dos DTO (data transfer objects, também inexistentes) dentre outros modelos e padrões. Além disso, em POO você pode ver coisas como sobrecarga de operadores, caso em que a AOO nem sequer cita.

Enquanto o livro Padrões de Projeto foca na POO, ignorando algumas premissas da AOO, ele também põe a herança em seu devido lugar: NEM TODA ESPECIALIZAÇÃO OU INCREMENTO SE RESOLVE COM HERANÇA.

Particularmente no caso de singletons, a herança é desnecessária, visto que o singleton, geralmente, é um objeto cheio de métodos estáticos que nada mais fazem do que prestar serviços. Sim, o singleton sequer faria parte da AOO porque ele é um objeto artificial, existente apenas no domínio da POO por razões técnicas, seja a leitura/escrita de arquivos de configuração seja a criação de objetos de conexão com bancos de dados.

Isto posto, não é necessário se criar heranças de singletons, até porque elas não vão funcionar corretamente e reimplementar todos os métodos de um singleton anula o propósito da Herança. Se precisar de um outro singleton muito parecido você pode:

Simplesmente criar outro copiando a maior parte do código e lógica de funcionamento (não é recomendável fazer isso se forem vários, se você quer fazer um código limpo com duplicação zero ou se deseja apenas atualizar um código para corrigir todos os singletons dependentes dele)
Se for o caso de manter a manutenção em um único ponto (recomendado) crie classes privadas, em pacotes, invisíveis aos programadores consumidores da sua biblioteca, que isolem todo o mecanismo e regras de funcionamento do singleton e implemente-o em forma de façade (fachada).

No exemplo 5 veremos como fazer singletons flexíveis, reutilizáveis e intercambiáveis mesclando o padrão singleton com o padrão façade.

Wazlawick, em seu livro , menciona que a aplicação, ou o objeto aplicação, que é o programa em si, sua "casca" mais externa que vai criar os outros objetos e interfaces deveria ser um singleton, e de fato o é. Mesmo que se executem várias instâncias da aplicação, no ambiente de uma única instância a aplicação em si é um singleton, e qualquer entidade ou artefato que prestasse algum serviço para a aplicação também deveria ser um singleton.

Como o singleton não faz parte das regras de negócio e da AOO aqui abordaremos ele do ponto de vista da POO e faremos uma tentativa de herança do mesmo, para demonstrar as confusões que podem ocorrer.

Neste 4° exemplo, analogamente ao exemplo 2, usamos o recurso de class vars (variáveis estáticas de classe, privadas) e acessores estáticos para criar class properties, coisa que só é possível nas modernas versões do Delphi, por isso perderemos a compatibilidade com o Lazarus.

Primeiro a classe singleton

unit uSingleton;

interface

uses Dialogs, Classes;

type


  TMySingleton = class(TObject)
  private
    class var _MySingletonInstance: TObject;
    class var _PreparadoParaLiberar: Boolean;

    FHello: TstringList;
    FDateTime: string;

  protected
    //se executar isso o objeto pode ser destruido
    class procedure PrepararParaLiberar; virtual;

    class function GetInstance: TMySingleton; static;

    //para criar ou destruir os componentes do objeto
    procedure InicializarObjeto; virtual;
    procedure FinalizarObjeto; virtual;
  public
    procedure SetHello(vHello: string);
    procedure SayHello; virtual;
    constructor Create;  virtual;
    //esses caras misticos abaixo que realmente criam, alocam memoria, destroem e desalocam memoria por tráz dos constructor e destructor que conhecemos
    class function NewInstance: TObject; override;
    procedure FreeInstance; override;
    destructor Destroy; override;
    class property Instance: TMySingleton  read GetInstance;
  end;

implementation

uses SysUtils;




{ TMySingleton }


procedure TMySingleton.SayHello;
begin
  //um metodo bobo pra testar
  ShowMessage('Classe: ' + Self.ClassName + #13#10 +
    'Mensagem: ' + FHello.Text + #13#10 +
    'Data: ' + FDateTime + #13#10 +
    'Instância: ' + inttostr(integer(self)));
end;

procedure TMySingleton.SetHello(vHello: string);
begin
  //um outro metodo bobo pra setar a mensagem
  FHello.Text := vHello;
end;




constructor TMySingleton.Create;
begin
  //antes de tudo, antes mesmo do inherited, newinstance já é chamado por padrão
  inherited; //faz o que for preciso de seu ancestral, eu tenho certeza aqui que o NewInstance está sendo executado
  InicializarObjeto; //inicializo o que precisa
end;

destructor TMySingleton.Destroy;
begin
  FinalizarObjeto;  //destruo as partes ou objetos criados pela minha classe, como stringlists
  inherited;    //a destruição normal do objeto, depois disso freeinstance é chamado normalmente
end;



class function TMySingleton.GetInstance: TMySingleton;
begin

  //isso é apenas um atalho em uma class function

  if _MySingletonInstance = nil then
    _MySingletonInstance := TMySingleton.Create;

  Result := _MySingletonInstance as TMySingleton;

end;





procedure TMySingleton.FreeInstance;
begin

  //no destructor não vai acontecer nada se _PreparadoParaLiberar for false, e eu não preciso disparar uma excessão

  //  agora se _PreparadoParaLiberar for true
  //eu faço o que um FreeInstance sempre deveria fazer, uso o inherited,
  if _PreparadoParaLiberar then
  begin
    inherited;
    //bloqueio a liberação  novamente
    _PreparadoParaLiberar := False;
    //atribuo nil
    _MySingletonInstance := nil;
  end;

  //agora se precisar pode criar de novo

end;

class function TMySingleton.NewInstance: TObject;
begin

  if (_MySingletonInstance = nil)  then
  begin
    //_MySingletonInstance := inherited NewInstance as TMySingleton;
    //_MySingletonInstance.FDateTime := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
    _MySingletonInstance := inherited NewInstance;
    (_MySingletonInstance as TMySingleton).FDateTime := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
  end;

  Result := _MySingletonInstance;

end;

class procedure TMySingleton.PrepararParaLiberar;
begin
  //esse método só faz isso
  _PreparadoParaLiberar := True;
end;

procedure TMySingleton.FinalizarObjeto;
begin
  //aqui você poe somente as coisas que devem acontecer da destruição verdadeira do objeto
  if _PreparadoParaLiberar then
  begin
    FHello.Free;
  end;
end;

procedure TMySingleton.InicializarObjeto;
begin
  //aqui você poe tudo o que precisa que aconteça depois do create
  //lembrando que se o NewInstance já retornar o objeto criado, então
  //Self.FHello vai ser o Fhello dessa instancia, e vai ser <> de nil
  if (FHello = nil) then
  begin
    FHello := TStringList.Create;
  end;
end;



initialization
  //inicializo minhas variáveis publicas, porque vou mecher nelas posteriormente
  TMySingleton._MySingletonInstance := nil;
  TMySingleton._PreparadoParaLiberar := False;



finalization
  if (TMySingleton._MySingletonInstance <> nil) then
  try
    TMySingleton.PrepararParaLiberar;
    TMySingleton._MySingletonInstance.Free;
  except
    //tratamento de exceção, se precisar
  end;


end.

Depois o singleton derivado. Observe que é inútil criar overrides para métodos que fazem apenas "inherited".

unit uSingletonDerivado;

interface

uses uSingleton, Dialogs, Classes;

  type
    TMySingletonDerivado = class(TMySingleton)
  private
    class var _MySingletonDerivadoInstance: TObject;
    class var _PreparadoParaLiberarDerivado: Boolean;
  protected
    class procedure PrepararParaLiberar;  override;
    class function GetInstance: TMySingleton; reintroduce; static;  //não usamos TMySingletonDerivado para não dar invalid typecast caso já exista um singleton base criado

//****************************************************************************
//* métodos que fazem basicamente inherited não precisam ser sobrecarregados *
//****************************************************************************
    //procedure InicializarObjeto; override;
    //procedure FinalizarObjeto;   override;
  public

//****************************************************************************
//* métodos que fazem basicamente inherited não precisam ser sobrecarregados *
//****************************************************************************
    //constructor Create;  override;
    //destructor Destroy; override;

    class function NewInstance: TObject; override;
    procedure FreeInstance; override;

     class property Instance: TMySingleton read GetInstance;
    end;

implementation




{ TMySingletonDerivado }

//****************************************************************************
//* métodos que fazem basicamente inherited não precisam ser sobrecarregados *
//****************************************************************************

{
constructor TMySingletonDerivado.Create;
begin
  inherited;
  InicializarObjeto;
end;

destructor TMySingletonDerivado.Destroy;
begin
  FinalizarObjeto;
  inherited;
end;

procedure TMySingletonDerivado.FinalizarObjeto;
begin
  inherited;
end;

procedure TMySingletonDerivado.InicializarObjeto;
begin
  inherited;
end;
}


{ TMySingletonDerivado }

procedure TMySingletonDerivado.FreeInstance;
begin
  if _PreparadoParaLiberarDerivado then
  begin
    _PreparadoParaLiberarDerivado := False;
    _MySingletonDerivadoInstance := nil;
    inherited;
  end;
end;

class function TMySingletonDerivado.GetInstance: TMySingleton;
begin
  //não usamos TMySingletonDerivado para não dar invalid typecast caso já exista um singleton base criado
  if _MySingletonDerivadoInstance = nil then
    _MySingletonDerivadoInstance := TMySingletonDerivado.Create;

  Result := _MySingletonDerivadoInstance as TMySingleton;
end;

class function TMySingletonDerivado.NewInstance: TObject;
begin
  if (_MySingletonDerivadoInstance = nil) then
  begin
    //_MySingletonDerivadoInstance := inherited NewInstance as TMySingletonDerivado;
    _MySingletonDerivadoInstance := inherited NewInstance;
  end;

  Result := _MySingletonDerivadoInstance;
end;

class procedure TMySingletonDerivado.PrepararParaLiberar;
begin
  _PreparadoParaLiberarDerivado := True;
  inherited;
end;

initialization
  TMySingletonDerivado._MySingletonDerivadoInstance := nil;
  TMySingletonDerivado._PreparadoParaLiberarDerivado := False;



finalization
  if (TMySingletonDerivado._MySingletonDerivadoInstance <> nil) then
  try
    TMySingletonDerivado.PrepararParaLiberar;
    TMySingletonDerivado._MySingletonDerivadoInstance.Free;
  except
    //tratamento de exceção, se precisar
  end;



end.

O programa de teste é o mesmo que fizemos no exemplo 3

Download do código: http://www.vitorrubio.com.br/downloads/Exemplo_Singleton_4.7z

Links úteis, leia todos ;)

Existem 1001 maneiras de preparar SINGLETON, invente uma! - Parte 1

http://blog.vitorrubio.com.br/2010/11/existem-1001-maneiras-de-preparar.html

Existem 1001 maneiras de preparar SINGLETON, invente uma! - Parte 2

http://blog.vitorrubio.com.br/2011/01/existem-1001-maneiras-de-preparar.html

Existem 1001 maneiras de preparar SINGLETON, invente uma! - Parte 3

http://blog.vitorrubio.com.br/2011/02/existem-1001-maneiras-de-preparar.html

Existem 1001 maneiras de preparar SINGLETON, invente uma! - Parte 4
http://blog.vitorrubio.com.br/2011/02/existem-1001-maneiras-de-preparar_08.html

Criando uma classe singleton verdadeira em delphi

http://www.comofazertudo.com.br/computadores-e-internet/criando-uma-classe-singleton-verdadeira-em-delphi

Creating a real singleton class in Delphi 5

http://edn.embarcadero.com/article/22576

Introdução: Singleton - Design Pattern Delphi - Parte 1

http://www.devmedia.com.br/post-17889-Introducao--Singleton-Design-Pattern-Delphi-Parte-1.html

Tentativa de Singleton usando Delphi

http://www.marcosdellantonio.net/2006/12/01/tentativa-de-singleton-usando-delphi/

Implementing the Singleton pattern in delphi

http://www.delphi3000.com/articles/article_1736.asp?SK=

Essa é uma abordagem nova que eu nunca imaginei:

http://stackoverflow.com/questions/1409593/creating-a-singleton-in-delphi-using-the-new-features-of-d2009-and-d2010

Class (, Static, or Shared) Constructors (and Destructors)

http://blogs.embarcadero.com/abauer/2009/09/03/38898

Design Patterns in Delphi

http://delphi.about.com/od/oopindelphi/a/aa010201a.htm

No forum antigo:

Tópico no forum devmedia sobre singleton

no forum novo:

http://www.devmedia.com.br/forum/viewtopic.asp?id=374670

Criando um sistema do Zero - Account Management - Parte 1

2011-02-07T11:33:00.000-08:00

Nesta série de artigos estaremos criando, do zero, um sistema de Account Management (gerenciamento de contas de usuário).

Hoje em dia um relógio não representa mais nenhum avanço tecnológico, visto que todo e qualquer aparelho moderno deve possuir um relógio como requisito mais básico. Celulares, aparelhos de som, DVD players, Blu-Ray (e o extinto videocassete), microondas, televisores, monitores, agendas, calculadoras, telefones fixos, videogames e qualquer outro aparelho pode vir com um relógio, e geralmente vem.

O relógio passou do status de produto tecnológico para ser apenas um ingrediente, uma peça.

É exatamente isso que está acontecendo com os sistemas de Account Management, aqui chamados de AMS.

Veja que enquanto alguns dizem que o CRM é o topo da evolução de sistemas para gerenciamento de clientes, o CRM serve apenas para gerenciar contato e relacionamento com os clientes. A tendência de o CRM tentar centralizar os dados a respeito de clientes de todos os outros sistemas, inclusive legados, em um formato próprio pode mais dificultar do que facilitar.

O carregamento de um CRM qualquer com os dados de todos os sistemas legados da empresa deve ser feito o em duas vias, ou seja, seguido de um carregamento de TODOS sistemas legados com os dados do CRM, DEPOIS DE DEVIDAMENTE TRATADOS.

Caso isso não aconteça os dados do CRM tornam-se apenas mais um montante de dados a serem administrados. Os mesmos problemas existentes antes do CRM prevalecerão depois do CRM, apenas para citar exemplos básicos:

Dados desatualizados - O cliente mudou-se, ou mudou de telefone, e-mail, estado civil;
Dados inconsistentes - O DDD informado não pertence à cidade constante no endereço;
Dados incorretos - Mais grave do que dados inconsistentes, nada pode ser aproveitado, muitos campos nulos;
Dados falsos - O cliente ou o operador do cadastro deliberadamente armazenou no sistema falsas informações, talvez com o propósito de cometer uma fraude;
Dados Repetidos - Existem vários tipos de repetições, e dados repetidos não querem dizer idênticos.

Porém a responsabilidade de um CRM não deveria ser manter o cadastro dos clientes, mas apenas gerenciar a relação com os mesmos, independente de em qual sistema da empresa eles estejam.

Dizemos "independente de em qual sistema da empresa eles estejam" porque empresas muito grandes, com uma gama variada de produtos e serviços, ou empresas formadas por conglomerados de outras empresas podem ter vários sistemas para gerenciamento de produtos diferentes, e mesmo que os clientes sejam consumidores de dois produtos distintos, por estarem em sistemas diferentes eles são considerados clientes diferentes.

Na empresa onde trabalho, por exemplo, há vendas de livors e revistas para distribuidores e atacadistas, bem como venda de assinaturas de revistas (1° sistema). Mas há também um sistema de vendas de livros pela internet, ou seja, um e-commerce (2° sistema). Este e-commerce não tem como backoffice o primeiro sistema, mas sim um terceiro, que também faz vendas em atacado e varejo. Nas filiais e livrarias (lojas físicas), para vendas de livros e revistas, há um 4° sistema. E a editora ainda oferece 2 sistemas de consulta de conteúdo das revistas online, pago através de assinatura, que são diferentes entre si: 5° e 6° sistemas.
Há um sistema de call center,( 7°) e um CRM (8°) que não se integra completamente com os outros sistemas, tornado-se assim apenas mais um.

Um cliente da livraria, por exemplo, não é visto como um prospectivo cliente do conteúdo online, mesmo já sendo assinante.

Agora imagine o cenário onde um cliente foi cadastrado com CPF do cônjuge, divorciou-se, mas não mudou de e-mail. O cônjuge não conseguirá criar um cadastro próprio porque "o cpf informado já existe". Já o outro cliente não conseguirá criar um outro cadastro porque "o seu e-mail já existe".

O cadastro original não pode ser desmembrado em dois, e não pode ser deletado pois já possui um histórico.
O correto nesse caso seria fazer a exclusão via flag (deletado = 1) mas aí você não pode definir o CPF ou o e-mail como unique no banco de dados. Talvez criar um conjunto de tabelas auxiliares para contas e pedidos "lixeira" e mover tudo para lá seria uma boa idéia.

Outra situação, um pouco mais complexa, são de usuários diferentes que são cadastrados com e-mail trocado, ou CPF trocado. Simplesmente é impossível colocar o CPF correto em um porque ele já existe no outro.

Outro problema são e-mails falsos, CPF's falsos, fraudes etc...

Agora imagine um sistema de banco ou de seguro de saúde: esses sistemas são os mais confiáveis em matéria de autenticidade do cliente, pois para um cliente existir no sistema ele teve que comparecer pessoalmente em uma agência e apresentar documentos originais e comprovante de residência. Cada vez que seus dados cadastrais mudarem ele deve voltar pessoalmente em uma agência e apresentar novamente os documentos. Talvez cópias dos documentos fiquem com a empresa e até uma impressão digital do cliente.

Porém sistemas de bancos e seguros saúde não são os mais dinâmicos no sentido de contatos, ou mais especificamente, redes de contatos e atualização desses dados. Por exemplo, se você adquirir 10 celulares novos, 5 contas de e-mail, twitter, orkut, facebook etc... dificilmente o seu banco será informado disso.

Em contrapartida os e-commerces, blogs, jornais e revistas online, embora sejam os mais sensíveis em matéria de dados cadastrais fraudulentos, são os mais dinâmicos no aspecto "social", sendo assim, caso o usuário tenha (e tenha o hábito de usar) celular, SMS,

Esta série de artigos terá como objetivo elocubrar a criação de um sistema de Gerenciamento de Contas seguro e unificado, que possa conter API's tanto para alimentar os sistemas legados com clientes como para ser alimentados por eles.

Conforme forem surgindo os desafios falaremos sobre como resolve-los.

Os objetivos desse sistema, denominado AMS, serão:

fornecer entrada de clientes unificada para todos os sistemas
fornecer consulta de clientes unificada para todos os sistemas
agregar segurança no processo de cadastro de clientes
atualizar e sincronizar em duas vias todos os dados utilizados pelo cliente em todos os sistemas
servir como gerenciador de sessões para sites e blogs com conteúdo pago
ser extensível para acomodar outros tipos de relações além de empresa/cliente

A longo prazo podemos considerar:

prover serviços para sistemas de terceiros, mediante pagamento
prover autenticação para sistemas de terceiros, mediante pagamento
ser um gateway de clientes assim como Moip, PagSeguro e Braspag são gateways de pagamentos
ser uma autoridade no quesito autenticação de usuário assim como o facebook/openID o é, mas fornecendo a segurança de o usuário ser perfeitamente identificável e reconhecível, o que traz segurança para o usuário evitando enganos ou fraudes da empresa, e evitando que sua conta seja sequestrada por outro usuário, e trazendo segurança para a empresa por garantir que o usuário exista.

Optou-se por criar o modelo mais trivial possível e ir aumentando em complexidade conforme necessário. Não tocaremos no assunto sobre metodologias porque simplesmente eu não domino tão bem a engenharia de software a ponto de ser prepotente o bastante para impor alguma metodologia, porém, conforme já disse em aula o meu guru professor Duduchi, "A melhor metodologia de desenvolvimento de software é o bom senso".

Por isso abordaremos algumas boas práticas como testes unitários e TDD, sistemas de gerenciamento de versão (SVN, CVS, VCS, Source Safe, GIT, Mercury e tantos outros) e alguma coisa de UML. Falaremos também sobre frameworks de persistência, webservices e serialização de objetos.

Obviamente alguns desses objetivos são até utópicos, mas vejamos até onde conseguiremos chegar.

Para iniciar nosso projeto usaremos o ArgoUML para gerar os diagramas UML, primeiramente de classes. Podemos também exportar os esqueletos de código.

No próximo post trataremos de mais alguns cenários de problemas e abordaremos a questão da persistência.

Olhando a vida de longe

2011-02-07T08:36:00.000-08:00

Você pode se perguntar o que um gato como eu faz olhando para fora. Perdi alguma coisa?

Através desta tela, que não me deixa sair, eu posso ver o que você ignora todos os dias.

Não se trata apenas dos coloridos alvoreceres ou crepúsculos, mas eu vejo algo que você não vê, eu vejo algo que você perde todos os dias: A VIDA.

Mesmo que eu viva apenas 14 anos, o mais longevo possível para mim, ainda assim teria vivido mais plenamente que você, pois enquanto você vaidosamente corria, em vão, atrás do vento, eu parei ao seu encontro para que ele soprasse meu rosto.

Se é só trabalhar que você sabe fazer, então, BOM TRABALHO.

O santo graal da memória não volátil parte 2

2011-02-04T08:15:00.000-08:00

Estávamos a semana passada a parolar sobre minhas desventuras tentando enviar uma declaração retificadora do meu IR. Eu juro que nunca mais cometerei um erro.

Hoje voltei eu lá, na receita federal do Tatuapé, próximo à praça Silvio Romero, quando minhas desventuras recomeçaram, logo no pré atendimento.

Não sei porque, todos esses atendentes me parecem iguais, e me parecem NPC's, iguais a enfermeira Joy por exemplo: estão em todos os lugares, são todas iguais e respondem com menos palavras que uma URA.

Seria bom se fosse apenas bazófia / prosápia / paparrotada .... pena que não é. Nenhuma delas. É putaria mesmo.

Senhora Dilma, pode ficar com os R$600,00 da minha restituição, espero que seja útil para algum hospital, escola ou creche que estiver precisando.

Enfim, terei que, além de desinstalar todos os virus er programas da receita federal e instalar novamente, não posso aproveitar ou importar o meu arquivo de declaração (.dec), pois ele pode estar, como disse o NPC, com algum "vício". Terei que refazê-lo do zero.

Boa sorte pra mim.

Existem 1001 maneiras de preparar SINGLETON - parte3

2011-02-03T18:06:00.000-08:00

Você já se perguntou como suprimir o método Create para que não seja utilizado? Tentar "esconder" o constructor colocando-o como private não irá funcionar por um motivo simples: ao utilizar o create será visível e perfeitamente "invocável" o create da classe base, que não conterá as informações necessárias para criar realmente o objeto e poderá causar access violations.

O que fazer então?

Na verdade o constructor create nada mais é do que uma espécie de class method (método de classe) especial que serve como alias para o NewInstance. O Create atua como um factory method nativo e bem simples, sendo o NewInstance que efetivamente aloca memória e constroi o objeto.

Então uma maneira muito elegante de se criar um singleton é, em vez de disparar um exception caso o método create seja executado mais de uma vez, sobrecarregar os métodos NewInstance e FreeInstance para impedir que de fato o objeto seja criado duas vezes, ou destruido antes do tempo. Esses métodos são os responsáveis por criar ou destruir um objeto "de verdade" na memoria. Eles que fazem a alocação e desalocação de memoria.

São métodos virtuais. Então sobrecarregando-os e fazendo com que retornem sempre a mesma instancia não importa quantas vezes se execute o create podemos fazer um singleton que trabalha com mais liberdade.

Aqui você vê um tópico interessante sobre o assunto

unit uSingleton;

interface

uses Dialogs, Classes;

type

  TMySingleton = class(TObject)
  private
    FHello: TstringList;
    FDateTime: string;
  protected
    //se executar isso o objeto pode ser destruido
    class procedure PrepararParaLiberar; virtual;
    //para criar ou destruir os componentes do objeto
    procedure InicializarObjeto; virtual;
    procedure FinalizarObjeto; virtual;
  public
    procedure SetHello(vHello: string);
    procedure SayHello; virtual;
    constructor Create;
    //esses caras misticos abaixo que realmente criam, alocam memoria, destroem e desalocam memoria por tráz dos constructor e destructor que conhecemos
    class function NewInstance: TObject; override;
    procedure FreeInstance; override;
    destructor Destroy; override;
    class function InstanciaPadrao: TMySingleton;  virtual;
  end;

implementation

uses SysUtils;

var
  _MySingletonInstance: TObject = nil;
  _PreparadoParaLiberar: Boolean = False;

{ TMySingleton }


procedure TMySingleton.SayHello;
begin
  //um metodo bobo pra testar
  ShowMessage('Classe: ' + Self.ClassName + #13#10 +
    'Mensagem: ' + FHello.Text + #13#10 +
    'Data: ' + FDateTime + #13#10 +
    'Instância: ' + inttostr(integer(self)));
end;

procedure TMySingleton.SetHello(vHello: string);
begin
  //um outro metodo bobo pra setar a mensagem
  FHello.Text := vHello;
end;




constructor TMySingleton.Create;
begin
  //antes de tudo, antes mesmo do inherited, newinstance já é chamado por padrão
  inherited; //faz o que for preciso de seu ancestral, eu tenho certeza aqui que o NewInstance está sendo executado
  InicializarObjeto; //inicializo o que precisa
end;

destructor TMySingleton.Destroy;
begin
  FinalizarObjeto;  //destruo as partes ou objetos criados pela minha classe, como stringlists
  inherited;    //a destruição normal do objeto, depois disso freeinstance é chamado normalmente
end;



class function TMySingleton.InstanciaPadrao: TMySingleton;
begin

  //isso é apenas um atalho em uma class function 

  if _MySingletonInstance = nil then 
    _MySingletonInstance := TMySingleton.Create; 

  Result := _MySingletonInstance as TMySingleton;
  
end;





procedure TMySingleton.FreeInstance;
begin

  //no destructor não vai acontecer nada se _PreparadoParaLiberar for false, e eu não preciso disparar uma excessão

  //  agora se _PreparadoParaLiberar for true
  //eu faço o que um FreeInstance sempre deveria fazer, uso o inherited,
  if _PreparadoParaLiberar then
  begin
    inherited;
    //bloqueio a liberação  novamente
    _PreparadoParaLiberar := False;
    //atribuo nil
    _MySingletonInstance := nil;
  end;

  //agora se precisar pode criar de novo

end;

class function TMySingleton.NewInstance: TObject;
begin

  if (_MySingletonInstance = nil)  then
  begin
    //_MySingletonInstance := inherited NewInstance as TMySingleton;
    //_MySingletonInstance.FDateTime := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
    _MySingletonInstance := inherited NewInstance;
    (_MySingletonInstance as TMySingleton).FDateTime := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
  end;

  Result := _MySingletonInstance;

end;

class procedure TMySingleton.PrepararParaLiberar;
begin
  //esse método só faz isso
  _PreparadoParaLiberar := True;
end;

procedure TMySingleton.FinalizarObjeto;
begin
  //aqui você poe somente as coisas que devem acontecer da destruição verdadeira do objeto
  if _PreparadoParaLiberar then
  begin
    FHello.Free;
  end;
end;

procedure TMySingleton.InicializarObjeto;
begin
  //aqui você poe tudo o que precisa que aconteça depois do create
  //lembrando que se o NewInstance já retornar o objeto criado, então
  //Self.FHello vai ser o Fhello dessa instancia, e vai ser <> de nil
  if (FHello = nil) then
  begin
    FHello := TStringList.Create;
  end;
end;



initialization
  //inicializo minhas variáveis publicas, porque vou mecher nelas posteriormente
  _MySingletonInstance := nil;
  _PreparadoParaLiberar := False;



finalization
  if (_MySingletonInstance <> nil) then
  try
    TMySingleton.PrepararParaLiberar;
    _MySingletonInstance.Free;
  except
    //tratamento de exceção, se precisar
  end;


end.

Creio que o código esteja bem comentado, mas explicando: temos aqui as procedures virtuais InicializarObjeto e FinalizarObjeto e temos a class procedure PrepararParaLiberar. InicializarObjeto simplesmente cria os outros objetos dos quais o singleton é dependente/composto e armazena esta instância no campo/atributo apropriado. Por exemplo nosso singleton faz uso de uma TStringList, então é nesta procedure, InicializarObjeto, que ele será criado. Analogamente ele será destruido em FinalizarObjeto. O trecho de código abaixo garante que a TStringList FHello será criada apenas quando não existir e será destruída apenas quando o singleton não for mais necessário, evitando-se memory leaks.

procedure TMySingleton.FinalizarObjeto;
begin
  //aqui você poe somente as coisas que devem acontecer da destruição verdadeira do objeto
  if _PreparadoParaLiberar then
  begin
    FHello.Free;
  end;
end;

procedure TMySingleton.InicializarObjeto;
begin
  //aqui você poe tudo o que precisa que aconteça depois do create
  //lembrando que se o NewInstance já retornar o objeto criado, então
  //Self.FHello vai ser o Fhello dessa instancia, e vai ser <> de nil
  if (FHello = nil) then
  begin
    FHello := TStringList.Create;
  end;
end;

O fato de ambas serem virtuais e protected é muito importante para evitar que sejam invocadas pelo "client" do singleton e mesmo assim permitir que sejam sobrecarregadas no descendente com a diretiva "override"

A class procedure PrepararParaLiberar apenas ativa uma flag booleana que permite que o singleton seja destruído de verdade.

As procedures SayHello e SetHello apenas mostram ou definem o valor da propriedade Text de FHello que é a mensagem a ser exibida. Considere-os como as operações/serviços principais do seu singleton, como fábricas de componentes de acesso a bancos de dados, por exemplo.

procedure TMySingleton.SayHello;
begin
  //um metodo bobo pra testar
  ShowMessage('Classe: ' + Self.ClassName + #13#10 +
    'Mensagem: ' + FHello.Text + #13#10 +
    'Data: ' + FDateTime + #13#10 +
    'Instância: ' + inttostr(integer(self)));
end;

procedure TMySingleton.SetHello(vHello: string);
begin
  //um outro metodo bobo pra setar a mensagem
  FHello.Text := vHello;
end;

Além de mostrar o nome da classe e a mensagem também mostramos a data e o endereço de memória do objeto. Não confunda com @self, pois @self dará o endereço da variável self de cada instancia, podendo ser diferente para duas variaveis mesmo que apontem para a mesma instancia. Self é o endereço do objeto e de qualquer variável que aponte para ele.

Manter os métodos "Inicializa" e "Finaliza" ajudará a mechar o menos possível no Create e no Destroy, pois as configurações de inicialização ou a limpeza de objetos antes da destruição não ficam no corpo dos métodos create e destroy mas sim no corpo dos métodos Inicializa e Finaliza, que são invocados por Create e Destroy respectivamente.

constructor TMySingleton.Create;
begin
  //antes de tudo, antes mesmo do inherited, newinstance já é chamado por padrão
  inherited; //faz o que for preciso de seu ancestral, eu tenho certeza aqui que o NewInstance está sendo executado
  InicializarObjeto; //inicializo o que precisa
end;

destructor TMySingleton.Destroy;
begin
  FinalizarObjeto;  //destruo as partes ou objetos criados pela minha classe, como stringlists
  inherited;    //a destruição normal do objeto, depois disso freeinstance é chamado normalmente
end;

A mágica de verdade acontece nos métodos NewInstance e FreeInstance. O método NewInstance sempre é uma function que retorna uma instância do objeto recém criado; Objeto este do tipo da classe em questão. Create chama NewInstance e isso pode ser observado com o Debug, da mesma forma que Destroy chama FreeInstance.

O que é feito nesse singleton é manter uma variável do tipo _MySingletonInstance: TMySingleton estática, na seção implementation (global, mas visível apenas nesta unit);

procedure TMySingleton.FreeInstance;
begin

  //no destructor não vai acontecer nada se _PreparadoParaLiberar for false, e eu não preciso disparar uma excessão

  //  agora se _PreparadoParaLiberar for true
  //eu faço o que um FreeInstance sempre deveria fazer, uso o inherited,
  if _PreparadoParaLiberar then
  begin
    inherited;
    //bloqueio a liberação  novamente
    _PreparadoParaLiberar := False;
    //atribuo nil
    _MySingletonInstance := nil;
  end;

  //agora se precisar pode criar de novo

end;

class function TMySingleton.NewInstance: TObject;
begin

  if (_MySingletonInstance = nil)  then
  begin
    //_MySingletonInstance := inherited NewInstance as TMySingleton;
    //_MySingletonInstance.FDateTime := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
    _MySingletonInstance := inherited NewInstance;
    (_MySingletonInstance as TMySingleton).FDateTime := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
  end;

  Result := _MySingletonInstance;

end;

Porque _MySingletonInstance é do tipo TObject e não do tipo TMySingleton? Simples: porque assim não precisa fazer a conversão de tipo na hora de atribuir a NewInstance, apenas na hora de setar o datetime ou na execução do método InstanciaPadrao ( Result := _MySingletonInstance as TMySingleton;)

Essa mudança permite que um singleton base e um derivado sejam criados em seguida sem dar invalid typecast na hora de chamar NewInstance, pois NewInstance grava

As seções initialization e finalization garantem que o singleton seja armazenado em uma variável limpa e seja destruído no final da aplicação.

initialization
  //inicializo minhas variáveis publicas, porque vou mecher nelas posteriormente
  _MySingletonInstance := nil;
  _PreparadoParaLiberar := False;



finalization
  if (_MySingletonInstance <> nil) then
  try
    TMySingleton.PrepararParaLiberar;
    _MySingletonInstance.Free;
  except
    //tratamento de exceção, se precisar
  end;

Há um post sobre um singleton no fórum DevMedia que pode ser herdado, contanto que alguns métodos sejam obrigatoriamente usados. O problema é que não se pode usar um singleton da classe base e outro da classe derivada ao mesmo tempo. Eles compartilham dados em comum, já que o singleton da classe derivada é o mesmo que a classe base com algo a mais.

O tópico foi evoluindo até chegar ao que foi visto nesta minha série de artigos. Os primeiros singletons do tópico pareciam com o singleton deste primeiro artigo. O último já estava mais parecido com este.

Mesmo esta versão mais nova, com todos os cuidados tomados, ainda não pode ser usada juntamente com sua herdeira.

Veja bem, ela pode ser Herdada, mas ou usa-se a classe base ou usa-se a classe filha separadamente. Caso use as duas o que acontecerá? Se você instanciar primeiro a classe base e depois a derivada, ambos os singletons serão da classe base, e se você instanciar a classe derivada primeiro, amboes serão da classe derivada. Isso porque o result de inherited NewInstance é armazenado na variável _MySingletonInstance, ou na _MySingletonDerivadoInstance para classe derivada. Essa variável que contém as instâncias não conseguem diferenciar qual classe está chamando NewInstance e a instância em si é gravada nas duas variáveis.

if (_MySingletonDerivadoInstance = nil) then
  begin
    //_MySingletonDerivadoInstance := inherited NewInstance as TMySingletonDerivado;
    _MySingletonDerivadoInstance := inherited NewInstance;
  end;

  Result := _MySingletonDerivadoInstance;

Eu ainda não consegui resolver esse problema de utilizar as duas classes. Ele não pode ser resolvido simplesmente omitindo-se ou suprimindo o inherited ou reescrevendo todos os métodos e substituindo todas as variáveis como no exemplo anterior. Na verdade ter que reimplementar todos os métodos não é uma herança inteligente, é uma herança burra, um despropósito: pra que herdar se eu tenho que fazer tudo de novo do zero e não aproveito o polimorfismo?

A classe filha, o singleton derivado, foi criado assim:

unit uSingletonDerivado;

interface

uses uSingleton, Dialogs, Classes;

  type
    TMySingletonDerivado = class(TMySingleton)
  protected
    class procedure PrepararParaLiberar;  override;
    procedure InicializarObjeto; override;
    procedure FinalizarObjeto;   override;
  public
    //constructor Create;
    class function NewInstance: TObject; override;
    procedure FreeInstance; override;
    //destructor Destroy; override;
    class function InstanciaPadrao: TMySingletonDerivado;   reintroduce;
    end;

implementation

var
  _MySingletonDerivadoInstance: TObject = nil;
  _PreparadoParaLiberarDerivado: Boolean = False;

{ TMySingletonDerivado }

//*******************************************************************
//* Repare que não foi necessário sobrescrever o Create e o Destroy *
//*******************************************************************

//constructor TMySingletonDerivado.Create;
//begin
//  inherited;
//  InicializarObjeto;
//end;

//destructor TMySingletonDerivado.Destroy;
//begin
//  FinalizarObjeto;
//  inherited;
//end;

procedure TMySingletonDerivado.FinalizarObjeto;
begin
  inherited;
end;

procedure TMySingletonDerivado.InicializarObjeto;
begin
  inherited;
end;

class function TMySingletonDerivado.InstanciaPadrao: TMySingletonDerivado;
begin
  if _MySingletonDerivadoInstance = nil then
    _MySingletonDerivadoInstance := TMySingletonDerivado.Create;

  Result := _MySingletonDerivadoInstance as TMySingletonDerivado;
end;

procedure TMySingletonDerivado.FreeInstance;
begin
  if _PreparadoParaLiberarDerivado then
  begin
    _PreparadoParaLiberarDerivado := False;
    _MySingletonDerivadoInstance := nil;
    inherited;
  end;
end;

class function TMySingletonDerivado.NewInstance: TObject;
begin

  if (_MySingletonDerivadoInstance = nil) then
  begin
    //_MySingletonDerivadoInstance := inherited NewInstance as TMySingletonDerivado;
    _MySingletonDerivadoInstance := inherited NewInstance;
  end;

  Result := _MySingletonDerivadoInstance;

end;



class procedure TMySingletonDerivado.PrepararParaLiberar;
begin
  _PreparadoParaLiberarDerivado := True;
  inherited;
end;









initialization
  _MySingletonDerivadoInstance := nil;
  _PreparadoParaLiberarDerivado := False;



finalization
  if (_MySingletonDerivadoInstance <> nil) then
  try
    TMySingletonDerivado.PrepararParaLiberar;
    _MySingletonDerivadoInstance.Free;
  except
    //tratamento de exceção, se precisar
  end;



end.

Para testar vários quesitos devem ser testados: primeiro de tudo se não estão se criando várias instâncias, depois se a criação e destruição fluem normalmente, se a destruição só é possível quando autorizado/preparado e se instâncias de classes diferentes não se atrapalham mutuamente (este teste não está passando).

Para o teste construa um formulário como este:

E este código:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, uSingleton, uSingletonDerivado;

type



  TfrmSingleton = class(TForm)
    btTeste1: TButton;
    btTeste2: TButton;
    btTEste3: TButton;
    btTeste4: TButton;
    btTeste6: TButton;
    Label1: TLabel;
    Label2: TLabel;
    btTeste5: TButton;
    Label3: TLabel;
    btTesteDerivado1: TButton;
    btTesteDerivado2: TButton;
    btTesteDerivado3: TButton;
    btTesteDerivado4: TButton;
    btTesteDerivado5: TButton;
    btTesteDerivado6: TButton;
    btTesteDerradeiro: TButton;
    Label4: TLabel;
    btCria1: TButton;
    btCria2: TButton;
    btTesta1: TButton;
    btTesta2: TButton;
    btDestroi1: TButton;
    btDestroi2: TButton;
    procedure btTeste1Click(Sender: TObject);
    procedure btTeste2Click(Sender: TObject);
    procedure btTEste3Click(Sender: TObject);
    procedure btTeste4Click(Sender: TObject);
    procedure btTeste6Click(Sender: TObject);
    procedure btTeste5Click(Sender: TObject);
    procedure btTesteDerivado3Click(Sender: TObject);
    procedure btTesteDerivado4Click(Sender: TObject);
    procedure btTesteDerivado1Click(Sender: TObject);
    procedure btTesteDerivado2Click(Sender: TObject);
    procedure btTesteDerivado5Click(Sender: TObject);
    procedure btTesteDerivado6Click(Sender: TObject);
    procedure btCria1Click(Sender: TObject);
    procedure btCria2Click(Sender: TObject);
    procedure btTesta1Click(Sender: TObject);
    procedure btTesta2Click(Sender: TObject);
    procedure btDestroi1Click(Sender: TObject);
    procedure btDestroi2Click(Sender: TObject);
  private
    { Private declarations }
  public
    FMySingleton: TMySingleton;
    FMySingleton1: TMySingleton;
    FMySingleton2: TMySingleton;

    FMySingletonDer1: TMySingletonDerivado;
    FMySingletonDer2: TMySingletonDerivado;

    teste1: TMySingleton;
    teste2: TMySingletonDerivado;
  end;



var
  frmSingleton: TfrmSingleton;

implementation



{$R *.dfm}




procedure TfrmSingleton.btTeste1Click(Sender: TObject);
begin

  FMySingleton1 := TMySingleton.Create;
  with FMySingleton1  do
  begin
    SetHello('teste1');
    SayHello;
  end;

  FMySingleton1.SayHello;

  FMySingleton1.Free;
end;

procedure TfrmSingleton.btTeste2Click(Sender: TObject);
begin
  FMySingleton2 := TMySingleton.Create;
  with FMySingleton2  do
  begin
    //não vamos mudar a mensagem, veremos que é a mesma do teste anterior
    //SetHello('teste2');
    SayHello;
  end;

  FMySingleton2.SayHello;
end;

procedure TfrmSingleton.btTEste3Click(Sender: TObject);
begin
  FMySingleton1 := TMySingleton.InstanciaPadrao;
  FMySingleton1.SayHello;
end;

procedure TfrmSingleton.btTeste4Click(Sender: TObject);
begin
  FMySingleton2 := TMySingleton.InstanciaPadrao;
  FMySingleton2.SayHello;
end;




procedure TfrmSingleton.btTesteDerivado6Click(Sender: TObject);
var fmst: TMySingletonDerivado;
begin

  fmst := TMySingletonDerivado.Create;
  fmst.SetHello('testeA');
  fmst.SayHello;

  //mesmo com várias tentativas de criação e destruição a instância se mantem a mesma

  fmst := TMySingletonDerivado.Create;
  fmst := TMySingletonDerivado.Create;
  fmst := TMySingletonDerivado.Create;

  fmst.SetHello('testeB');
  fmst.SayHello;

  fmst.Free;
  fmst.Free;
  fmst.Free;

  fmst.Destroy;
  fmst.Destroy;
  fmst.Destroy;

  fmst.SetHello('testeC');
  fmst.SayHello;
end;

procedure TfrmSingleton.btCria1Click(Sender: TObject);
begin
  teste1 := TMySingleton.Create;
  teste1.SetHello('hello 1');
end;

procedure TfrmSingleton.btCria2Click(Sender: TObject);
begin
  teste2 := TMySingletonDerivado.Create;
  teste2.SetHello('hello 2');
end;

procedure TfrmSingleton.btTesta1Click(Sender: TObject);
begin
    teste1.SayHello;
end;

procedure TfrmSingleton.btTesta2Click(Sender: TObject);
begin
  teste2.SayHello;
end;

procedure TfrmSingleton.btDestroi1Click(Sender: TObject);
begin
  teste1.Free;
end;

procedure TfrmSingleton.btDestroi2Click(Sender: TObject);
begin
  teste2.Free;
end;

procedure TfrmSingleton.btTesteDerivado1Click(Sender: TObject);
begin
  FMySingletonDer1 := TMySingletonDerivado.Create;
  with FMySingletonDer1  do
  begin
    SetHello('teste4');
    SayHello;
  end;

  FMySingletonDer1.SayHello;

  FMySingletonDer1.Free;
end;

procedure TfrmSingleton.btTesteDerivado2Click(Sender: TObject);
begin
  FMySingletonDer2 := TMySingletonDerivado.Create;
  with FMySingletonDer2  do
  begin
    //SetHello('teste5');
    SayHello;
  end;

  FMySingletonDer2.SayHello;

end;

procedure TfrmSingleton.btTesteDerivado3Click(Sender: TObject);
begin
  //FMySingletonDer1 := TMySingletonDerivado.InstanciaPadrao;
  FMySingletonDer1.SayHello;
end;

procedure TfrmSingleton.btTesteDerivado4Click(Sender: TObject);
begin
  //FMySingletonDer2 := TMySingletonDerivado.InstanciaPadrao;
  FMySingletonDer2.SayHello;
end;

procedure TfrmSingleton.btTesteDerivado5Click(Sender: TObject);
begin
  TMySingletonDerivado.InstanciaPadrao.SetHello('teste6');
  TMySingletonDerivado.Create.SayHello;
  TMySingletonDerivado.InstanciaPadrao.SayHello;
end;

procedure TfrmSingleton.btTeste6Click(Sender: TObject);
var fmst: TMySingleton;
begin

  fmst := TMySingleton.Create;
  fmst.SetHello('testeA');
  fmst.SayHello;

  //mesmo com várias tentativas de criação e destruição a instância se mantem a mesma

  fmst := TMySingleton.Create;
  fmst := TMySingleton.Create;
  fmst := TMySingleton.Create;

  fmst.SetHello('testeB');
  fmst.SayHello;

  fmst.Free;
  fmst.Free;
  fmst.Free;

  fmst.Destroy;
  fmst.Destroy;
  fmst.Destroy;

  fmst.SetHello('testeC');
  fmst.SayHello;

end;

procedure TfrmSingleton.btTeste5Click(Sender: TObject);
begin
  TMySingleton.InstanciaPadrao.SetHello('teste3');
  TMySingleton.Create.SayHello;
  TMySingleton.InstanciaPadrao.SayHello;
end;

end.

Ainda existe um erro ao se executar os testes 1 do singleton base e logo depois o 5 do singleton derivado. Isso porque a instância será um TMySingleton, e seria inválido fazer o typecast para TMySingletonDerivado.

Isso pode ser contornado fazendo com que InstnciaPadrao retorne TMySingleton, assim:

class function TMySingletonDerivado.InstanciaPadrao: TMySingleton;
begin
  if _MySingletonDerivadoInstance = nil then
    _MySingletonDerivadoInstance := TMySingletonDerivado.Create;

  Result := _MySingletonDerivadoInstance as TMySingleton;
end;

Ou então suprimindo-se completamente este método.

O código atualizado tanto para Delphi como para lazarus pode ser baixado aqui: http://www.vitorrubio.com.br/downloads/Exemplo_Singleton_3.zip

Nos próximos dois artigos faremos mudanças que funcionarão apenas no Delphi 2009 em diante, e o lazarus ficará de fora. No exemplo 4 transformaremos as variáveis estáticas globais da unit em variaveis/propriedades de classe e no exemplo 5 criaremos um singleton com generics. Até lá!

PS.: Eu tenho o péssimo hábito de escrever exceção errado, com dois "S" e só percebo depois, por isso onde estiver excessão leia-se exceção.

Vamos ressuscitar o antigo fórum da DevMedia?

2011-02-03T04:54:00.000-08:00

Bom pessoAll, não sei quanto à vocês, mas eu não gostei do forum novo da DevMedia, por isso criei esse tópico e essa enquete para ver se eles voltam para o antigo.

O que vocês acham?

http://www.devmedia.com.br/forum/off-topic/395007-De-boa-pessoall-reabram-o-forum-antigo--Esse-novo-nao-e-legal-.html

Por favor comentem aqui e no fórum.

Embarcadero Technologies

2011-02-02T03:16:00.000-08:00

Aewwwww, me registrei para Delphi Meeting 2011. Vamo lá!

Embarcadero Technologies: "CONFIRMAÇÃO DE REGISTRO!

Estimado(a): Vitor

Obrigado por registrar-se no evento: Delphi Meeting 2011 - São Paulo.

Confirmado sua presença no Delphi Meeting 2011. Se estiver impossibilitado de participar do evento, por favor nos informe, pois as vagas para este evento são limitadas.

Deseja convidar um amigo?

Ligue para (11) 2165-8000 ou acesse http://latam.embarcadero.com/br/delphimeeting

Esperamos você no dia do evento!"

Desbloqueio de Samsung Galaxy S

2011-01-31T07:03:00.001-08:00

Update na parte de cima porque tem gente que não sabe ler:

Recebo uma quantidade absurda de mimimi de gente que não sabe usar um celular e vem desesperado me perguntar o que fazer, então, atenção para algumas regrinhas básicas:

1) Esse procedimento necessita de um reset de fábrica, ou factory reset no seu celular.
2) Todos os seus dados, videos, arquivos e bugigangas serão apagados irrecuperavelmente.
3) Não me responsabilizo por danos causados no seu aparelho.
4) Se não se sentir seguro ou não tiver conhecimento técnico suficiente, ou não entendeu alguma palavra do que eu disse, NÃO FAÇA O PROCEDIMENTO.
5) Isso é um blog, não um fórum.
6) Isso é um blog, E NÃO UM FÓRUM POW!.
7) O procedimento foi realizado com um Samsung Galaxy S, versão 2.1 do Android, modelo GT-I9000B, kernel 2.6.29, n° de compilação ECLAIR.VJJG9. Nunca fiz o procedimento em outro aparelho, nunca nem vi outro. Portanto se o seu aparelho for UM MILÍMETRO, UMA LETRINHA, diferente desse, NÃO ME PERGUNTE, EU NÃO SEI, NÃO TENTE FAZER O PROCEDIMENTO.
8) Eu não sou funcionário, técnico, atendente ou SAC da samsung. Se quiser o SAC da samsung está aqui: http://www.samsung.com/br/
9) Existe um grande site, que pode resolver todas as suas dúvidas e te ajudar a desbloquear qualquer celular, é este aqui http://migre.me/5gLGb
10) Se não sabe o que é Android ou não tem conta no google, faça o favor: nem tente.

Quando comprei um Samsung Galaxy S com linha da VIVO eu ainda tinha um chip pré-pago da OI, e tinha optado por fazer a portabilidade do meu número. Mas como a portabilidade demoraria uns 5 dias, eu queria já usar o meu celular novo, e tentei colocar nele o chip da OI. Nada feito. O sistema estava bloqueado pela VIVO e pedia pin e tal. Mas nem o pin da VIVO nem o da OI servia.
Fiquei com minha linha no chip da OI que não funcionava no celular novo, e o chip novo da VIVO que ainda não tinha meu número, e iria demorar 5 dias. O que fazer? Voltar para o celular antigo por 5 dias?

Para usar meu chip da OI nesses 5 dias no meu celular VIVO tive que fazer o que por lei seria obrigação das lojas e operadoras, mas que eles não fazem por negligência, incompetência e claro desrespeito às leis.

Primeiro de tudo leia esse post http://vitorrubio.blogspot.com/2011/01/dicas-e-codigos-para-celulares.html para saber alguns códigos úteis para seu celular, como o reset de fábrica, por exemplo.

Baixe o programa sgs unlock pelo android market, ou via rapidshare nesse link http://piratamania.com/desbloquear-samsung-galaxy-s-tmn/ (particularmente eu usei o market)
rodar o programa e no botão do menu escolher uma das opções, com ou sem root. (dá pra fazer sem root) Você receberá dois códigos de 8 digitos, um de unlock e um de unfreeze. Anote-os.

Desligue o celular, tire o chip dele (por ex.: vivo) e coloque o seu chip de outra operadora (por ex.: oi) e quando ligar novamente pedirá o código para desbloqueio de rede sim.

Use o código "unlock" anotado do programa. Caso não funcione execute no discador o código para resetar e *2767*3855# e quando ligar (reboot) coloque o código de "unlock".

Pronto, seu chip pre-pago da OI está pronto para ser usado no seu celular novo, agora desbloqueado, até que a portabilidade ocorra. Depois é só colocar seu chip novo.

Dicas e códigos para celulares

2011-01-31T06:01:00.000-08:00

Código para ver se a rede está bloqueada (faça no teclado numérico do discador)
*#7465625#

Com isso aparecerá uma lista de opções e se cada uma delas está bloqueada ou não.

Código para resetar a rede (no discador)

*2767*3855# (isso dará um factory reset no celular, apagando suas configurações e apps salvas)

Código para mudar o pin do seu chip:

* * 04 * pin atual * pin novo * pin novo#

Obtendo o IMEI:

Para bloquear o celular em caso de roubo:

O imei vem anotado em um código barras abaixo da bateria, na parte de dentro, mas você pode discar *#06# que o imei aparecerá. Anote esse número. Caso seu celular seja roubado, ligue na operadora ou na anatel e peça para bloquear esse imei. O ladrão não vai poder usar esse celular nem trocando o chip.

http://www.baixaki.com.br/tecnologia/3544-imei-aprenda-a-bloquear-o-aparelho-celular-em-caso-de-roubo.htm

Códigos padrões de pins de operadoras

TIM - 1010

Claro - 3636

OI - 8888

BrT GSM - 1414

Amaz/Telemig - 1414

CTBC - 1212

VIVO - 8486

Também podem ser usados como padrão:

0000

00000

1234

12345

Fontes

http://www.youtube.com/watch?v=oszeD_o8RSQ

http://ne-miguelito.com/index.php?topic=154590.0

http://piratamania.com/desbloquear-samsung-galaxy-s-tmn/

http://www.blogsdna.com/11906/how-to-unlock-samsung-galaxy-s-with-free-unlock-codes.htm

http://info.abril.com.br/forum/viewtopic.php?f=185&t=1142

Existem 1001 maneiras de preparar SINGLETON - parte2

2011-01-31T05:27:00.000-08:00

No último post desta série mostramos como preparar um singleton que funciona tanto em Delphi como em Lazarus.

Neste post veremos como criar um singleton mais elegante que funcione sem métodos ou variáveis estáticas. Usaremos class vars e class methods para isso. Porém a lógica será a mesma do exemplo anterior.

Objeto Único:

unit uSingleton;

interface

uses
  DateUtils, SysUtils, Windows, dialogs;

type



  TObjetoUnico = class
  private
    FDataHora: string;
    class var  FObjetoUnico: TObjetoUnico;
    class var  FContador: Integer;
    class function GetObjetoUnico: TObjetoUnico; static;
    class function GetContador: integer; static;
  public
    constructor Create;
    destructor Destroy; override;
    function GetDataHora: string; virtual;

    class property ObjetoUnico:  TObjetoUnico read GetObjetoUnico;
    class property Contador: integer read GetContador;
    property DataHora: string read GetDataHora write FDataHora;
  end;

procedure VerificaObjetoUnicoCriado;

implementation


procedure VerificaObjetoUnicoCriado;
begin
  //Uso do FObjetoUnico aqui porque se usasse ObjetoUnico o método acessor
  //GetObjetoUnico seria automaticamente executado, criando o objeto
  if (TObjetoUnico.FContador >= 1) and (TObjetoUnico.FObjetoUnico <> nil) then
    ShowMessage('=========== verificação ===========' + #13#10 +
    'Nome da classe: ' + TObjetoUnico.FObjetoUnico.ClassName+ #13#10 +
    'Hora de Criação: ' + TObjetoUnico.FObjetoUnico.DataHora + #13#10 +
    'Endereço na memória: ' + IntToStr(Integer(TObjetoUnico.FObjetoUnico))
  );
end;


{ TObjetoUnico }

constructor TObjetoUnico.Create;
begin

    //essa verificação impede uma segunda chamada a create
    //se não verificar, ou se deixar crar para se disparar a excessão depois
    //da verificação corre-se o risco de ter criado mais um antes da excessão
    //e aí não será possível destruir, causando um leak
    if (FContador = 0) and (FObjetoUnico = nil) then
    begin
      inherited Create;  //aqui tudo bem usar o inherited create e destroy porque a classe base não faz nada de mais
      InterlockedIncrement(FContador);
      DataHora := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
    end
    else
      raise Exception.Create('Ei! Não use esse constructor, use o CreateUnico!');
    //o inherited fica dentro do if assim o objeto não será criado caso ja esteja o contador > 0

end;



destructor TObjetoUnico.Destroy;
begin

  FObjetoUnico := nil;
  InterlockedDecrement(FContador);
  inherited;

end;

class function TObjetoUnico.GetContador: integer;
begin
  Result := FContador;
end;

function TObjetoUnico.GetDataHora: string;
begin
  Result := FDataHora;
end;



//como a propriedade  ObjetoUnico executa esse get e esse get le o class var e
//o instancia caso seja nil a propriedade ObjetoUnico tem uma proteção
//natural contra nil e sempre será instanciada, nunca será igual a nil
class function TObjetoUnico.GetObjetoUnico: TObjetoUnico;
begin
  //aqui a mesma verificação é feita para não se executar o create duas vezes
  //mas devolver o objeto existente ou devolvê-lo assim que criado
  if (FContador = 0) and (FObjetoUnico = nil) then
    FObjetoUnico := TObjetoUnico.Create;
  Result := FObjetoUnico;
end;

initialization
  //a initilization não é necessária

finalization
  if (TObjetoUnico.FObjetoUnico <> nil) then
  try
    //leia o comentário abaixo para saber porque o campo privado FObjetoUnico
    //é usado aqui em vez da propriedade ObjetoUnico
    TObjetoUnico.FObjetoUnico.Free;
  except
    //tratamento de excessão
  end;

  //por causa da proteção "natural" contra nil você pode destruir
  //o singleton com
  //TObjetoUnico.ObjetoUnico.Free;
  //mas isso causa um overhead porque se o FObjetoUnico não estiver criado (nil)
  //ele será criado só para ser destruído.
  //É bonito de se ver, mas feio do ponto de vista do algoritmo

end.

Objeto Único Derivado:

unit uSingletonDerivado;

interface

uses
  uSingleton, SysUtils, DateUtils, Windows, dialogs;

type


  TObjetoUnicoDerivado = class(TObjetoUnico)
  private
    class var FObjetoUnico: TObjetoUnicoDerivado;
    class var  FContador: Integer;
    class function GetContador: integer; static;
    class function GetObjetoUnico: TObjetoUnicoDerivado;  static;
  public
    destructor Destroy; override;
    constructor Create; reintroduce;   

    class property ObjetoUnico: TObjetoUnicoDerivado  read GetObjetoUnico;
    class property Contador: integer read GetContador;
    function GetDataHora: string; override;

    property DataHora: string read GetDataHora;
  end;

 

procedure VerificaObjetoUnicoDerivadoCriado;

implementation



procedure VerificaObjetoUnicoDerivadoCriado;
begin
  if (TObjetoUnicoDerivado.FContador >= 1) and (TObjetoUnicoDerivado.FObjetoUnico <> nil) then
    ShowMessage('=========== verificação ===========' + #13#10 +
    'Nome da classe: ' + TObjetoUnicoDerivado.ObjetoUnico.ClassName+ #13#10 +
    'Hora de Criação pelo método: ' + TObjetoUnicoDerivado.ObjetoUnico.GetDataHora + #13#10 +
    'Hora de Criação pela propriedade: ' + TObjetoUnicoDerivado.ObjetoUnico.DataHora + #13#10 +
    'Endereço na memória: ' + IntToStr(Integer(TObjetoUnicoDerivado.ObjetoUnico))
  );
end;


{ TObjetoUnicoDerivado }


constructor TObjetoUnicoDerivado.Create;
begin
    if (FContador = 0) and (FObjetoUnico = nil) then
    begin
      InterlockedIncrement(FContador);
      DataHora := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
    end
    else
      raise Exception.Create('Ei! Não use esse constructor, use o CreateUnico!');
end;


destructor TObjetoUnicoDerivado.Destroy;
begin
  FObjetoUnico := nil;
  InterlockedDecrement(FContador);
end;

class function TObjetoUnicoDerivado.GetContador: integer;
begin
  Result := FContador;
end;



function TObjetoUnicoDerivado.GetDataHora: string;
begin
  Result := 'acréscimo ' + inherited;
end;


class function TObjetoUnicoDerivado.GetObjetoUnico: TObjetoUnicoDerivado;
begin
  if (FContador = 0) and (FObjetoUnico = nil) then
    FObjetoUnico := TObjetoUnicoDerivado.Create;
  Result := FObjetoUnico;
end;


initialization

finalization
  //aqui há um exemplo de como o objeto único pode ser destruido
  TObjetoUnicoDerivado.FObjetoUnico.Free;

end.

Os testes podem ser feitos da mesma maneira que o exemplo anterior:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Menus, uSingleton, uSingletonDerivado;

type


  TfrmUmaInstancia = class(TForm)
    btUnico: TButton;
    btDerivado: TButton;
    btVerificaUnico: TButton;
    btVerificaDerivado: TButton;
    procedure btUnicoClick(Sender: TObject);
    procedure btDerivadoClick(Sender: TObject);
    procedure btVerificaUnicoClick(Sender: TObject);
    procedure btVerificaDerivadoClick(Sender: TObject);
  public
  end;



var
  frmUmaInstancia: TfrmUmaInstancia;

implementation



{$R *.dfm}



procedure TfrmUmaInstancia.btDerivadoClick(Sender: TObject);
var FObjetoUnico: TObjetoUnicoDerivado;
begin
  //veja que é possivel executar o create
  //Mas dessa forma não é garantido que o objeto seja unico
  //para garantir que seja único é imprescindível o uso do método  CreateUnico

  FObjetoUnico := TObjetoUnicoDerivado.ObjetoUnico;

  //mostrando a classe do objeto, hora de criação e endereço do objeto
  //veja que é sempre igual
  ShowMessage('Nome da classe: ' + FObjetoUnico.ClassName+ #13#10 +
    'Hora de Criação: ' + FObjetoUnico.DataHora + #13#10 +
    'Endereço na memória: ' + IntToStr(Integer(FObjetoUnico))
  );

end;

procedure TfrmUmaInstancia.btUnicoClick(Sender: TObject);
var FObjetoUnico: TObjetoUnico;
begin

  //veja que é possivel executar o create
  //Mas dessa forma não é garantido que o objeto seja unico
  //para garantir que seja único é imprescindível o uso do método  CreateUnico

  FObjetoUnico := TObjetoUnico.ObjetoUnico;

  //mostrando a classe do objeto, hora de criação e endereço do objeto
  //veja que é sempre igual
  ShowMessage('Nome da classe: ' + FObjetoUnico.ClassName+ #13#10 +
    'Hora de Criação: ' + FObjetoUnico.DataHora + #13#10 +
    'Endereço na memória: ' + IntToStr(Integer(FObjetoUnico))
  );

end;




procedure TfrmUmaInstancia.btVerificaDerivadoClick(Sender: TObject);
begin
  VerificaObjetoUnicoDerivadoCriado;
end;

procedure TfrmUmaInstancia.btVerificaUnicoClick(Sender: TObject);
begin
  VerificaObjetoUnicoCriado;
end;

end.

Da mesma forma que o primeiro exemplo, todos os métodos devem ser re-escritos, e praticamente substituidos sem menção ou referência a inherited. Um override completo.
O único método que pode ser aproveitar dos dois lados do polimorfismo (herdar um método, modificá-lo com override mas ainda assim aproveitar-se de parte do código do método ancestral) e agregar alguma coisa nova no código antigo é o GetDataHora, que é público e virtual.

Também é possível que GetDataHora seja privado, como geralmente um método acessor no Delphi deve ser, mas se crie um novo na classe derivada para servir de método acessor à nova propriedade DataHora. E a DataHora do objeto ancestral pode ser obtida com inherited.
Passamos o método GetDataHora para private tanto no TObjetoUnico como no TObjetoUnicoDerivado, e este método não será mais virtual ou dinâmico nem será mais sobrescrito.

TObjetoUnico = class
  private
    FDataHora: string;
    class var  FObjetoUnico: TObjetoUnico;
    class var  FContador: Integer;
    class function GetObjetoUnico: TObjetoUnico; static;
    class function GetContador: integer; static;
    function GetDataHora: string;

  public
    constructor Create;
    destructor Destroy; override;

    class property ObjetoUnico:  TObjetoUnico read GetObjetoUnico;
    class property Contador: integer read GetContador;
    property DataHora: string read GetDataHora write FDataHora;
  end;

{...}

  TObjetoUnicoDerivado = class(TObjetoUnico)
  private
    class var FObjetoUnico: TObjetoUnicoDerivado;
    class var  FContador: Integer;
    class function GetContador: integer; static;
    class function GetObjetoUnico: TObjetoUnicoDerivado;  static;
    function GetDataHora: string;
  public
    constructor Create; reintroduce;
    destructor Destroy; override;

    class property ObjetoUnico: TObjetoUnicoDerivado  read GetObjetoUnico;
    class property Contador: integer read GetContador;
    property DataHora: string read GetDataHora;

  end;

Mas o método GetDataHora do TObjetoUnicoDerivado é diferente. E ele consegue substituir o acessor da propriedade DataHora mesmo que esta propriedade não esteja declarada no TObjetoUnicoDerivado e não tenhamos um FDataHora. Fazemos isso por usar o inherited de DataHora, onde é possível obter o valor ancestral de DataHora.

function TObjetoUnicoDerivado.GetDataHora: string;
begin
Result := 'acréscimo ' + inherited DataHora;
end;

O ponto fraco dessa abordagem é que se você tiver um objeto TObjetoUnicoDerivado instanciado em uma variável TObjetoUnico, o GetDataHora que será executado é o do TObjetoUnico e não o do TObjetoUnicoDerivado. A única forma de se resolver isso é tornar GetDataHora público e virtual. Assim ele pode ser "sobrescrito" e mesmo uma variável TObjetoUnico pode referenciar o método GetDataHora correto caso este seja um TObjetoUnicoDerivado. Mas a única maneira de se fazer isso sem gerar um access violation caso o método ou propriedade referenciados ainda não estejam na memória ou ainda não tenham sido sobrescritos é retirar do singleton derivado a propriedade DataHora e sobrescrever o método GetDataHora. Somente assim a propriedade DataHora lerá o acessor GetDataHora mesmo em um TObjetoUnicoDerivado instanciado em uma variável do tipo TObjetoUnico.

Ou seja, o final da brincadeira ficará assim:

unit uSingleton;

interface

uses
  DateUtils, SysUtils, Windows, dialogs;

type



  TObjetoUnico = class
  private
    FDataHora: string;
    class var  FObjetoUnico: TObjetoUnico;
    class var  FContador: Integer;
    class function GetObjetoUnico: TObjetoUnico; static;
    class function GetContador: integer; static;


  public
    constructor Create;
    destructor Destroy; override;
    function GetDataHora: string; virtual;

    class property ObjetoUnico:  TObjetoUnico read GetObjetoUnico;
    class property Contador: integer read GetContador;
    property DataHora: string read GetDataHora write FDataHora;
  end;

procedure VerificaObjetoUnicoCriado;

implementation


procedure VerificaObjetoUnicoCriado;
begin
  //Uso do FObjetoUnico aqui porque se usasse ObjetoUnico o método acessor
  //GetObjetoUnico seria automaticamente executado, criando o objeto
  if (TObjetoUnico.FContador >= 1) and (TObjetoUnico.FObjetoUnico <> nil) then
    ShowMessage('=========== verificação ===========' + #13#10 +
    'Nome da classe: ' + TObjetoUnico.FObjetoUnico.ClassName+ #13#10 +
    'Hora de Criação pelo método: ' + TObjetoUnico.FObjetoUnico.GetDataHora + #13#10 +
    'Hora de Criação pela propriedade: ' + TObjetoUnico.FObjetoUnico.DataHora + #13#10 +
    'Endereço na memória: ' + IntToStr(Integer(TObjetoUnico.FObjetoUnico))
  );
end;


{ TObjetoUnico }

constructor TObjetoUnico.Create;
begin

    //essa verificação impede uma segunda chamada a create
    //se não verificar, ou se deixar crar para se disparar a excessão depois
    //da verificação corre-se o risco de ter criado mais um antes da excessão
    //e aí não será possível destruir, causando um leak
    if (FContador = 0) and (FObjetoUnico = nil) then
    begin
      inherited Create;  //aqui tudo bem usar o inherited create e destroy porque a classe base não faz nada de mais
      InterlockedIncrement(FContador);
      DataHora := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
    end
    else
      raise Exception.Create('Ei! Não use esse constructor, use o CreateUnico!');
    //o inherited fica dentro do if assim o objeto não será criado caso ja esteja o contador > 0

end;



destructor TObjetoUnico.Destroy;
begin

  FObjetoUnico := nil;
  InterlockedDecrement(FContador);
  inherited;

end;

class function TObjetoUnico.GetContador: integer;
begin
  Result := FContador;
end;

function TObjetoUnico.GetDataHora: string;
begin
  Result := FDataHora;
end;



//como a propriedade  ObjetoUnico executa esse get e esse get le o class var e
//o instancia caso seja nil a propriedade ObjetoUnico tem uma proteção
//natural contra nil e sempre será instanciada, nunca será igual a nil
class function TObjetoUnico.GetObjetoUnico: TObjetoUnico;
begin
  //aqui a mesma verificação é feita para não se executar o create duas vezes
  //mas devolver o objeto existente ou devolvê-lo assim que criado
  if (FContador = 0) and (FObjetoUnico = nil) then
    FObjetoUnico := TObjetoUnico.Create;
  Result := FObjetoUnico;
end;

initialization
  //a initilization não é necessária

finalization
  if (TObjetoUnico.FObjetoUnico <> nil) then
  try
    //leia o comentário abaixo para saber porque o campo privado FObjetoUnico
    //é usado aqui em vez da propriedade ObjetoUnico
    TObjetoUnico.FObjetoUnico.Free;
  except
    //tratamento de excessão
  end;

  //por causa da proteção "natural" contra nil você pode destruir
  //o singleton com
  //TObjetoUnico.ObjetoUnico.Free;
  //mas isso causa um overhead porque se o FObjetoUnico não estiver criado (nil)
  //ele será criado só para ser destruído.
  //É bonito de se ver, mas feio do ponto de vista do algoritmo

end.

unit uSingletonDerivado;

interface

uses
  uSingleton, SysUtils, DateUtils, Windows, dialogs;

type


  TObjetoUnicoDerivado = class(TObjetoUnico)
  private
    class var FObjetoUnico: TObjetoUnicoDerivado;
    class var  FContador: Integer;
    class function GetContador: integer; static;
    class function GetObjetoUnico: TObjetoUnicoDerivado;  static;
  public
    constructor Create; reintroduce;
    destructor Destroy; override;
    function GetDataHora: string; override;

    class property ObjetoUnico: TObjetoUnicoDerivado  read GetObjetoUnico;
    class property Contador: integer read GetContador;

  end;

procedure VerificaObjetoUnicoDerivadoCriado;

implementation



procedure VerificaObjetoUnicoDerivadoCriado;
begin
  if (TObjetoUnicoDerivado.FContador >= 1) and (TObjetoUnicoDerivado.FObjetoUnico <> nil) then
    ShowMessage('=========== verificação ===========' + #13#10 +
    'Nome da classe: ' + TObjetoUnicoDerivado.FObjetoUnico.ClassName+ #13#10 +
    'Hora de Criação pelo método: ' + TObjetoUnicoDerivado.FObjetoUnico.GetDataHora + #13#10 +
    'Hora de Criação pela propriedade: ' + TObjetoUnicoDerivado.FObjetoUnico.DataHora + #13#10 +
    'Endereço na memória: ' + IntToStr(Integer(TObjetoUnicoDerivado.FObjetoUnico))
  );
end;


{ TObjetoUnicoDerivado }


constructor TObjetoUnicoDerivado.Create;
begin
    if (FContador = 0) and (FObjetoUnico = nil) then
    begin
      InterlockedIncrement(FContador);
      DataHora := FormatDateTime('yyyy-mm-dd hh:nn:ss', now);
    end
    else
      raise Exception.Create('Ei! Não use esse constructor, use o CreateUnico!');
end;


destructor TObjetoUnicoDerivado.Destroy;
begin
  FObjetoUnico := nil;
  InterlockedDecrement(FContador);
end;

class function TObjetoUnicoDerivado.GetContador: integer;
begin
  Result := FContador;
end;



function TObjetoUnicoDerivado.GetDataHora: string;
begin
  Result := 'acréscimo ' + inherited GetDataHora;
end;


class function TObjetoUnicoDerivado.GetObjetoUnico: TObjetoUnicoDerivado;
begin
  if (FContador = 0) and (FObjetoUnico = nil) then
    FObjetoUnico := TObjetoUnicoDerivado.Create;
  Result := FObjetoUnico;
end;


initialization

finalization
  //aqui há um exemplo de como o objeto único pode ser destruido
  TObjetoUnicoDerivado.FObjetoUnico.Free;

end.

A maior lição aprendida aqui é que se desejamos sobrescrever os métodos acessores, para poder usufruir de todos os recursos da herança e do polimorfismo e poder agregar código ao método da classe base ainda usando parte do código da classe base devemos fazer como no Java e em outras linguagens Orientadas a Objetos e criar métodos acessores públicos e virtuais.

Além disso, isso é extremamente necessário, indispensável, para se criar interfaces com propriedades. Em interfaces as propriedades só podem ler e escrever métodos, e nunca campos privados, mas os métodos de uma interface, mesmo que acessores, PRECISAM SER PÚBLICOS E VIRTUAIS para que possam ser implementados.

Essa última alteração pode ser testada com mais um botão que cria uma instância de TObjetoUnicoDerivado dentro de uma variável ancestral, do tipo TObjetoUnico.

procedure TfrmUmaInstancia.brCriaDerivadoEmAncestralClick(Sender: TObject);
var FObjetoUnico: TObjetoUnico;
begin


  FObjetoUnico := TObjetoUnicoDerivado.ObjetoUnico;

  ShowMessage('Nome da classe: ' + FObjetoUnico.ClassName+ #13#10 +
    'Hora de Criação: ' + FObjetoUnico.DataHora + #13#10 +
    'Endereço na memória: ' + IntToStr(Integer(FObjetoUnico))
  );

end;

Quem quiser conferir esse exemplo é só baixá-lo aqui: http://www.vitorrubio.com.br/downloads/Exemplo_Singleton_2.7z

Have fun ;)

O santo graal da memória não volátil

2011-01-28T10:15:00.000-08:00

Caminhava eu para a praça Silvio Romero a fim de resolver minha pugna minha com a receita federal e, precavido que sou, levei minha declaração do imposto de renda E a retificação da dita cuja em duas cópias, uma em DVD e uma em pendrive.

O porque da peleja? não consigo transmitir minha maldita declaração do IR. Recebo essa mensagem de erro:

É esta a mensagem de erro

Optei por essas mídias porque ligando no 146, de Brasília, fui informado de que poderia ser em pendrive. Ao chegar lá, após pegar a senha de pré - atendimento, peguei a de ATENDIMENTO. Foi o tempo de passar 21 telas do angrybirds. Minha senha era AMF XX, AMF de Auxílio Malha Fina.

Chegando lá, a gentil e capacitada funcionária pública da receita disse que eu deveria trazer a declaração para ser transmitida por lá. Saquei a declaração do bolso, e então ela disse que eu deveria pegar uma senha e um formulário para a retransmissão da declaração.

Peguei novamente duas senhas.

Ao ser atendido novamente (milhares de porquinhos depois) o atendente, também incrivelmente capacitado e inteligente, me passou um telefone: (11) 3757-6508. Você consegue ligar? Nem eu. Ele me disse que poderia fazer a transmissão pra mim.

Quando saquei meu DVD desperdiçado com um único arquivo de míseros 2 kb, o atendente, balançando a cabeça, disse: "- cd não pode senhor". "porque?" perguntei. "Porque cd é somente leitura e precisamos gravar o recibo de envio". Eu nem questionei, saquei meu pendrive de 8 GB e disse: - esse grava, e muito.

- Não pode ser pendrive senhor.

- Oras, e o que pode então?

- Disquete.

- O quê? (whaaaaaaaat)?

- Disquete senhor. Desse tipo aqui:

- Karaleo, onde vou arrumar um desses? Tem antiquário por aqui? Tem certeza que o senhor não quer um relógio cuco ou um soldado de terracota? Onde vou arrumar uma coisa dessas.

Pois é, o cara queria um disquete

- Porque não pode ser o pendrive?

- Porque pendrives são muito suscetíveis a virus.

- E um disquete também não pode ter virus?

-NÃO. (sério, ele disse que não)

De fato, para um virus contaminar um disquete, ele tem que ser menor que um disquete. O que é raro para esses trojans modernos. A maioria tem mais de 1.5 MB.

Outra dificuldade é um virus ENCONTRAR um disquete. Dificuldade esta que abracei. Saí da receita alucinado em busca de um disquete. Foi uma verdadeira QUEST de RPG, daquelas que você tem que falar com todos os habitantes do vilarejo para ver se descola alguma dica útil. Cada um falando uma coisa diferente e te mandando ir em um lugar diferente. O Ferreiro te manda para o Alfaiate, que te manda para o Açougueiro, que manda para o Artesão, o Boticário, o Curandeiro, o Padre, a Bruxa .... fui em 3 papelarias e 2 lan houses. Não encontrei. Nas lan houses foi pior, porque fizeram chacota do problema: "você veio da receita né? mwuhauahuaahuau. Desista, mesmo se você tivesse um disquete você nunca, NUNCA vai encontrar um computador com drive de disquete por aqui." (de fato os computadores das duas lan houses, mesmo os servidores ou os caixas, não tinham o drive de disquete).

Disquetes são dispositivos ancestrais, que vem de tempos imemoriais. Foram criados
pouco tempo depois da roda
no alvorecer de nossa civilização, na era de ouro. Mas na inquisição quase todos foram destruídos, já que poderiam ser usados para transportar o alcorão. Dos 5 que restaram, apenas dois vieram para o Brasil nas caravelas, em 1500. Dizem que o portador de um destes pode desvendar todos os segredos do universo. E que todos os segredos do universo têm apenas 1.44 kb e todas as outras ciências são mero enchimento de linguiça.

Então é isso. Depois de meio dia de trabalho perdido fui comer um black dog e jogar umas partidas de fliper na Lords. Quem sabe um dia eu encontro um disquete em algum sítio arqueológico e faço a transmissão da minha declaração.... até lá acho que vou ficar sem minha restituição do IR ...

Revista Clube Delphi 125

2011-01-20T07:50:00.000-08:00

A revista Clube Delphi 125 já está disponível aos assinantes e no site.
Essa revista tem uma introdução muito interessante ao desenvolvimento de aplicações para iPhone utilizando MonoDevelop, MonoTouch e a SDK do iPhone. Desenvolver aplicações para iPhone não é fácil se comparado ao desenvolvimento Win32/Windows Forms com técnicas RAD, mas a matéria explica quais são as diferenças e introduz bem o tema.
Há também um artigo sobre o Firebird 2.5. Eu já usava o 2.1 mas nem imaginava que ele tinha alguns recursos avançados, desses que você pode encontrar no MS SQL.
O artigo de capa fala sobre o Codesite. Se quer aprender a rastrear e corrigir bugs leia-o.
E há um artigo meu sobre criação de experts (plugins) para a IDE do Delphi. É um mundo totalmente novo para quem nunca viu. Há a possibilidade de interagir com units, formulários e componentes em tempo de design e automatizar tarefas, ou apresentar formulários que, se preenchidos, criam arquivos de configuração, units etc.

Vale a pena para quem quiser entrar nesse mundo de Experts e desenvolver ferramentas para programadores. Se seus usuários forer programadores também, 100% de chance de diminuir todos os seus problemas com a "destreza" alheia.

O glorioso retorno do bom senso

2011-01-20T06:24:00.000-08:00

Bom, desde minha volda das férias esse é o meu primeiro post técnico, ou quase.

Bom senso está relacionado à razoabilidade. E vale para tudo, de saúde à tecnologia.

Ando vendo por aí muitas pessoas preocupadas demais com o monte de buzzwords do mercado, são as metodologias e certificações de qualidade (ITIL, PMBOK, RUP, Open UP, XP, Scrum, laranja, abacaxi, batatinha) outras relacionadas a linguagens de programação (Java, Python, C#, Ruby) e cada linguagem de programação se desdobrando em infinitos frameworks para os mais diversos assuntos (Hibernate, Fluent, Linq, velocity, rails, django, makumba, spring).

Para complicar há ainda diversos sistemas operacionais, de windows a bada. E por falar em bada, diversos tipos de mobile (android, symbian, windows 7, bada, iOS, McDonalds, China in Box ).

E as ferramentas para documentação de código ou criação de diagramas? ArgoUML, Poseidon, Model Maker...

Nós, que lidamos com tecnologia, somos curiosos por natureza. Mas a curiosidade pode ser uma faca de dois gumes. Ela pode te levar a destruir sua produtividade.

Você que aprender todas as linguagens, metodologias e frameworks? Quer pelo menos conhecer?

Chamemos essa sopa de letrinhas de siglas e neologismos que nascem aos montes todo dia simplesmente de buzz-tools. Algumas realidades sobre eles que podem ser dolorosas:

1) Você não vai ficar rico se souber todas as buzz-tools.
2) Você não vai ganhar mais dinheiro que seu colega por sua buzz-tool ser melhor ou mais nova.
3) Aprender todas as buzz-tools é como aprender todas as linguagens naturais. Não importa se você tenha pós doutorado na área de Ciência da computação ou áreas correlatas, a verdade é que nem todo pós doutor em letras, por exemplo, fala mais de 10 idiomas. Alguns sabem fluentemente 3 e olhe lá. Todos os idiomas da Terra então, impossível.
Médicos pós doutores também não podem lhe dar vida eterna, nem novos olhos ou novas pernas.
4) Se tentar estudar todas as buzz-tools não se aprofundará em nenhuma delas, não fará nada produtivo e será um especialista em "Hello World", pois será só isso que irá fazer.
5) Convenhamos, se a cada dia aparece uma nova buzz-tool, chegará um momento em que existirá no mundo todo apenas meia dúzia de projetos feito em cada ferramenta, já que o número de ferramentas é tão grande.

O ponto onde quero chegar é que nem todas as buzz-tools precisam ser estudadas. Não que elas não sejam boas (algumas realmente não o são) ou que não mereçam ser estudadas. Mas é que você não vai aplicar todos os seus conhecimentos em todos os projetos. E perceberá que os seus melhores projetos serão os que você usou SEUS conhecimentos, SUAS idéias e SUA criatividade, sem usar padrões, metodologias e buzz-tools. (ou independentemente da que use).

Nenhuma revista, tutorial, fórum ou livro de buzz-tools pode te ensinar a ter criatividade e imaginação. Talvez um litro de cachaça te ensine mais sobre imaginação do que uma enciclopédia de assembly e todos os livros do Dijkstra e Tanembaum juntos.

Pense nisso. Buzz-tools são soluções, ferramentas. Você nunca criará uma solução ou ferramenta se o seu foco for em outras soluções ou ferramentas. Você deve ter o foco no problema. Para criar um bom programa você deve TER um PROBLEMA, FOCAR no PROBLEMA e desenvolver a SUA SOLUÇÃO. Não outro problema. Os únicos softwares que fogem a essa regra são os softwares para fins lúdicos como os games. Esses são mais complicados porque você não deve criar uma solução, mas sim criar um problema (de preferência solucionável com uma certa dificuldade).

Para desenvolver algo realmente complexo, útil e bem feito deve-se desprender totalmente das buzz-tools, abraçar o abstrato e seguir em frente, mesmo que seja em VB6 .... pronto, falei.

NÃO EXISTE MELHOR FERRAMENTA QUE O BOM SENSO.

A alma do programador

2011-01-20T05:18:00.000-08:00

Certa vez, no curso de pós graduação da FATEC-SP, um professor que eu admiro muito, ao ser interrogado sobre quando teria uma janela para reposição de uma aula, sacou seu smartphone para conferir sua agenda e disse:

" - Deixe-me primeiro consultar minha prótese cognitiva."

Interessante, ele considerava o seu celular como uma prótese cognitiva. Não sabia em que lugar ir ou quando ir se não fosse por ele, o celular.

Isso não é de todo ruim se você levar em consideração a filosofia geral que permeava a classe dos Samurais (Saburau ou Bushi) no Japão Feudal dos anos 1200 aproximadamente até 18xx (aproximadamente). Eles tinham um extenso e complexo código de ética/conduta verbal. Era o Bushido, ou caminho do Servidor.

Os Samurais eram, em sua maioria, militares de alta patente, guarda costas, juízes e executores. A maioria deles era muito bem versado nas artes marciais, mas também na poesia e na caligrafia. Todos eram guerreiros no sentido mais amplo da palavra, mas nem todos estavam envolvidos em guerras. Todos os guerreiros, soldados, generais do exército eram Samurais, mas nem todo Samurai era guerreiro. Como a palavra Samurai quer dizer "Servidor", a maioria era servidor público. (Não compare com os servidores públicos de hoje no Brasil).

Os Samurais consideravam sua ferramenta de trabalho (seja a espada para o guerreiro ou a pena para os burocratas) como uma extensão do próprio corpo, ou até mais do que isso, como sua alma. Um guerreiro que perdesse ou danificasse sua espada em uma luta poderia se considerar como se estivesse com um membro amputado, ou pior: um corpo sem vida, sem alma, uma casca vazia.

Ao dizer que meu celular, computador etc são minhas próteses cognitivas, estou afirmando que fazem parte do meu corpo, que são extensão dele. Se você considerar suas ferramentas de trabalho e sua capacidade de usá-las como parte do seu corpo, sua própria alma, você já deu o primeiro passo para se tornar exímio naquilo que faz.

Sim, meu computador é minha alma. Não o computador físico em sentido literal, esse que estou usando para digitar esse texto, mas sim qualquer computador que eu venha a usar, a minha capacidade de lidar com tecnologia, digamos assim.

A idéia é mais abstrata. Um Samurai, aristocrata, ordenava um ferreiro famoso confeccionar uma katana (espada longa) e muitos rituais e formalidades eram envolvidos no processo. A "espada" tinha "alma própria, vida".

Se você der alma, SUA ALMA, à sua ferramenta de trabalho, encontrará um caminho prazeiroso e recompensador.

De volta das férias, e desperdiçando energia

2011-01-10T15:51:00.000-08:00

Boa noite a todos. Depois de umas merecidas férias em Natal (uma vez a cada 5 anos precisa mesmo) estou de volta (fotos em breve) e VIVO. Vivo mas com uma baita úlcera. A causa primária de minha úlcera por incrível que pareça não é a comida forte porém deliciosamente bem temperada de Natal.

A causa-mor de minhas dores é a famigerada Telefonica e aquilo que eles chamam de conexão. Cheguei de viajem dia 23/01/2011 e hoje já é dia 10/01/2011 e eu estou quase sem conexão à internet. Digo quase porque as vezes a conexão vem, mas fica funcionando apenas por alguns minutos e aí eu tenho que fazer todo o circo de liga desliga parafernalha para ver se volta.

Por causa disso criei um blog para fazer um protesto contra esse abuso. http://manifestoderepudioatelefonica.blogspot.com/

São três anos lutando e desperdiçando dinheiro, por uma conexão de 300 k, um pouco melhor que a discada, e que quando funciona fica apenas alguns minutos no ar.

Sabe, não gosto de aparecer, e nesses 12 anos de Internet nunca me passei por troll ou hatter. Quem me conhece sabe disso. Mas a Telefonica está merecendo absolutamente tudo o que eu conseguir criar de ruim para eles. Por isso, canalizarei todas as minhas energias negativas para que cada mísero funcionário que me atendeu porcamente sofra terríveis dores e gemidos de agonia. Que morram todos com um tumor maligno bem lá no *

Em breve farei mais posts técnicos, como a prometida continuação do assunto sobre Singleton e alguns posts rápidos de Lazarus e MonoDevelop. De quebra mostrarei alguns programinhas de segurança legais.

Have fun ;)

Vamos lÃ¡....O correio entrega hoje?

2011-01-05T03:42:00.000-08:00

Tomara, Deus te ouça, e oxalá não façam isso: http://colunistas.ig.com.br/obutecodanet/2011/01/03/por-que-as-vezes-sua-encomenda-chega-com-algum-probleminha/

Ask me anything

formspring.me

2011-01-05T03:15:00.001-08:00

Ask me anything http://formspring.me/vitorrubio

hey how did you survive the holiday season. you got a new years resolution?

2011-01-05T03:15:00.000-08:00

I just survived. I got a new years resolution: dont't tell my resolutions in formspring :p

Ask me anything

Meus vídeos favoritos do youtube até agora

2010-12-27T11:44:00.000-08:00

Clube Delphi 124

2010-12-09T11:40:00.000-08:00

Já está no site da DevMedia a revista Clube Delphi n° 124.

Com um artigo de capa muito interessante e há muito que queríamos ler: controle de versão já integrado no Delphi XE.

Nesta edição você poderá ver também meu artigo sobre compressão de arquivos e a terceira parte do artigo sobre design patterns.

Neste artigo você verá como criar um programa OO multibanco e multicomponente de acesso usando factory method e abstract factoey.

Também é mostrada nessa série de artigos uma maneira mais simples de se criar um singleton do que a que já foi mostrada nesse blog.

Espero que gostem, divirtam-se.