Os prefixos de tipo e escopo valem convenções de nomenclatura?

Recentemente, iniciando meu primeiro trabalho como desenvolvedor de software, fiquei surpreso ao saber que não precisava seguir nenhuma convenção de nomes no meu código. O código escrito por grupos trabalhando em outros projetos maiores seguiu as convenções de nomenclatura, mas desde que fui chamado para escrever um novo aplicativo independente, a sensação era de que isso não importava especialmente. Foi a última das minhas preocupações, então peguei a convenção existente e segui em frente.

int nTickCount  
bool bConnected  
object[] m_aItems  
fSum += fWeight * fValue  
class cManager  
enum etSystemStates  
etSystemStates eState   
cManager.cs

Mas vale a pena? Acho difícil julgar o efeito líquido que esse tipo de convenção de nomenclatura tem sobre a compreensão e a detecção de erros, mas, visualmente , parece meio feio. Além disso, ter todas as classes e arquivos do projeto chamado cSomething parece bastante estúpido.

Não tenho a ilusão de que seja um problema remotamente grande quando comparado a coisas que fazem uma diferença óbvia, como os algoritmos e arquiteturas que você emprega. Mas qualquer convenção que afete todas as linhas de código que escrevo parece valer a pena.

Qual você acha a convenção de nomenclatura mais elegante e eficaz, se é necessário usá-la? Denota tipo e / ou escopo?

Joel Spolsky escreveu um artigo sobre por que a notação húngara existe e para que ela foi criada pode ajudar a responder sua pergunta.

Prefixos como tbl para uma tabela de banco de dados, int para um número inteiro etc. geralmente não são úteis - é trivial descobrir o que é o contexto e as ferramentas de desenvolvimento nesses casos. Algo como imp para medições imperiais e encontrado para métricas faz muito mais sentido, porque, caso contrário, você só pode ver que eles são números de ponto flutuante.

area = width * height

parece perfeitamente bem enquanto

impArea = metWidth * impHeight

mostra logo que algo está errado.

Pessoalmente, apenas uso nomes de variáveis ​​descritivos. $ number_of_items é obviamente uma contagem inteira. $ input_file_handle, $ is_active e $ encrypted_password têm tipos óbvios em termos de tipo de dados de idioma e tipo semântico.

O que você está descrevendo é chamado de notação húngara . Era uma vez considerada uma prática recomendada, mas geralmente é desaprovada agora.

O artigo da Wikipedia contém uma seção sobre seus prós e contras.

Sim, os prefixos podem ser úteis, mas tenho algumas sugestões:

Se toda a sua equipe estiver usando as mesmas convenções, elas se tornarão muito mais úteis. Usá-los por conta própria é menos útil.

Em idiomas fortemente tipados estaticamente, não copie apenas o tipo de uma variável. Por exemplo, "bSubscribe" é um nome ruim para uma variável booleana em C # ou Java, porque seu IDE já sabe que tipo é. Em C, por outro lado, que não possui um tipo booleano, essas informações seriam úteis.

Em C # e Java, você pode considerar um prefixo para mostrar que um objeto pode ser nulo. Ou que uma string foi escapada por html. Ou que representa uma expressão regular ou uma instrução sql. Ou que uma matriz foi classificada. Use sua imaginação.

Basicamente, é uma questão de se perguntar o que você gostaria que um nome de variável lhe dissesse, e isso depende muito do domínio e do idioma em que você está trabalhando.

Existem alguns "estilos" diferentes de convenções de nomes por aí, e a maioria deles tem algum valor em tornar o código compreensível.

O que é MUITO mais importante é: use nomes descritivos para variáveis ​​e funções. No seu exemplo com "soma", "peso" e "valor", convém dar nomes mais significativos: "totalCost", "lumberWeight", "lumberValuePerOunce" (estou fazendo algumas suposições aqui)

Acho convenções como anexar nomes de variáveis ​​com um caractere que significa que o tipo é bastante perturbador na maioria dos idiomas modernos.

