¿Cómo lidiar con un método aún no implementado que será realizado por un coprogramador?

Esta es una pregunta sobre cómo trabajar en equipo.

Recientemente trabajé en mi primer proyecto de programación más grande (~ 80 clases, Java) con un equipo de 6 personas, aunque solo 4 de nosotros trabajábamos continuamente en el código. Distribuimos el trabajo a realizar desde el principio y en algún momento tuve que llamar a un método que aún no estaba implementado por uno de mis coprogramadores. ¿Cómo es la forma recomendada de lidiar con esto?

Opciones que vi, aunque realmente no me gusta ninguna de ellas:

Escribiéndome //TODOy revisando esta línea de código más tarde para verificar si el método se ha implementado mientras tanto.
Pidiendo al miembro del equipo correspondiente que implemente eso ahora .
Lanzar una excepción de tiempo de ejecución personalizada con una descripción clara de lo que aún no se ha implementado. (Al menos no tenemos que buscar mucho tiempo para descubrir lo que falta)
Agregar el método necesario a su clase y escribirlos //TODOen el cuerpo del mensaje, posiblemente también les envíe un mensaje rápido sobre ese cambio. (Ahora ya no es mi problema, pero esto puede causar conflictos de fusión molestos si estaban trabajando en este método mientras tanto)
Definir clases o interfaces abstractas para todo antes de escribir realmente el código que hace el trabajo. (No funcionó muy bien porque estas interfaces a menudo se cambiaron)

teamwork

— lucidbrot
fuente

Creo que el flujo de trabajo donde necesita un método escrito por otra persona no es el correcto. Estás trabajando en una función. Si esa característica requiere un método, USTED lo implementa. Si dos personas implementan una característica única, se emparejan o se integran y se comunican con tanta frecuencia que casi parece que se emparejan.

— Eufórico

@Euphoric Varias veces me he encontrado con una situación en la que se iba a desarrollar una nueva característica bastante grande en un período de tiempo relativamente corto y, como tal, la interfaz de usuario, la lógica empresarial y las capas API tuvieron que dividirse en diferentes tareas para trabajar simultáneamente, de lo contrario, el plazo nunca podría cumplirse. Eso es exactamente donde una persona que trabaja en la interfaz de usuario solo debe declarar los métodos y comandos de acceso a datos a BL como interfaces y dejar que las otras personas trabajen en la implementación, mientras trabajan únicamente en la interfaz de usuario.

— Andy

@DavidPacker Lo que describe no es la única forma de resolver ese problema. Los cortes verticales, la integración frecuente, las características pequeñas son mejores soluciones que los cortes horizontales, con cada persona trabajando en partes separadas.

— Eufórico

@Euphoric No puedo estar más de acuerdo contigo. Cuando sea posible, seguimos la forma de eliminar la nueva característica compleja de las partes no críticas (es decir, aquellas que solo mejorarían la experiencia de usuario pero que no son necesarias de inmediato). Lamentablemente, a veces las opciones que mencionó, ni la eliminación de características, no son posibles. Las empresas dicen que los desarrolladores lo hacen. Entonces, si bien sus puntos son sólidos, también existe la posibilidad de que alguien se encuentre y encuentre una situación en la que se deba realizar algún tipo de división de trabajo para cumplir con las necesidades del negocio.

— Andy

¿Qué hay de hablar con él sobre cómo quiere manejarlo?

— Aganju

Respuestas:

Es una pregunta interesante y la respuesta podría ser más fácil de lo que piensas.

En pocas palabras, escriba pruebas que validen sus suposiciones. No importa si haces la implementación o si tus compañeros programadores

La larga respuesta.

Cualquiera de las opciones que enumera son algo pasivas y requieren que regrese y vuelva a visitar el código (si existe) tarde o temprano.

Los comentarios deben ser leídos y manejados por su contraparte responsable de la implementación. Su código no se puede compilar mientras tanto. Si verifica dicho estado en un repositorio de código, su canal de integración continua no funcionará, y de todos modos es una mala práctica ... nunca registre código roto
Las excepciones de tiempo de ejecución parecen mejores, pero siguen siendo tóxicas, porque su compañero programador podría asumir que la implementación ya se realizó sin verificar, dejando el sistema también en un estado inestable. Si el método no se activa con tanta frecuencia, podría dar lugar a un código de producción roto ... una mala práctica también ... nunca verifique excepciones "no implementadas"
Esperar a sus compañeros programadores para la implementación de los métodos o un código auxiliar también es desalentador. Rompe tu flujo de trabajo y el flujo de trabajo de tus compañeros programadores. ¿Qué sucede si están enfermos, en una reunión ag, en un descanso para tomar café, quieres pasar el tiempo esperando? ... no esperes a alguien si no tienes que
implementar los métodos faltantes definitivamente es la mejor manera de seguir adelante. Pero, ¿qué sucede si su implementación no satisface todo el caso de uso y sus compañeros programadores necesitan enmendarlo o cambiarlo? ¿Cómo se aseguran usted y ellos de que todavía sea compatible con su intención? La respuesta es fácil nuevamente. Escriba pruebas que verifiquen, describan y documenten sus intenciones. Si las pruebas se rompen, es fácil notarlo. Si es necesario realizar cambios en ese método que rompan su función ... lo verá de inmediato. Ambos tienen una razón para comunicarse y decidir qué hacer. Dividir la funcionalidad? Cambie su implementación, etc., nunca registre código que no esté suficientemente documentado por las pruebas.

