Venho, por meio deste, apenas demonstrar alguns aplicativos devéras úteis e, principlei almente, mostrar que ainda estou vivo.

E, importante:

1. Ainda estou usando o Opera (ou seja, estou usando a mais tempo que qualquer outro navegador, eu acho);
2. Instalei o Mandriva 2009.1 RC2 (está quase funcionando) em uma partição ext4;
3. Durante algum tempo, testei o Windows 7. Está muito bom, incrivelmente leve. Pena que o driver beta de vídeo da Intel (no note, é claro) NÃO implementava completamente OpenGL;

Dessa vez, postarei alguns aplicativos, todos free, eu acho.

Então, indo direto ao ponto.

TeraCopy

Como todos sabem, o recurso de copiar/recortar e colar do Windows não é exatamente eficiente. Este aplicativo tenta consertar isso. Após a instalação, ele se registra como copiador padrão de arquivos. Além de, aparentemente, ele acelerar as cópias de arquivos, faz a checagem de integridade e permite o desligamente do PC após a cópia (opções não habilitadas por padrão, mas basta clicar no botão na janela de cópias) Recomendo a versão beta, que possui essas opcões citadas). Como devem ter percebido, roda apenas em Windows.

XMind

Um plugin para Eclipse para fazer mapas mentais. Também existe uma versão “stand alone”. Além dos recursos normais em aplicativos do genero, este possui uma parte “social”: seus mapas podem ser enviados para a comunidade XMind. No geral, os recursos deixarão usuários do Freemind bem confortáveis. Um tutorial com mais detalhes sobre o aplicativo ficará para um próximo post.

TiddlyWiki

Uma wiki pessoal que pode ser utilizada para o fim que o dono bem entender, como por exemplo, uma agenda, um catálogo, etc. No geral, sua sintexa se parece com a de uma wiki qualquer, mas podem ser adicionados alguns complementos para aumentar seu poder. Ficará para um próximo post também (pouco provavelmente o mesmo sobre mapas mentais) um tutorial sobre isso.

Q-Dir

Mais um aplicativo que ajuda a copiar arquivos. Quando aberto, são exibidas quatro pastas ao mesmo tempo (lado a lado), e arquivos podem ser movidos, copiados, …, de uma para outra. Exclusivo para Windows.

Hoje começa o zOMG beta.

Aparentemente a turma do Gaia vai liberando acesso ao zOMG aos poucos, baseado na data de cadastro do usuário (usuários mais antigos poderão acessar primeiro).

Para quem não sabe, zOMG é o sistema de batalha do Gaia Online, que está em desenvolvimento há mais de um ano, e agora, finalmente, está entrando em fase de testes.

Meus caros colegas leitores (ou não)…

Uma boa notícia para vocês (que já não deve ser mais uma novidade, mas…)…

Hoje, após um bom tempo longe do Gaia Online, resolvi dar uma olhadinha na minha conta, quando notei que na parte de games havia um link para o zOMG.

Para quem não sabe, zOMG é o nome que será dado ao “RPG” que citei muito tempo atras que estava em desenvolvimento. Em julho (meio atrasado eu hein!) ele finalmente entrou em estágio beta de desenvolvimento, e aparentemente será lançado no verão (o que pode ser meio abstrato, mas enfim…)

Mas isso já é uma boa notícia, eu acho…
Ainda no aguardo!!

Desculpem a ausência, mas estive meio ocupado por uns tempos:

As novidades são que finalmente passei em Cálculo I (o problema é que semana que vem terei que encarar o Magossi em Cálculo II, eu acho).

Outra novidade é que agora estou usando o Opera. No começo eu achava o Safari melhor (ele renderiza as páginas melhor e ele em si é bem mais “visualmente agradavel”). Mas depois de conhecer o Opera só pude dizer: Wow!

Confesso que comecei a usá-lo apenas porque o Firefox 3 me decepcionou (ao menos não achei ele tudo o que diziam que ele seria), e principalmente porque o Safari não roda em Linux, e agora estou usando meu Mandriva com uma certa frequência.

Claro que o Fernandinho tinha que perguntar “Como você faz para verificar seu Gmail, ou gerenciar seus links no Ma.gnolia?”.

