Waldyr Felix

17/11/2009

Melhore seu desktop no Windows 7

Há duas semanas instalei o Windows 7 que tive acesso pelo programa MSDNAA da Microsoft (pra quem não conhece, é um programa de parceria entre a Microsoft e instituições de ensino, que provê acesso dos alunos aos softwares da Microsoft sem nenhum custo – para os alunos pelo menos). Por enquanto, estou adorando o sistema. Muito rápido, bonito e simples. Gostei bastante da nova barra de tarefas e tal.
Mas senti falta de múltiplos desktops, funcionalidade que já existe há muito tempo em outros sistemas operacionais. Pois é, quem já está usando o Windows 7 já deve saber disso, mas eu juro que esperava que a Microsoft fosse incluir esta funcionalidade – na minha opinião essencial para um programador, administrador de rede, ou qualquer pessoal que precise do mínimo de organização em meio às suas dezenas de janelas abertas.

Bom, então fui procurar alguma solução descente na internet para o problema e achei o Dexpot que é simplesmente tudo que eu queria. Ele cria desktops virtuais (até 20) e lhe dá uma gama de configurações (tanta que nem sei) para vc poder customizar ao máximo seus desktops. O programa é leve e tem suporte desde o Windows 2000 até o Windows 7, o legal é que tem alguns efeitos de transição entre os desktops, parecido com esse:

Bem parecido com um efeito que tem no Ubuntu, quando vc instala o Compiz, tem outros efeitos também mas eu gostei mais deste :) Além disso vc pode ter uma pré-visualização dos seus desktops:

Claro que se vc tiver mais que 4 desktops vai aparecer aí também… Fica aí ~~a dica~~ o pedido para a Microsoft adicionar isso no próximo Windows (ou mesmo num service pack), ideia é o que não falta: veja esse link e esse também.

Outro aplicativo que achei bem legal e que também adotei (dica do Scott Hanselma) foi a divisão do desktop em sessões, tal como esta:

Pra fazer isso vc precisa de um outro programinha chamado Fences, com ele vc pode criar várias destas áreas e colocar nomes diferentes, serve como se fosse um contêiner de itens, isso deixa seu desktop bem mais organizado. E se não quiser ficar olhando o tempo todo pra eles, basta dar dois cliques na área vazia do desktop que tudo desaparece (até os ícones), muito legal. E para criar novos “fences” basta clicar arrastar e soltar com o botão direito do mouse, delimitando assim as dimensões do seu novo “fence”.

Bem era isso que tinha pra falar, por hoje é só.

Até a próxima.

11/11/2009

Até quanto C# pode ser considerada uma linguagem funcional?

Estive brincando um pouco com expressões lambda e percebi que simplesmente não dá pra usar recursividade, o detalhe mais importante de todos é que em linguagens funcionais isso é requisito básico. Afinal de contas em linguagem funcional tudo são funções, chamadas de funções e o uso de recursividade neste caso é fundamental.
Testando, o algoritmo recursivo mais vagabundo de todos, o de calculo fatorial, fica assim:

Func<int, int> fat = (b) => (b <= 1) ? 1 : b * fat(b – 1);

Parece bem obvio que isto funciona, mas não funciona… Ao compilar a instrução acima dispara este erro de compilação:

Bonito né? Não, eu não achei nem um pouco bonito, que tipo de expressão “lambda” é essa que não permite fazer chamadas recursivas de si mesma?
Tentei novamente, agora usando todo o dinamismo do C# 4.0, que alias, é lindo - mas vou falar sobre isso noutro post – e ficou assim:

dynamic fat = (Func<int, int>)((b) => (b <= 1) ? 1 : b * fat(b - 1));

Pois também não compila! E acusa o mesmo erro de antes – talvez não foi dinâmico o suficiente…
Apelando mais um pouco dá pra “emular” uma chamada recursiva assim:

Func<int, int> fat = null;
fat = (b) => (b <= 1) ? 1 : b * fat(b - 1);

Antes que alguém pergunte: digo “emular” porque na verdade isso não é uma recursão é chamada de delegate – delegate que chama delegate. Isso é recursão? Não!
Nas linguagens funcionais de verdade tal como Lisp, Scheme e Haskell não existe nenhum comando mágico que sirva para fazer iteração (sem for ou while, foreach nem pensar), temos somente que nos apegar as recursões. Veja o exemplo:

(define (fat n) (if (= n 1) 1 (* n (fat (- n 1)))))

Isso aí é meu algoritmo fatorial em Scheme, já deve ter percebido porque as linguagens funcionais não são lá muito populares né? Apesar que se vc estudar um pouco vai ver que são linguagens extremamente simples, mas vamos em frente com outro exemplo:

fat = lambda x: 1 if x <= 1 else fat(x-1) * x

