Temos um produto de longa vida há cerca de 8 anos. Com o tempo, os nomes dos conceitos e entidades mudam. Devemos colocar o trabalho para renomear todas as tabelas e colunas da base de código e do banco de dados para corresponder a esses novos nomes?
Existe um estudo feito sobre essa ou algumas práticas recomendadas publicadas?
obrigado
Respostas:
A incompatibilidade entre nomes internos e externos definitivamente cheira. Como Rinzwind aponta, os homofones e sinônimos cheiram pior.
A verdadeira pergunta que você precisa responder é: Qual é a relação custo / benefício ao fazer a alteração?
O custo de não mudar é uma curva de aprendizado mais acentuada para novos membros da equipe e maior probabilidade de erros futuros. O custo da mudança é o tempo óbvio envolvido, uma nova curva de aprendizado para os veteranos do projeto e a possibilidade de novos bugs.
Se você espera ter um número relativamente grande de novos membros da equipe, é mais provável que faça sentido fazer a alteração. Se você não espera rotatividade, a equipe atual não costuma ficar confusa e a equipe está satisfeita com o status quo, então não faz sentido renomear as coisas.
Se o código estiver em vigor por um longo tempo e houver novos desenvolvedores trabalhando nele, eu faria as alterações.
Pode ser muito confuso e demorado para um novo desenvolvedor entrar em um projeto e achar que os nomes das entidades são enganosos.
Há também o argumento válido de ... Se não estiver quebrado, não conserte.
Com relação à sua segunda pergunta, não conheço estudos publicados ou práticas recomendadas. Com relação à primeira pergunta, posso oferecer algumas observações da experiência pessoal com um produto de longa duração semelhante, onde os nomes 'interno' e 'externo' são às vezes diferentes.
Os nomes que eu realmente gostaria de corrigir são os "homofones", onde um nome é usado interna e externamente para coisas diferentes . Isso pode ser realmente confuso, principalmente se as duas coisas não forem completamente diferentes (de modo que o contexto ajude a desambiguar). Um exemplo (abstrato) disso na minha experiência pessoal é onde internamente você tem algo como um Fooque é uma coleção de múltiplos FooEntity; externamente, apenas o último é visível e é chamado de "Foo". Demorei um pouco para descobrir que, quando o manual do cliente estava falando de vários “Foo”, na verdade significava múltiplos FooEntity(em um único Foo), se isso ainda faz algum sentido para você.
Em segundo lugar, eu gostaria de corrigir quaisquer “sinônimos” em que algum nome externo tenha sido usado internamente. Como em nomes de variáveis, partes de nomes de métodos / funções e assim por diante. Isso geralmente acontece quando os desenvolvedores implementam algo diretamente da descrição dos requisitos do cliente e esquecem de "traduzir" os nomes. Quando isso acontece, o nome 'errado' também tende a se espalhar, porque outros desenvolvedores copiam / colam parte desse código para usar como modelo para o novo código, por exemplo. Esses sinônimos não são tão confusos, mas podem ser irritantes porque, se você estiver pesquisando no código por alguma referência a Barvocê, tenha em mente que algumas partes podem se referir a ele comoQux, então você precisa pesquisar duas vezes. (Isso pode ser pior em idiomas de tipo dinâmico do que nos estáticos, já que você precisa procurar partes do nome de variáveis / funções / ... em vez do nome de seu tipo.) Quanto ao caso inverso de “sinônimos ”, Onde um nome interno foi usado externamente: isso tende a não acontecer com tanta frequência, pois os funcionários do suporte ao cliente etc. geralmente têm menos consciência dos nomes internos, embora eu assuma que é confuso para os clientes quando isso acontece.
Se você puder evitar ou consertar pelo menos as duas situações acima, não tenho certeza se você deve ir tão longe quanto tornar todos os nomes internos iguais aos externos. Provavelmente, há uma boa razão pela qual os nomes internos também não foram alterados quando o nome externo foi diferente do nome interno. Na minha experiência pessoal, esse bom motivo é a necessidade de oferecer suporte a versões mais antigas do produto; pode tornar-se difícil mesclar uma correção de bug de uma versão de limpeza antes dos nomes para a versão mais recente, se for necessário alterar muito código.
É um problema bastante comum. Vários projetos nos quais trabalhei usam nomes de código em vez de nomes de produtos (que podem não ter sido decididos naquele momento) e usam terminologia bastante diferente no código do que o que é exibido para o usuário. Eu provavelmente deixaria as coisas como estão, a menos que você esteja passando por uma redefinição maciça do código ou se houver algo específico causando problemas. Não adianta perturbar o carrinho de maçã. Além disso, quem dirá que daqui a cinco anos não haverá mais mudanças? E então você teria que passar pela renomeação novamente. E não se esqueça, isso também afeta qualquer documentação de código separada que você possa ter (APIs publicadas), o que pode ser um problema particularmente caro se for impresso (cópia impressa).
Acho que muitas vezes as entidades de "marketing" não correspondem exatamente às entidades internas. Nesses casos, faz mais sentido introduzir uma entidade em um nível diferente de abstração, o que torna as diferenças de terminologia um ponto discutível.
Por exemplo, temos um modelo que representa uma hierarquia. Cada nível na hierarquia tem um termo associado a ele, com base em como a hierarquia é usada para modelar relacionamentos do mundo real, mas internamente não há uma diferença no comportamento de um nível da hierarquia para o próximo. A terminologia é essencialmente apenas um nome para esse nível na hierarquia; portanto, para um nó específico da árvore, o nome simplesmente descreve o que é o nó; não prescreve nenhum comportamento específico.
Além disso, a árvore possui várias raízes, portanto, existem vários nós sem um pai. Embora conceitualmente exista uma raiz (ela representaria essencialmente o universo), e incluí-la no modelo seria muitas operações muito mais simples, não há "termo de marketing" para ela.
Obviamente, componentes diferentes em nosso sistema usam terminologia diferente. Eles foram desenvolvidos em momentos diferentes por equipes diferentes, e não temos controle sobre todos eles. Na verdade, em algum momento, alguém adicionou ou removeu um nível em um componente e, portanto, os outros níveis são alterados um em relação ao outro. Os mesmos três níveis são representados por A, B e C em um componente, mas como B, C e D em outro.
Dar um passo adiante na abstração e simplesmente modelar tudo como um "nó" ou algo igualmente genérico torna esses tipos de modelos muito mais fáceis de serem discutidos. Cada nó sabe qual é o seu "termo de marketing" e o tipo que representa um termo de marketing específico pode saber o que esse termo significa em cada contexto.