Realmente, o Opera não é um “quebra-cabeça” como o Firefox,  onde você deve ir juntando as pecinhas para que ele funcione corretamente (precisa de extensão para baixar arquivos, extensão para renderizar as páginas, …).

Mas, que seja, o Opera já é um navegador completo, com um cliente de e-mail embutido, que pode ser usado para gerenciar o GMail bem (só cadastrar como uma conta IMAP que você consegue até aplicar os labels nos e-mails).

Mas, se preferir, o Opera suporta widgets, que são mini-aplicativos que você pode rodar no desktop. Dentre estes existe um que eu até gostei, e que pode ajudar nisso. É o multiGmail, que faz exatamente o que as extensões do Firefox fazem: informam se há ou não algum email.

Já para o Ma.gnolia,  como não encontrei nada que pudesse ajudar, resolvi fazer eu mesmo um widget. veja algumas imagens dele sobre a edição desse artigo.

Claro que ele ainda está em seus passos iniciais, mas acho que não demorará tanto para ficar pronto (ou vai, nunca se sabe).

Outras metas:

• Estudar a Oracle Call Interface e dar uma ajuda com a DDBI, já que há uma parte na interface com Oracle com um “return null;” que estava me intrigando.
• Passar esse semestre sem nenhum exame (difícil, considerando Cálculo II, mas é uma meta).
• Terminar meu primeiro artigo sobre E/S usando Tango (faz tempo que ele está como draft).
• Brincar mais um pouco com a biblioteca para comunicação serial (e/ou paralela?) em D.
• Terminar o sistema de comunicação instantânea que eu comecei.
• E, além de tudo isso, levar uma vida comum (essa parte está difícil).

Ajude a sustentar a Wikipédia e outros projetos, sem colocar a mão no bolso, e concorra a um Eee PC!
…e também a pen drives, card drives, camisetas geeks, livros e mais! O BR-Linux e o Efetividade lançaram uma campanha para ajudar a Wikimedia Foundation e outros mantenedores de projetos que usamos no dia-a-dia on-line. Se você puder doar diretamente, ou contribuir de outra forma, são sempre melhores opções. Mas se não puder, veja as regras da promoção e participe – quanto mais divulgação, maior será a doação do BR-Linux e do Efetividade, e você ainda concorre a diversos brindes!

Faz algum tempo já, mas só para informar:

Eu e o Diogo criamos um blog para mostrar o pouco que nós (não) sabemos sobre Haskell e programação funcional.

Então conforme nós formos aprendendo sobre a assunto postaremos por lá.

Não deixem de conferir…

Neste artigo vou falar um pouco mais sobre funções. Mais precisamente sobre como passar um número variável de parâmetros para elas.

Existem basicamente 3 (três) formas de se fazer isso:

1 – Passagem segura quanto ao tipo

Nesse tipo, a parte dos parâmetros com número variável é passada como um array. Sendo assim, apenas um tipo de parâmetro pode ser passado, mas em qualquer quantidade.

Considere o exemplo: 

void func(int[] p...)
{
    foreach(i, v; p)
        Stdout.formatln("p[{}] = {}", i, v);
}

Essa função pode ser usada como:
func()
func(10);
func(10, 15);

2 – Passagem estilo D

O porém de se usar a forma anterior é que apenas um tipo de argumento pode ser usado, e nem sempre isso é o desejado. Por isso existe um tipo, semalhante ao estilo C de se passar um número aleatório de parâmetros.

Considere o exemplo:

void func(...)
{
    foreach(i, arg; _arguments)
    {
        if(arg == typeid(int))
            Stdout.formatln("O argumento {} é um {} de valor {}", i, arg, *cast(int*)_argptr);
        else if(arg == typeid(float))
            Stdout.formatln("O argumento {} é um {} de valor {}", i, arg, *cast(float*)_argptr);
        _argptr += arg.tsize;
    }
}

Explanações

Quando é encontrado um “…” como argumento, você ganha duas variáveis ocultas: _arguments, um array de TypeInfo, e _argptr, um ponteiro void* para o primeiro argumento.´

Uma intância de TypeInfo é retornada pela expressão typeid, usada para RTTI (Run Time Type Information).

O método “tsize()” da classe TypeInfo retorna o tamanho do tipo.

