¿Cómo se llama esta técnica de programación?

Encontré esta técnica de programación mientras hacía programación de pares en una entrevista y no pude encontrar el nombre en google.

La idea es que primero escriba la expresión que usa las variables y luego escriba el código que computa las variables más adelante.

Para usar un código de ejemplo aquí:

private bool ValidPolicyNumber(string policyNumber) 
{
    var hasExpectedPrefix = policyNumber.Substring(0,5) == "POLIC";
    var followedBy7Digits = Regex.IsMatch(policyNumber.Substring(6,7), "^[0-9]{7}$");
    var hasLengthOf12 = policyNumber.Length == 12;

    return hasExpectedPrefix && followedBy7Digits && hasLengthOf12;
}

Al escribir esta función utilizando la técnica que mencioné, primero escribiría la última línea return hasExpectedPrefix && followedBy7Digits && hasLengthOf12;y luego las 3 líneas que la preceden.

La técnica más cercana que pude encontrar es "ilusiones" y eso es de SICP, pero se relaciona con las funciones de llamada que implementará más tarde en lugar de usar variables que va a inicializar más tarde.

programming-practices

— usuario2108462
fuente

Creo que esto es solo una forma de diseño de arriba hacia abajo .

— Vincent Savard el

No conozco un nombre específico para él, pero lo he visto con bastante frecuencia cuando es necesario verificar un conjunto complejo de condiciones. Esta técnica hace que sea mucho más fácil leer y comprender condiciones complejas.

— FrustratedWithFormsDesigner

He hecho esto Utiliza el código para esbozar una idea sin sudar los detalles al principio. Luego, el IDE se queja de que algo no existe, así que ve y haz que exista. Ayuda cuando tienes una prueba que fallará hasta que termines.

— candied_orange

Si esto fue precedido por una prueba unitaria, sería Test Driven Development. Cuando uso TDD, sé mi resultado esperado y trabajo hacia atrás desde ese comportamiento esperado.

— Martin Spamer el

Yo lo llamaría "escribir condiciones complejas sanamente".

— Jimmy Breck-McKye

Respuestas:

Es solo una variación de la composición funcional.

Testigo:

private bool ValidPolicyNumber(string policyNumber) 
{
    return hasExpectedPrefix(policyNumber) 
        && followedBy7Digits(policyNumber) 
        && hasLengthOf12(policyNumber);
}

private bool hasExpectedPrefix(string policyNumber)
{
    return policyNumber.Substring(0,5) == "POLIC";
}

private bool followedBy7Digits
{
    return Regex.IsMatch(policyNumber.Substring(6,7), "^[0-9]{7}$");
}

private bool hasLengthOf12
{
    return policyNumber.Length == 12;
}

La única diferencia real es que su versión combina los resultados calculados de las funciones más pequeñas en un solo alcance funcional, que es lo que desea a menos que las expresiones funcionales más pequeñas estén destinadas a ser reutilizadas en otro lugar.

— Robert Harvey
fuente

Esto podría ser solo una sugerencia de Clean Code (el libro), que se utilizará cuando la descomposición funcional (como explicó Robert) no sea aplicable debido a que las funciones resultantes no son reutilizables por sí mismas.

Sin embargo, si desea obtener información técnica al respecto, el libro Implementation Patterns , de Kent Beck, nombra esta técnica como Explicando las variables locales (énfasis mío):

Variable local

Las variables locales solo son accesibles desde su punto de declaración hasta el final de su alcance. Siguiendo el principio de que la información debe difundirse lo menos posible, declare las variables locales justo antes de que se usen y en el ámbito más interno posible.

Hay un puñado de roles comunes para las variables locales:

Recopilador: una variable que recopila información para su uso posterior. A menudo, el contenido de los recopiladores se devuelve como el valor de una función. Cuando se devuelva un recopilador, asígnele el nombre resultado o resultados.

Count: un colector especial que recopila el recuento de algunos otros objetos.

Explicación: si tiene una expresión complicada, asignar bits de la expresión a variables locales puede ayudar a los lectores a navegar por la complejidad:

int top = ...;

int left = ...;

int altura = ...;

int bottom = ...;

volver nuevo rectángulo (arriba, izquierda, altura, ancho);

Si bien no es computacionalmente necesario, las variables locales explicativas ayudan a lo que de otro modo sería una expresión larga y complicada.

— MichelHenrich
fuente