Recentemente eu tenho pensado nisto:

Usar um martelo de borracha para derrubar parede de concreto? E dinamite para cortar torta de banana? A resposta só pode ser uma: NÃO!

Cada ferramenta tem o seu propósito. Use a melhor para cada tarefa.

Aproveitando que não curto muito o carnaval, vou aproveitar o tempo para aprender algo mais sobre algumas linguagens dinâmicas:

As tradicionais

Phyton

Ruby

O novo jedi

É uma que não é tão conhecida, mas que sem dúvida não demora a entrar no rol das grandes linguagens.

BOO | A linguagem amigável aos pulsos

O BOO se auto-intitula a linguagem amiga dos pulsos, e já nas primeiras linhas em BOO que você escreve dá para notar que não é brincadeira.

Apesar de extremamente poderosa chega a ser ridiculamente simples de se programar.

Vejo um longo e promissor futuro para o BOO.

Mas por que isto?

Quando eu fui fazer umas brincadeiras com jQuery eu rapidamente vi uma correlação da forma de usar o jQuery com os lambdas e o Linq do .Net 3.5.

Depois de um tempo programando em jQuery eu sou muito sincero em dizer que meus códigos em C# melhoraram por usar de forma mais livre lambdas e Linq.

Quando ocorreu a Semana de Interoperabilidade com o Mono Brasil o Binhara em um dos webcasts começou a mostrar os benchmarks para as implementações do Phyton e Ruby em .Net (respectivamente IronPhyton e IronRuby).

Neste momento me deu um insight, já que na empresa somos Gold Partner Microsoft e tudo que é novo sai majoritariamente em C#.Net:

Casamos com o .Net (Microsoft ou Mono), mas dane-se a linguagem.

O C# é ruim? Se alguém me falar isto vai apanhar com um gato morto até o gato voltar a miar.

Ele é excelente, e eu adoro programar em C#, mas tem momentos em que ele não é a ferramenta mais adequada para o trabalho.

Eu vejo o C# como sendo a linguagem certa para o core da aplicação, justamente por ser uma linguagem de frente da Microsoft e assim proteger o investimento em código.

Mas tem coisas que não há como fugir. Para determinadas tarefas há linguagens mais ágeis que ela.

Como uma linguagem pode ser mais ‘ágil’?

O exemplo clássico da página do Ruby.

Dois arrays com cidades. Um com todas elas e outro com as que você já visitou. Como saber quais faltam?

Em C# usando lambdas e Linq fica assim (assumindo uma aplicação console):

static void Main(string[] args)
{
    var cities = new string[] {
        "London",
        "Oslo",
        "Paris",
        "Amsterdam",
        "Berlin"
    };

    var visited = new string[] {
        "Berlin",
        "Oslo"
    };

    var not_visited = cities
        .Where((city) => { return !visited.Contains(city); })
        .ToArray();

    Console.Write("I still need to visit ");
    Console.Write("the following cities: ");
    Console.Write(string.Join(" ", not_visited));
}

Se for da forma tradicional, para gerar o array not_visited ficaria algo assim:

static void Main(string[] args)
{
    string[] cities = new string[] {
        "London",
        "Oslo",
        "Paris",
        "Amsterdam",
        "Berlin"
    };

    string[] visited = new string[] {
        "Berlin",
        "Oslo"
    };

    List not_visited_list = new List(cities);

    foreach (string city in visited)
       not_visited_list.Remove(city);

    string[] not_visited = not_visited_list.ToArray();

    Console.Write("I still need to visit ");
    Console.Write("the following cities: ");
    Console.Write(string.Join(" ", not_visited));
}

Em Ruby é só subtrair um array do outro (exemplo descaradamente copiado do site oficial do Ruby).

# Ruby knows what you
# mean, even if you
# want to do math on
# an entire Array
cities  = %w[ London
              Oslo
              Paris
              Amsterdam
              Berlin ]
visited = %w[Berlin Oslo]

puts "I still need " +
     "to visit the " +
     "following cities:",
     cities - visited

Consegue entender onde quero chegar?

Bom ziriguidum neste carnaval para você.