Então basta ir tratando para cada tipo que você deseja que seja válido ou inválido:

assert(arg == typeid(char), "Tipo inválido");

Lembrando que um assert não termina o programa, simplesmente dispara um AssertError em Phobos ou um AssertException em Tango.

Só para frisar, se você estiver em um extern(C), você não ganha o _arguments.

3 – Tuplas

Esse tipo de passagem eu comecei a usar recentemente e, pelo menos para mim, já se tornou o melhor.

Uma tupla é um conjunto de coisas. Essas coisas podem ser tipos ou expressões, sendo que uma mesma tupla pode ter tipos e expressões, expressões de diferentes tipos, etc.

Esse tipo pode ser entendido como uma combinação dos dois anteriores, já que tuplas podem ser controladas como arrays, mas podem conter qualquer tipo em seu interior.

O único porém das tuplas é que seu tamanho deve estar disponível em tempo de compilação.

Para criar uma tupla, usa-se um template:

void func(P...)(P p)
{
    foreach(i, v; p)
        Stdout.formatln("p[{}] é um {} de valor {}", i, typeof(v).stringof, v);
}

Lembrando que void func(P...)(P p) é o mesmo que:

template func(P...)
{
    void func(P p)...
}

Lembrando que typeof retorna o tipo de uma expressão e a propriedade “.stringof” converte qualquer expressão para uma string. E quando eu digo expressão, dessa vez é a expressão mesmo. Por exemplo: (5 + 1).stringof não rende a string “6″, mas sim “5 + 1″.

Por hoje é só. Logo entrarei em mais detalhes sobre Tuplas (e templates no geral).

blogblogs tags:linguagem, programacao, d

No último post eu falei um pouco sobre as vantagens de se usar a a palavra lazy na passagem de parâmetros.

Então alguém pode pensar: “Legal, vou usar isso sempre”.
Mas não é bem assim que funciona.

Esse tipo de parâmetro tem a vantagem de ser avaliado apenas quando for usado, mas tem a desvantagem de ser avaliado sempre que for usado.

Confuso? Considere este exemplo:

/**
* testLazy.d - Exemplo de uso de parâmetros lazy.
*
 * Author: Christian Hartung < hartung [at] live.com >
 * Copyright: Domínio Público
 */
module testLazy;import tango.io.Stdout;
import tango.text.convert.Format;

const nrTests = 10;

void testLazy(lazy char[] str, int times)
{
for(int i = 0; i < times; i++)
 	Stdout(str())
}

void test(char[] str, int times)
{
    for(int i = 0; i < times; i++)
 	Stdout(str)
}

void makeTests(alias Test)()
{
int j;

for(int i = 0; i < nrTests; i++)
    {
 	Test(Format("{:d2} ", j++, 5), 10);
 	Stdout.newline()
    }

Stdout.formatln("j = {}", j)
}

void main()
{
    Stdout("Testando com lazy").newline
    makeTests!(testLazy)();

Stdout.newline();

Stdout("Testando sem lazy").newline;
    makeTests!(test)()
}

Neste exemplo, seria esperado que j = 10 ao final, mas usando lazy, j = 100.

Isso ocorre porque a cada vez que str é usado dentro de testLazy, todo o Format("{:d2} ", j++, 5) é avaliado, e o j++ é executado.

Já na função test str é avaliado apenas quando ela é chamada, ou seja, o j++ é avaliado apenas uma vez a cada chamada.

Ou seja, se você for usar seu parâmetro várias vezes dentro de sua função, o desempenho ganho com o uso de lazy pode ser perdido.

Outro problema que pode ocorrer:

int ops(bool b, lazy int i)
{
if(b)
return i();
    return 0;
}

Se você chamar essa função como:

i = 1;
test(false, i++);Stdout.formatln("Sem lazy, i = {}", i);

Você vai perceber que o i não foi incrementado! Afinal, o segundo parâmetro de test não foi avaliado nenhuma vez.

Ou seja, apesar do aumento no desempenho que o uso de parâmtros lazy pode proporcionar, eles devem ser usados com cuidado.

blogblogs tags:linguagem, programacao, d