A maioria dos desenvolvedores .NET segue as Diretrizes de Design da Microsoft ( http://msdn.microsoft.com/en-us/library/ms229042.aspx ), que são bastante semelhantes às do Java (a principal diferença é que a Microsoft prefere Pascal Case para nomes de membros, enquanto Java favorece o camelo).

Além disso, eu diria que seu exemplo de código é muito menos legível por causa do ruído extra que você adicionou.

Acho que, na maioria das vezes, o guia de estilo de codificação do Google é muito bom. Desde que lhe disseram que você pode usar qualquer estilo que você gosta, acho que você deve começar examinando isso e escolhendo e escolhendo.

A prefixação de nomes de variáveis ​​com tipos de dados (especialmente tipos de dados primitivos) aumenta o ruído visual, bem como o risco de que uma alteração pequena, de outra forma, se torne uma renomeação do big bang.

Quanto ao primeiro ponto, "intStudentCount" é realmente mais claro do que, por exemplo, "numberOfStudents"? "InvoiceLineItems" não seria pelo menos tão informativo quanto "aobjItems". (O tipo de dado deve ser sobre o significado dos dados no domínio do problema, não a representação de baixo nível.)

Quanto ao segundo ponto, o que acontece quando, por exemplo, uma seleção prematura de int é substituída por longa ou dupla? Pior ainda, o que acontece quando uma classe concreta é refatorada em uma interface com várias classes de implementação? Qualquer prática que aumenta a carga de cenários realistas de manutenção parece questionável para mim.

Também pode depender do motivo pelo qual você está prefixando o nome, em vez de apenas o prefixo.

Como exemplo, costumo usar um prefixo de 1-2 letras para os nomes dos controles em um formulário. Não é porque eu não sei que o compilador encontrará facilmente a classe certa para o botão (como exemplo), mas eu tendem a criar formulários grandes primeiro e depois escrever a maior parte do código posteriormente.

Ter um prefixo de bt para os botões facilita encontrar o botão certo depois, em vez de ter muitos nomes misturados.

Porém, não uso prefixos para nomear variáveis, nem para o tipo (que geralmente não é útil de qualquer maneira), nem para o significado, contexto ou unidade (que é a idéia original por trás da notação húngara).

Na minha opinião, depende do idioma e do tamanho do projeto. Eu nunca fui tão longe a ponto de usar prefixos de tipo em todas as minhas variáveis, mas você deseja nomeá-las de maneira clara.

Em um idioma estaticamente digitado, como o que você está usando, quanto mais confortável me sinto com o sistema de tipos, menos importante a Notação Húngara se torna. Portanto, em Java ou C # e, especialmente, em Haskell, eu nem pensaria em adicionar esses prefixos, porque suas ferramentas podem indicar o tipo de qualquer expressão e detectam a maioria dos erros resultantes do mal-entendido de um tipo.

Os prefixos geralmente fazem sentido para os objetos, por exemplo, em um formulário no qual você pode ter 20 caixas de texto chamando todos eles tbSomething.

No entanto, principalmente eu não acho que vale a pena, especialmente para tipos de valor.

Por exemplo, suponha que você tenha:

short shortValue = 0;
//stuff happens

Meses depois, você descobre que precisa alterá-lo - um curto não é grande o suficiente. Agora você tem:

int shortValue = 0;
//stuff happens

A menos que você também altere o nome da variável (mais risco de quebrar o código do que alterar o tipo nesse caso), agora você tem um código confuso.

É melhor ter um nome que descreva o que ele contém:

int loopCounter = 0;
//stuff happens

Se mais tarde, isso precisa mudar para um longo: não há problema.

Talvez haja mais argumentos para essas convenções em linguagens de tipo dinâmico ou naquelas sem um IDE.

Eu sempre fui propenso a usar uma abreviação de 2 a 4 caracteres para o tipo na frente da própria variável. Às vezes, parece tedioso, mas quando você trabalha com tipos ou situações de dados complexos, isso se torna benéfico. Eu acho que se enquadra na categoria de estojo de camelo inferior.

Olhando para o seu exemplo acima, seria ligeiramente reformulado para ser:

int intTickCount;
bool boolConnected;
object[] aobjItems;

As matrizes sempre têm um a na frente do tipo para designar a matriz. Isso também me permite agrupar instâncias de variáveis ​​semelhantes. Por exemplo, eu posso usar ...

taStore.Fill(dtStore);

... o que indica que meu Store TableAdapter está preenchendo o Store DataTable.

Eu sempre tentei aderir ao princípio básico de que prefixos e / ou sufixos devem ser inseridos somente quando tornar o código mais legível (como no inglês comum).

Quanto menos enigmático, melhor ...

Por que ter um método como este:

public boolean connect( String h, int p );

Quando você pode ter algo parecido com isto:

public boolean connect( String hostName, int port );

Além disso, hoje os IDEs realmente possuem uma ferramenta poderosa para refatorar variáveis ​​(especialmente Java), nomes de métodos, classes, etc. A idéia de dizer o máximo de informações com o mínimo de caracteres é antiquada.