Isso aí agora é Python, pois é, Python é uma linguagem multi-paradigma e dinâmica onde dá para programar de forma estruturada, orientada a objetos ou mesmo como uma linguagem funcional (ver também IronPython). Bem mais fácil de entender…

O que eu quero dizer com todo essa conversa é que a Microsoft não tem intuito de torna C# uma linguagem dinâmica como Ruby (ver também IronRuby), nem totalmente funcional como Lisp (ver também linguagem funcional da Microsoft, o F#). Estas ~~novas~~ características da linguagem tem mais a ver com evolução natural do C# e necessidade de se ter uma ferramenta cada vez mais flexível, deixando o desenvolvimento de software cada vez mais ágil e simplificando a vida dos desenvolvedores.

Então, não pense que o C# vai ser tão dinâmico quanto Python ou tão funcional quanto Lisp, isso nunca vai acontecer. Mas isso não quer dizer que a Microsoft não possa dar um suporte melhor à programação dinâmica e funcional. Apesar que isso poderá mudar em breve, talvez no C# 5.0, vamos esperar pra ver.

Por hoje é só, até a próxima.

31/10/2009

Usando parâmetros opcionais no C# 4.0

Olá pessoal, hoje vamos falar um pouco sobre um novo recurso do C# 4.0, os parâmetros opcionais.
Para isto utilizaremos um código bem simples que gera strings, segue:

public string[] GerarString()      
{     
    return GerarString("Parâmetros");      
}     
public string[] GerarString(string str)      
{     
    return GerarString(str, 10);      
}     
public string[] GerarString(string str, int qtd)      
{     
    var lista = new List<string>();     
    for (int i = 0; i < qtd; i++)     
    {     
        lista.Add(str);     
    }     
    return lista.ToArray();     
}     
Como vocês estão vendo, aqui utilizei 3 métodos sobrecarregados, onde posso chamá-los passando a string que eu quero gerar e a quantidade de repetições, ou somente a string que eu quero gerar (neste caso a quantidade default é 10), ou mesmo não passar nenhum parâmetro (neste caso a quantidade default é 10 e o string é "Parâmetros").     
Bem, não há novidade nenhuma até agora. O fato é que parâmetros default têm o funcionamento parecido com os métodos sobrecarregados e torna a linguagem mais expressiva, vamos ver agora o código a seguir:

public string[] GerarString(string str = "Parâmetros", int qtd = 10)      
{     
    var lista = new List<string>();      
    for (int i = 0; i < qtd; i++)      
    {     
        lista.Add(str);     
    }     
    return lista.ToArray();      
}

Ficou bem mais simples e bem menor! O que acontece agora é que estamos dizendo ao compilador que se nada for passado no parâmetro str ele assumirá o valor "Parâmetros" e se nada for passado no parâmetro qtd ele assumirá o valor 10. Isso significa que podemos passar ou não os parâmetros (opcionais) e as chamadas ficam idênticas a como fazíamos com a sobrecarga de método:

// sem passar nenhum parâmetro, neste caso assume os defaults     
GerarString();

// passando somente o ultimo parâmetro, neste caso somente str assume o default     
GerarString(15);

// passando ambos, nenhum parâmetro assume o default     
GerarString("Agora tou passando", 30);

Legal, mas temos que ter em mente algumas regrinhas na hora de sair programando com parâmetros opcionais.

É possível especificar quantos parâmetros opcionais você quiser, desde que comece do ultimo para o primeiro.

void Calcular(int a, int b, int c = 10) // isso é permitido
void Calcular(int a = 10, int b, int c) // isso NÃO é permitido

Não é permitido intercalar parâmetros opcionais e não opcionais.

void Calcular(int a = 2, int b, int c = 8) // isso NÃO é permitido

Caso todos os parâmetros do método sejam opcionais é possível escolher quais poderemos passar usando parâmetros nomeados.

Calcular(b: 1); // especifica somente b, enquanto a e c assumem o default
Calcular(b: 5, c: 4); // especifica somente b e c
Calcular(b: 5, a: 10, c: 4); // ou mesmo especificados (a ordem não importa)

O parâmetro default sempre deve ser uma constante.

Calcular(int a, int b, int c = SelecionarC()) // isso NÃO é possível

Como podemos observar existem grandes aplicações para este novo recurso do C#, façam bom uso dele. Espero que tenham gostado.

Tchau e até a próxima.

27/10/2009

Verificando existência de Objetos no SQL Server

Olá, após um longo tempo fora do meu blog volto com força total e neste post vou falar um pouco sobre como podemos obter informações sobre existência de objetos numa base SQL Server. Entenda "objeto" como qualquer coisa que possa ser manipulada no banco tal como tabelas, colunas, constraints, índices, chaves primárias, etc.

No SQL Server existe uma função Object_ID() que é muito útil na hora de descobrir a existência de elementos no banco.

-- Retorno o id do objeto do elemento buscado

if Object_ID('CK_NIVEL') IS NOT NULL