Para lograr un nivel suficiente de pruebas, le sugiero que eche un vistazo a dos disciplinas.

TDD - desarrollo basado en pruebas - esto asegurará que describas tu intención y lo pruebes lo suficiente. También le brinda la posibilidad de simular o falsificar métodos y clases (también mediante el uso de interfaces) que aún no se han implementado. El código y las pruebas aún se compilarán y le permitirán probar su propio código en forma aislada del código de sus compañeros programadores. (ver: https://en.wikipedia.org/wiki/Test-driven_development )
ATDD: desarrollo impulsado por pruebas de aceptación: esto creará un bucle externo (alrededor del bucle TDD) que lo ayudará a probar la función en su conjunto. Estas pruebas solo se volverán verdes cuando se implemente toda la función, lo que le dará un indicador automático cuando sus compañeros completen su trabajo. Muy ordenado si me preguntas.

Advertencia: en su caso, solo escribiría pruebas de aceptación simples y no trataría de incorporar demasiado del lado comercial, ya que sería demasiado para comenzar. Escriba pruebas de integración simples que junten todas las partes del sistema que requiere la función. Eso es todo lo que se requiere

Esto le permitirá poner su código en una tubería de Integración continua y producir una implementación altamente confiable.

Si desea profundizar en ese tema, consulte los siguientes enlaces:

— Jesko R.
fuente

103

Pide trozos.

O escríbelos tú mismo. De cualquier manera, usted y sus compañeros de trabajo deben ponerse de acuerdo sobre las interfaces y cómo deben usarse. Ese acuerdo debe estar relativamente solidificado para que pueda desarrollarse contra trozos, sin mencionar, para que pueda crear sus propios simulacros para la prueba de su unidad ...

— svidgen
fuente

^^ Esto. Si está utilizando correctamente las interfaces, no debería necesitar las implementaciones hasta que el otro tipo haya terminado de escribirlas.

— Robert Harvey

Y para ampliar el comentario de Robert, si no está utilizando correctamente las interfaces en un proyecto específicamente diseñado para dividirse entre varias personas, bueno, lo

— pasará

Es una pena que Java no tenga archivos de encabezado. En el mundo C / C ++, puede calcular sus API y escribir todos sus encabezados primero, la falta de implementación se convierte en un problema para el vinculador. (Ligera simplificación, el ABI también debe permanecer constante para que solo sea un elemento de enlace).

— Wes Toleman

@WesToleman Divertidamente, una de mis cosas favoritas sobre Java es que no tiene archivos de encabezado. Las "interfaces" que Robert y corsiKa mencionaron cumplen ese rol perfectamente. Primero trabajas tus API, escribes las interfaces, y la falta de implementación concreta no es un problema para el compilador.

— GrandOpener

@WesToleman ¿Eso funciona bien para ti? En mis oídos, eso suena muy parecido al estilo de las caídas de agua, y supongo que tiene que actualizar aún más la interfaz cuando se da cuenta de que ha perdido este "parámetro importante".

— netigger

En su situación, hablaría con el miembro del equipo responsable de esa función. Es posible que estén en condiciones de priorizar el desarrollo de esa función para que pueda comenzar a usarla antes.

Me mantendría alejado de tu cuarta opción. Has escrito todo tu código y, como dices, ya no lo consideras tu problema. Luego, su colega escribe la implementación de la función y ya no la considera su problema. ¿Quién va a probar que el código que USTED escribió funciona correctamente?

— Pete
fuente

Debería solicitar la API para esa función que debería dar como resultado una o más interfaces. Puede ser una buena idea hacer esto juntos, ya que necesitará usar esta interfaz para poder diseñar los casos de prueba iniciales en función de su entrada. La implementación real puede venir más tarde (incluidos los posibles cambios de API)

— Thorbjørn Ravn Andersen