Arquivo

Arquivo de maio, 2009

Cuide de suas ferramentas de trabalho

9 de maio de 2009

Estava dando uma folheada no manual do meu MacBook, e na seção “Last, but no least” encontrei pequenas dicas sobre ergonomia, algo que muitas vezes os programadores não dão muito importância.

Ao usar o teclado e o trackpad, seus ombros devem estar relaxados. O seu braço e o antebraço devem formar um ângulo pouco maior que 90 graus, com o seu pulso e sua mão quase em uma
linha reta.

Toque levemente o teclado ao digitar ou usar o trackpad e mantenha suas mãos e dedos relaxados. Evite rolar seus polegares sob as palmas das mãos.

Altere sempre a posição das mãos para evitar fatiga. Alguns usuários de computadores podem desenvolver desconfortos em suas mãos, pulsos ou braços após o uso intensivo sem intervalos.
Se começar a desenvolver uma dor crônica ou desconforto nas suas mãos, pulsos e ombros,
consulte um médico especialista qualificado.

Antes de entrar para o mundo da informática, trabalhei por uns 3 anos em uma empresa de pagers (ou beepers). Eram 6 horas por dia de atendimento telefônico digitando as mensagens a serem enviadas. Lá aprendi sobre LER (Lesão por esforço repetitivo) e vi muita gente fazendo tratamento fisioterapêutico para curar tendinite.

Eu digitava com os pulsos suspensos, sem apoiá-los em lugar nenhum. No final do dia estava com dores nos tendões, nervos e ligamentos. Depois que comecei a apoiar os braços para digitar, minha produtividade e velocidade aumentou. Com isso, aliado a alongamentos periódicos (por exemplo, de uma em uma hora, sentado mesmo), minhas dores nos braços se foram.

Eu já vi muitos programadores escreverem código de uma forma tensa, sem relaxar os ombros e os braços, com os pulsos suspensos, sem apoio.

Os pulsos devem ficar apoiados na mesa ou (melhor ainda) em um apoio ergonômico de teclado próprio.

Hoje em dia, alguns programadores ficam até 12 horas por dia na frente do computador, escrevendo código sem parar. Se você não relaxar quando está digitando, estará muito propenso a uma lesão crônica.

Algumas empresas, como a Locaweb, fornecem um programa de ginástica laboral para seus funcionários. Isso ajuda e muito, mas não adianta terminar a sessão de ginástica e voltar a sentar na frente do computador sem postura e movimentar os pulsos quando deveria movimentar somente os dedos.

Uma observação rápida: bons programadores evitam o usar o mouse, substituindo suas funções por teclas de atalho. Além de aumentar sua produtividade, ajudam na sua saúde também.

Você precisa cuidar do seu corpo: coluna, ombros, braços, pulsos, mãos, dedos. Se eles não funcionarem bem, como você irá transformar as idéias que surgem em sua mente em código?

O manual do MacBook pode ser baixado nos seguintes endereços:

Há também mais informações sobre ergonomia no site da Apple: http://www.apple.com/about/ergonomics.

Geral , , , , , ,

Como medir o uso da CPU utilizando Performance Counters

4 de maio de 2009

Na última semana no trabalho, dois desenvolvedores estavam procurando uma forma de recuperar a porcentagem de uso da CPU utilizando .NET. Eles encontraram uma solução utilizando Win32_Processor de WMI e classes do namesapce System.Management, escrevendo algo mais ou menos assim:

ObjectQuery query = new ObjectQuery("SELECT * FROM Win32_Processor");
ManagementObjectSearcher searcher = new ManagementObjectSearcher(query);

int load = 0;
int cpus = 0;

foreach (ManagementObject mo in searcher.Get())
{
    load += Convert.ToInt32(mo["LoadPercentage"]);
    numCpus++;
}

decimal cpuUsage = load / cpus;

Uma maneira mais fácil de fazer isso, e que atende ao propósito de medir recursos utilizados da máquina, é utilizar Performance Counters. Classes como PerformanceCounter e PerformanceCounterCategory, que são encontradas no namespace System.Diagnostics, lhe dão acesso não somente a informações do uso do processador, mas também informações sobre cachê de sistema, disco físico, memória, threads, entre outros.

O exemplo abaixo mostra como criar uma instância da classe PerformanceCounter para recuperar a porcentagem do uso da CPU naquele instante:

PerformanceCounter cpuCounter = new PerformanceCounter
{
    CategoryName = "Processor",
    CounterName = "% Processor Time",
    InstanceName = "_Total"
};

float cpuUsage = cpuCounter.NextValue();

Note que na propriedade CategoryName é informado “Processor”, a categoria referente ao processador da máquina, e na propriedade CounterName, o contador que se refere à porcentagem do tempo de processamento. Em algumas categorias de Performance Counter é necessário especificar o nome da instância do contador, através da propriedade InstanceName, como é o caso da categoria “Processor” do exemplo acima, onde está sendo utilizado a instância “_Total”. Na minha máquina, para a categoria “Processor”, também estão disponíveis as instâncias “0″ e “1″, que se referem aos dois núcleos do meu AMD Athlon™ 64 X2 Dual Core Processor 6000+.

Na categoria “Memory” não é necessário especificar o nome da instância. Veja abaixo o exemplo de como obter a quantidade de memória disponível:

