¿Hasta qué punto debemos cambiar el nombre del código y los datos cuando cambian las nomenclaturas de los usuarios finales?

Hace mucho tiempo agregamos una función en la que nuestros usuarios podían "Aceptar" una imagen después de agregarla a una cola de flujo de trabajo. Resulta que usamos el término incorrecto y los usuarios realmente "aprueban" la imagen.

Cambiar Aceptar para aprobar en nuestra interfaz es fácil, solo reemplace una palabra. Pero programamos todas las capas con la palabra "aceptar", desde el nombre de la clase CSS hasta los valores de la base de datos.

• La clase CSS que activa el botón en verde: ".accepted";
• El método modelo que verifica y vincula el atributo de clase en el nodo DOM: "isAccepted";
• Atributo de estado de JavaScript: matriz con "sin revisar", "aceptado" y "publicado";
• Columna de estado de MySQL: ENUM con "no revisado", "aceptado" y "publicado";
• Nombres de prueba;

Es trivial (especialmente cuando tiene pruebas) reemplazar la mayoría de los casos de aceptar para aprobar. Un poco más difícil es migrar los datos, especialmente porque deben sincronizarse con la implementación.

Este caso específico es simple, pero me he enfrentado a casos similares, pero más complejos, durante mi carrera. Cuando también se cambia el nombre de un archivo y la implementación se realiza en docenas de servidores, o cuando el almacenamiento en caché de proxy, memcached y mysql están involucrados

Dejar "aceptado" en cualquier otra capa, excepto la interfaz, es una mala idea, ya que los nuevos programadores que se unen al equipo podrían no conocer las razones históricas que llevaron a esta decisión, y si bien aceptar -> aprobar son palabras cercanas en términos de significado, si es que fue renombrado como "en cola para la próxima reunión de estado gerencial", ciertamente no tendría ningún sentido. Y parece que si nos comprometemos aquí y allá, en algunas iteraciones, los conceptos de la interfaz de usuario no tendrán relación con los componentes internos del sistema, y ​​ciertamente no quiero trabajar en un sistema donde la mitad de la salida no tiene conexión con sus entrañas.

Entonces, ¿siempre cambias el nombre de todo cuando lo necesitas? Si esto te sucedió y decidiste que la compensación no valía la pena, ¿volvió a morderte? ¿Es suficiente el comentario de código o la documentación del desarrollador para evitar este problema?

Para mí, definitivamente es mejor cambiar todo lo relacionado con el elemento en cuestión.

Es una forma de degradación del código, y aunque 1 elemento que no se cambia puede no ser un gran problema, establece el tono para la base del código.

También podría generar confusión en el futuro y dificultar que los nuevos desarrolladores entiendan el código base / dominio.

Por el contenido y las etiquetas de la pregunta, supondré que está utilizando un lenguaje omnipresente.

En mi experiencia, UL es excelente, pero, como mencionó, puede llevar a tareas de mantenimiento adicionales a medida que evoluciona el lenguaje. Esto, en sí mismo, no es algo malo. Claro, es inconveniente, pero también se espera.

Lo que típicamente he hecho (y visto hecho) es:

• Refactorización inicial de 1 disparo: refactorice todas las capas de la aplicación para adoptar el lenguaje actualizado; o
• registrar la deuda técnica: puede cambiar el código del usuario de inmediato y luego registrar las tareas de la deuda técnica para alinear el resto de las capas de la aplicación con el lenguaje actualizado. Esto generalmente resulta en un puñado de tareas aburridas (pero manejables). (Perfecto para las 5pm!)

Creo que la clave aquí es que lo que está describiendo es deuda técnica y debe reconocerse como tal.

He tenido gerentes que han argumentado que no deberíamos perder el tiempo en tareas tan triviales que no agregan ninguna funcionalidad visible. Esto es cuando la analogía de la deuda realmente es útil. Todo se reduce a esto:

El equipo eligió hacer DDD con lenguaje ubicuo. Alejarse de este enfoque al dejar el código en un estado inconsistente agrega confusión y elimina muchos de los beneficios que proporcionan DDD y UL. En términos de gerente, agrega costos al proyecto. El código se vuelve más difícil (costoso) de administrar y más confuso para los nuevos desarrolladores (costoso).

