Quando usar def no Groovy?

Estou desenvolvendo o Groovy há um tempo e estou me perguntando com que frequência devo usar o casting dinâmico def. Um colega de trabalho meu acredita que devemos usá-lo sempre, pois ajuda o Groovy de alguma forma que eu não entendo.

Atualmente, ao declarar tipos e argumentos de retorno de método, gosto de declarar deliberadamente quais objetos devem ser inseridos e cuspidos (para facilitar a leitura do código e eu venho de um plano de fundo Java que faz sentido para mim) exemplo:

String doSomething(String something){
    //code
}
// vs
def doSomething(def somthing){
    //code
}
// vs 
def doSomething(somthing){
    // code
}

Então, acho que minha pergunta é apenas uma preferência de quando usar defou há uma vantagem real em usá-lo o tempo todo? (Adicionei o último exemplo porque achava que ele se encaixa na pergunta como uma opção viável para o Groovy)

Como boa prática de programação (mesmo de script), sempre considere especificar um tipo definido (embora não necessariamente concreto) para uma variável. Use defapenas se não houver um tipo definido aplicável à variável.

Como o OP conhece Java, não é diferente de especificar um tipo de Object(embora pareça haver uma pequena diferença ). A resposta a esta pergunta não será diferente de responder a uma pergunta como: "por que nem sempre usar o Objecttipo em Java?"

Ser o mais definitivo possível sobre os tipos reduz as chances de erros e até serve como auto-documentação. Considerando que, se alguém estiver implementando deliberadamente uma lógica dinâmica, o uso defpoderá fazer muito sentido. Essa é, de fato, uma das maiores forças do Groovy; o programa pode ser digitado dinamicamente ou estaticamente como se precisa! Só não deixe a preguiça ser a razão para usar def;-)

Por exemplo, esse método faz sentido com um tipo de argumento definido e um tipo de retorno:

// def val or Object val, opens up the possibility
// of the caller sending a non-numeric value 
Number half(Number val) {  
    val/2
}

enquanto esse método faz sentido com o tipo def

// I'd let them pass an argument of any type; 
// type `Object` makes sense too
def getIdProperty(def val) {   
    if(val?.hasProperty('id')) {
        // I don't know the type of this returned 
        // value and I don't really need to care 
        return val.id            
    }
    else {
        throw new IllegalArgumentException("Argument doesn't have an 'id' property")
    }
}

Sempre que o código que você está escrevendo for usado por outras pessoas como uma API pública, você sempre deve favorecer o uso de digitação forte, isso ajuda a tornar o contrato mais forte, evita possíveis erros de digitação de argumentos passados, fornece melhor documentação e também ajuda o IDE com conclusão de código. Sempre que o código for apenas para seu uso, como métodos particulares ou quando o IDE puder inferir facilmente o tipo, você estará mais livre para decidir quando digitar ou não.