Agora, voltando a falar um pouco sobre funções, um conceito que pode ser muito útil é chamado Lazy Evaluation (Avaliação preguiçosa, ou algo do tipo).

Veja o exemplo dessa função:

string call(bool b,  string s)
{
if(b)
return s;
else
        return "";
}

Como podem ver, essa função (inútil, mas é apenas para demonstrar) retorna seu segundo argumento (s) se seu primeiro argumento (b) for verdadeiro.

Um problema com isso é que seu segundo argumento é sempre avaliado. Imaginando que ele seja uma função relativamente complexa, como a função “convert”, da classe Layout (função parecida com string.Format do C# ou String.format do Java), isso seria um desperdício de processamento) em casos como:

call(false, Format("{}", i));

(Format é uma “instância global” de Layout para char’s, definida em tango.text.convert.Format
Uma solução para isso seria passar um ponteiro para uma função ou um delegate (ponteiro para um membro, ou uma função interna) que faz a formatação:

call(false, { return Format("{}", i); });

Com isso, seria necessário trocar return s; em call por return s();.

Claro que é meio incomode ter que usar a sintaxe para delegates literais sempre que se quiser esse tipo de otimização, por isso foi criado o conceito de argumento preguiçoso (lazy), que basicamente é convertido para um delegate. Veja a função:

string lazyCall(bool b, lazy string s)
{
if(b)
        return s();
else
        return "";
}

Obs.: string é um alias que eu criei para um array de char’s ou invariant(char)’s, dependendo da versão da linguagem ou biblioteca sendo usada. Ele é definido como:

static if(!is(string))
{
static if(is(typeof(object.Object.toString) R == return))
        alias R string;
}

Esse trecho verifica se já não existe um tipo string já definido (lembrando que ele foi adicionado ao módulo “object” para Phobos v2). Se não existir, ele pega o tipo que o método toString (método existente em Phobos e adicionado à Tango na versão 0.99.4 Frank – antes disso era toUtf8 da classe Object (classe esta existente em Phobos e em Tango no módulo object) em R e cria um alias para esse tipo como string. Uma observação: não vá confundir o typeof em D e em C#. Em C#, você usaria typeof(tipo) para retornar uma instância de System.Type para o tipo (ou algo do tipo) passado. Em D, você usa typeof(variável) para retornar o tipo da variável.

static if é uma forma de compilação condicional da linguagem. A condição dessa instrução é avaliada em tempo de compilação, e não é criado um novo escopo para seu bloco de instruções.

Esta forma de is é para verificar, em tempo de compilação, a validade ou não de algum tipo. Mais informações sobre isso futuramente (assim espero!).

Para demonstrar a eficiência disso, criei este simples benchmark:

module Lazy; import tango.io.Stdout;

import tango.text.convert.Format;

import tango.time.StopWatch;const j = 10000000u; static if(!is(string))

{

static if(is(typeof(object.Object.toString) R == return))

alias R string;

}

string lazyCall(bool b, lazy string s)

{

if(b)

return s();

else

        return "";

}

string call(bool b,  string s)

{

if(b)

return s;

else

        return "";

}

private void benchmarkImpl(alias fn)(bool b)

{

StopWatch e;

Stdout.formatln("Executando {} vezes com b = {}", j, b);

e.start();

for(uint i = 0; i < j; i++)

fn(b, Format("{}", i));

Stdout.formatln("Tempo de execução: {}", e.stop()).newline;

}

void benchmark(alias fn)()

{

benchmarkImpl!(fn)(true);

benchmarkImpl!(fn)(false);

}

void main()

{

Stdout("lazyCall").newline;

benchmark!(lazyCall)();

Stdout("-----------------------").newline;     Stdout("call").newline;

benchmark!(call)();

}

Coloque isso em um arquivo chamado Lazy.d e compile (tomara que compile).

Acho que a única novidade nesse código é o private void benchmarkImpl(alias fn)(bool b).

Então, vejamos o que é isso:
private, assim como para classes, torna a função benchmarkImpl visível apenas para o módulo Lazy (lembrando que em OOP em D, campos/métodos privados são visíveis para todo o módulo, não apenas para a classe, semelhantemente ao Delphi – mas não tente colocar strict private para mudar isso).

Fora isso, sobrou apenas a parte legal da declaração:
void benchmarkImpl(alias fn)(bool b).

Isso é equivalente a declarar um template da seguinte forma:

template benchmarkImpl(alias fn)

{

void benchmarkImpl(bool b) { ... }

}

O alias na declaração do template, neste caso, aceita símbolos globais no geral (no caso, uma função).

Usando Phobos (a biblioteca padrão), o exemplo ficaria mais ou menos assim:

module Lazy;import std.perf;

import std.stdio;

import std.string;

const j = 10000000u;

static if(!is(string))

{

static if(is(typeof(object.Object.toString) R == return))

alias R string;

}

string lazyCall(bool b, lazy string s)

{

if(b)

return s();

else

 	return "";

}

string call(bool b,  string s)

{

if(b)

return s;

else

 	return "";

}

private void benchmarkImpl(alias fn)(bool b)

{

auto e = new PerformanceCounter();

writefln("Executando %s vezes com b = %s", j, b);

e.start();

for(uint i = 0; i < j; i++)

fn(b, format("%s", i));

e.stop;

writefln("Tempo de execução: %s", e.milliseconds / 1000.0);

}

void benchmark(alias fn)(){
benchmarkImpl!(fn)(true);
benchmarkImpl!(fn)(false);
}

void main(){
writefln("lazyCall");
benchmark!(lazyCall)();

writefln("-----------------------"); writefln("call");
benchmark!(call)();
}

blogblogs tags:linguagem, programacao, d

O D Shared Software System é um “sistema de compartilhamento de software” criado para facilitar a utilização de bibliotecas de terceiros, e (o que eu uso com mais frequencia) como um sistema para automatizar a compilação de softwares.

Suponha que você esteja escrevendo uma biblioteca. Esta provavelmente terá vários módulos. Utilizando simplemente o compilador, você teria que especificar todos os módulos. Por exemplo:
dmd -c Soma.d Mul.d Sub.d Div.d
(-c para não linkar, apenas compilar e não linkar – não gerando o executável)

Quando seu aplicativo vai crescendo, começa a ficar incomodo listar todos os arquivos (ou criar um script, como um makefile e especificá-los). É aí que entra uma ferramenta como o DSSS.

Continuando o exemplo anterior, teríamos os módulos:

module matematica.Soma;
int soma(int a, int b)
{
    return a + b;
}

//--------------------------------module matematica.Sub;
int sub(int a, int b)
{
    return a - b;
}

//--------------------------------module matematica.Mul;
int mul(int a, int b)
{
    return a * b;
}


//--------------------------------

module matematica.Div;
int div(int a, int b)
{
    if(b == 0)
        return a;
    return a + b;
}

//--------------------------------

Para tornar essa biblioteca “usável” com o DSSS, você simplesmente deve criar um script chamado “dsss.conf” na raíz de seu aplicativo:

- dsss.conf
- matematica
- - Soma.d
- - Sub.d
- - Mul.d
- - Div.d

O script se assemelha à um arquivo .ini do Windows:

name=matematica[matematica]
type=library
target=matematica

Esse script criará um sistema chamado matematica (se ele for instalado via DSSS, terá esse nome), que terá uma biblioteca compilada com os arquivos dentro do pacote “matematica”, e que se chamará “matematica.lib” no Windows e “libmatematica.a” em sistemas POSIX.

No geral, não é necessário informar o tipo, mas eu prefiro, só por documentação.

Agora, basta entrar no diretório que contém esse script e digitar no console dsss build (claro que isso depois de configurar o PATH, como já é de costume). Se houver documentação das funções no formato DDOC, você pode usar dsss build –doc
Se desejar instalar essa biblioteca, para que possa ser usada por outros sistemas, basta usar dsss install.

Se desejar adicionar um binário qualquer à sua biblioteca (por exemplo, main.d no diretório raíz):

- dsss.conf
- matematica
- - Soma.d
- - Sub.d
- - Mul.d
- - Div.d
- main.d

Basta adiciná-lo ao script dsss.conf:

name=matematica[matematica]
type=library
target=matematica

[main.d]type=binary
target=testmatematica

Desta vez, além da biblioteca, também será gerado um executável (type=binary) chamado testmatematica(\.exe)?