Es posible que desee ver las opciones de localización (l10n). Si bien puede no parecer tan drástico como pasar del inglés al español, se trata de un término diferente para el mismo concepto. Si esto parece suceder comúnmente, usar l10n puede permitirle cambiar rápidamente lo que se muestra en la interfaz de usuario sin tener que cambiar el término utilizado en el código.

Con eso en su lugar, solo use los términos en su código que son los más entendidos. Elija nombres del dominio como los desarrolladores lo conocen y podrían esperarlo.

Como lo describe adecuadamente, el seguimiento de los cambios en la nomenclatura del usuario final en cada parte de la fuente es una gran inversión. Sin embargo, definitivamente vale la pena, especialmente para un producto de larga vida desarrollado por una infraestructura completa (con línea directa, probadores, etc.)

El seguimiento de la nomenclatura del usuario final en la fuente es una inversión porque hay muchos tipos de componentes donde aparece y no hay una varita mágica que funcione simultáneamente en todos estos componentes. Quizás desarrollar una varita mágica, componente tras componente, sea una inversión interesante que pueda diluir durante la vida útil del proyecto.

Trabajé en una base de código de 30 años donde la diferencia entre la nomenclatura del usuario final y la nomenclatura interna creció especialmente. Aquí hay algunos inconvenientes de esta situación, que se suman a la sobrecarga del trabajo de todos:

1. En ausencia de una política adecuada, el nuevo desarrollo tiende a utilizar la nomenclatura actual del usuario final. Por lo tanto, el mismo concepto puede tener dos o más nombres en diferentes componentes. Dado que los componentes interactúan entre sí, esto da como resultado varios nombres sinónimos que existen simultáneamente en algunas partes locales del código.

2. Cuando se llama a la línea directa / mesa de ayuda, escriben una historia de usuario utilizando la nomenclatura del usuario final. El desarrollador a cargo de solucionar el problema debe traducir la nomenclatura del usuario final para que coincida con la nomenclatura de origen. Por supuesto, no está archivado, y por supuesto es un desastre. (Ver 1.)

3. Cuando el programador depura el código, quiere establecer puntos de interrupción en las funciones relevantes. Es difícil encontrar las funciones apropiadas si la nomenclatura del usuario final y la nomenclatura fuente no están de acuerdo. Incluso puede ser difícil o imposible estar seguro de que una lista de las funciones relevantes está completa. (Ver 1.)

4. En ausencia de una política adecuada, el mantenimiento de la fuente utilizando una nomenclatura obsoleta ocasionalmente pondrá esta nomenclatura obsoleta frente a los usuarios nuevamente. Esto produce una mala impresión y causa sobrecarga.

Ya rastreé durante dos días el lugar donde se leen algunos datos de la base de datos y se inyectan en algún componente de esta base de código. Porque si ni yo ni nadie de la empresa con la que trabajé fue capaz de encontrar un nombre que llevara a este lugar, finalmente lo descarté y decidí buscar otra solución a ese problema.

Si bien costar más de [1] dos días de mantenimiento sin producir nada (sin conocimiento, sin solución, nada) es probablemente tan malo como puede ser, las discrepancias entre la nomenclatura de usuario y la nomemclatura de origen agregan una sobrecarga a muchas tareas rutinarias en el mantenimiento de un software.

Es importante señalar que el costo general aumenta con la compañía que produce el software, en una organización grande, un informe de problema no llegará a su escritorio antes de que varios colegas lo hayan considerado y la solución podría estar sujeta a prueba.

[1] Debido a la participación de más de un desarrollador.

No siempre cambio el nombre del código y los datos porque algunos paquetes se comparten entre los clientes. Básicamente están usando lo mismo pero lo llaman de manera diferente. Ejemplos, en un CMS, un cliente llama a su cliente "Cliente" y otro usa "Cliente". Por lo tanto, reemplazamos Cliente por Cliente en la superficie para un cliente, pero CMS siempre será un Sistema de gestión de clientes.

Otro ejemplo es la administración de usuarios con términos como permisos vs lista de control de acceso, administrador vs administrador, etc. Puede ser confuso para los recién llegados, pero para componentes centrales como esos, generalmente hay desarrolladores principales que se aseguran de que esos componentes funcionen para todos los clientes y También es fácil de implementar por otros desarrolladores (por ejemplo, creando etiquetas configurables).

Podría ayudar pensar que si realiza este cambio, con suerte no tendrá que volver a hacerlo si otro cliente usa la misma pieza, básicamente convirtiéndola en un producto.