PerformanceCounter ramCounter = new PerformanceCounter
{
    CategoryName = "Memory",
    CounterName = "Available MBytes"
};

float availableRam = ramCounter.NextValue();

Para recuperar todas as categorias disponíveis para medição, use o método GetCategories da classe PerformanceCounterCategory:

PerformanceCounterCategory[] categories;
categories = PerformanceCounterCategory.GetCategories();

A partir de uma categoria, você pode recuperar todas os nomes de contadores. Por exemplo, o código abaixo:

var category = new PerformanceCounterCategory("System");

foreach (PerformanceCounter counter in category.GetCounters())
{
    Console.WriteLine(counter.CounterName);
}

Gera a seguinte saída:

File Read Operations/sec
File Write Operations/sec
File Control Operations/sec
File Read Bytes/sec
File Write Bytes/sec
File Control Bytes/sec
Context Switches/sec
System Calls/sec
File Data Operations/sec
System Up Time
Processor Queue Length
Processes
Threads
Alignment Fixups/sec
Exception Dispatches/sec
Floating Emulations/sec
% Registry Quota In Use

Eu fiz duas aplicações console de exemplo utilizando Performance Counters:

  • Uma exibe a porcentagem de uso da CPU e a quantidade de MB de memória disponíveis, atualizando as informações a cada um segundo;
  • A outra lista todos os nomes de instâncias e contadores de algumas categorias.

Você pode baixar essas duas aplicações aqui.

.NET , ,

Frameworks e DDD: Mantendo o modelo limpo, por Tim McCarthy

2 de maio de 2009

“Frameworks and DDD: Keeping the Model Clean” foi mais uma das apresentações que assisti na QCon San Francisco 2008, em que Tim McCarthy mostrou algumas técnicas para desacoplar o modelo de domínio da infra-estrutura da aplicação e ainda sim continuar usando recursos de frameworks em .NET.

Tim McCarthy é autor de .NET Domain-Driven Design with C#: Problem - Design - Solution, um livro que propõe mostrar os passos da implementação de uma aplicação real utilizando DDD. O livro é dividido em módulos, cada um identificando um problema, elaborando o design e implementando a solução.

A idéia é sempre deixar o domínio intacto, somente com o código do coração do software. Se você utilizar as famosas ferramentas de “arrastar e soltar”, vai poluir as entidades do domínio com código de infra-estrutura.

Quando falou a respeito do ADO.NET Entity Framework, o novo framework de mapeamento objeto-relacional da Microsoft, Tim se expressou indignado: “Oh, my God!”. Segundo ele, arrastar e soltar tabela por tabela do seu banco de dados, deixando o Visual Studio gerar um monte de código para você é algo não muito bom para se fazer.

Essas ferramentas de geração de código podem ser uma armadilha para desenvolvedores inexperientes. Para sistemas pequenos, sem grandes pretensões, isso pode ser uma solução rápida e que atende sua necessidade. Mas para grandes aplicações é preciso se concentrar no domínio e eliminar qualquer código que polua suas entidades de negócio.

Não é uma boa idéia criar um modelo de domínio fazendo a relação de uma entidade por tabela no banco de dados. As tabelas do banco de dados pertencem à infra-estrutura do sistema. O seu modelo de domínio deve ser rico e refletir seu negócio, o mais próximo da realidade possível. A partir do seu modelo de domínio é que você constrói uma infra-estrutura de persistência de dados.

A apresentação de Tim McCarthy foi repleta de exemplos reais (e rodando) de código. Num deles, mostrou uma classe de entidade do domínio onde havia uma referência using para o namespace Microsoft.SharePoint. Esse foi um tipico exemplo de entidade de negócio poluída.

Também tivemos um exemplo de utilização de repositórios (Repository), que segundo Tim, são um tipo de abstração da persistência, comparando-os como um tipo de coleção de dados, onde é possível listar, inserir, alterar e remover seus itens. Ele enfatizou que o classes do modelo de domínio podem usar repositórios, mas elas devem estar ligadas somente às interfaces dos repositórios, não acopladas às suas implementações.

Outra parte “prática” da apresentação foi a utilização de injeção de dependência (Dependency Injection) de repositórios nas classes de serviço e alteração do tipo de persistência via arquivo de configuração.

Tim também mostrou a implementação de uma unidade de trabalho (Unit of Work), onde a mesma não conversava diretamente com a base de dados.

A apresentação excedeu 10 minutos do tempo previsto, pois tinha muito código interessante a ser mostrado. Isso só acabou instigando a dar uma olhada no seu livro, que vem com o código fonte de todos os passos de construção de uma aplicação em .NET aplicando os padrões de DDD.

Só não esqueça que todo esse código somente vai poder lhe ajudar se você definir bem seu modelo de domínio, consistente e conciso com a realidade do seu negócio.

Você pode assistir à palestra no site da InfoQ:
http://www.infoq.com/presentations/Clean-Model-Tim-McCarthy

Baixe também os slides da apresentação em PDF neste endereço:
http://qconsf.com/sf2008/file?path=/qcon-sanfran-2008/slides//TimMcCarthy_DotNet_Domain_Driven_Design_With_CSharp.pdf
.
Post original:
http://tecblog.locaweb.com.br/2008/11/24/qcon-frameworks-and-ddd-keeping-the-model-clean

.NET, Arquitetura, Eventos , , , , , , , ,