Al crear una aplicación no trivial, ¿es mejor concentrarse en hacer que las cosas funcionen rápidamente y tomar atajos en el código, como mezclar la lógica del modelo con sus vistas, romper la encapsulación, olores típicos del código? O, es mejor tomarse el tiempo por adelantado para construir más arquitectura, compilarlo correctamente, pero correr el riesgo de que no se use todo este código adicional ya que su diseño es bastante fluido y es posible que tenga que tirarlo si los comentarios lo causan ir en una dirección diferente?

Por contexto, estoy creando una aplicación de escritorio. Soy el único desarrollador, y lo estoy haciendo a tiempo parcial desde que tengo un trabajo diario. Ahora, por trabajo, trato de hacer las cosas de la manera correcta, si el horario lo permite. Pero para este proyecto, que espero se transformará a medida que reciba comentarios de la gente, no estoy seguro de que sea el enfoque correcto. Pasé varias horas esta semana colocando un diseño de controlador de vista de modelo de libro de texto para comunicar los cambios en el modelo a la vista. Esto es genial en general, pero no estoy seguro si necesito varias vistas para mostrar los datos y sé que podría haber hecho que las cosas se muestren más rápidamente sin la arquitectura adicional. Con unas 10-15 horas a la semana para dedicar al proyecto, creo que tomará años construir algo que pueda demostrar si sigo las buenas prácticas de software. Sé que mis usuarios ganaron ' No importa que use MVC internamente, solo quieren algo que resuelva su problema. Pero también he estado en una situación en la que ha incurrido en tanta deuda técnica por atajos que el código es increíblemente difícil de mantener y agregar nuevas funciones. Me encantaría saber cómo otras personas abordan este tipo de problema.

Construirlo bien .

Construirlo "rápido" es una falacia lógica si nos fijamos en el panorama general. Evitará que lo construyas bien, y eventualmente te atascarás con errores y fallas fundamentales de la arquitectura que evitan la refactorización o incluso hacen que sea casi imposible agregar nuevas características.

Construirlo bien es en realidad lo contrario. Al principio puede ser más lento, pero eventualmente se dará cuenta de las ganancias de eficiencia al tomarse el tiempo para tomar las decisiones correctas por adelantado. Además, podrá adaptarse a los requisitos futuros más fácilmente (refactorizando si es necesario) y tendrá un mejor producto final debido, al menos, a menos errores.

En otras palabras (a menos que se trate de un contrato único), construirlo rápido = construirlo lento, construirlo bien = construirlo rápido .

También hay algo importante a tener en cuenta sobre "construirlo bien" y diseñar una arquitectura. Tu preguntaste...

... pero ¿corre el riesgo de que todo este código adicional no se use ya que su diseño es bastante fluido y podría tener que tirarlo si los comentarios lo llevan a una dirección diferente?

Eso no es realmente un verdadero riesgo de "pasar tiempo de arquitectura". El diseño de la arquitectura debe ser orgánico . No pierda el tiempo diseñando una arquitectura para ninguna parte hasta que esté justificada. La arquitectura solo debe evolucionar a partir de patrones observados y confirmados en su proyecto.

La ley de John Gall de Systemantics :

Un sistema complejo diseñado desde cero nunca funciona y no se puede reparar para que funcione. Debe comenzar de nuevo, comenzando con un sistema simple que funcione.

Rápido, entonces bien

Esto es de mi experiencia personal después de haber probado muchos métodos diferentes.

El problema de trabajar solo rápidamente (y lanzar) es que generalmente agregará una característica tras otra en su aplicación y, dado que se lanzó, es muy difícil hacer cambios fundamentales en su programa. Pagas un alto precio a largo plazo por nada que tenga una arquitectura subyacente sólida, es como construir un desvencijado en arenas movedizas.

El programa para hacerlo bien es que perderás mucho tiempo y código. Es como construir una mansión sin planos. Escribir aplicaciones es un proceso de aprendizaje y casi (en mi experiencia) imposible de diseñar desde el principio. Eso significa que harás muchas refactorizaciones, y si escribes todo "bien" todo el tiempo, terminarás tirando mucho código.

Por lo tanto, rápido, entonces bien!

Lo principal cuando comienzas es solo tener todo en el código para que puedas identificar todas las características y ver qué tipo de arquitectura necesitas admitir. Otra cosa buena de esta metodología es que te mantendré motivado ya que rápidamente tendrás algo funcionando. También es importante implementar alguna funcionalidad de "caso límite" ya que eso tendrá un impacto en su arquitectura general. No se moleste en escribir pruebas unitarias o trabajar en detalles en esta etapa. Si cree que necesitará soporte multilenguaje en el futuro, una arquitectura de plugin de todo lo demás, impleméntelo, pero de manera rápida y sucia. Realice algunas refactorizaciones para mantener la aplicación manejable pero nada excesivo.

Después de sentir que tiene un "prototipo" en funcionamiento, es hora de comenzar a refactorizar. Básicamente, desea rehacer la aplicación como lo haría si comenzara desde cero sabiendo todo lo que ahora sabe. Lo importante es obtener la arquitectura correcta, no volver a implementar todas las características que hizo en la fase uno, pero debe tener la arquitectura en su lugar para admitirla más adelante.

De esta manera, terminarás con una aplicación con una arquitectura de sonido lo más eficiente posible, en mi experiencia de todos modos :)

Constrúyelo

Rápido si el tiempo de comercialización es más importante que la calidad

Bueno, si la calidad es más importante que el tiempo de comercialización

Construirlo rápido le dará beneficios a corto plazo y pérdidas a largo plazo.

Construirlo bien generará pérdidas a corto plazo pero beneficios a largo plazo.

Construirlo bien requiere paciencia y sabiduría, pero será recompensado.

Construirlo rápido solo es bueno para la creación rápida de prototipos y descarte. Los objetivos a largo plazo solo se pueden lograr con la actitud correcta desde el principio.

Para los proyectos que planea distribuir para que otros los usen, siempre cometería un error en el lado del trabajo inicial. Una arquitectura bien pensada es más fácil de ampliar si es necesario. Tomar atajos es solo el modelo para acumular deuda técnica.

Puede ser frustrantemente lento a veces. Las cosas que vale la pena hacer valen la pena hacerlo bien.

Construirlo bien = construirlo rápido

Los atajos tienden a darte la vuelta y morderte aún más rápido de lo que piensas. A veces incluso antes del almuerzo.

Sobre tu contexto; No haga un resumen de inmediato. Apégate a YAGNI y elimina la duplicación. Implemente ese patrón basado en la Vista cuando realmente tenga una segunda vista, no porque piense que puede tener una en el futuro. Cuando llega esa segunda Vista, la abstracción que creas suele ser mucho mejor que la que habrías hecho alrededor de esa primera aparición.

Bueno, si ya sabes lo que estás haciendo, rápido si no lo sabes

Soy un investigador científico y escribo mucho código exploratorio antes de tener alguna idea de cuál es el panorama general o cómo se desarrollará el proyecto. En estos casos, es difícil incluso ver cómo se debe definir "bien". Además, generalmente es difícil ver todos los pequeños detalles y las formas en que las cosas se pueden extender por adelantado. Por lo tanto, se aplica el viejo adagio:

1. Hazlo funcionar.
2. Hacer lo correcto. Hacerlo bien en segundo lugar tiene la ventaja de que puede definir mejor "correcto" una vez que haya tenido la experiencia de hacerlo funcionar.

Constrúyalo bien ... siempre, pero dé la ilusión de ir rápido

pero para hacerlo más rápido, hazlo más pequeño. Cree un pequeño subconjunto del conjunto que sea lo suficientemente significativo como para obtener comentarios. Agregarlo progresivamente a un ritmo constante producirá el mismo beneficio de construir rápido sin vender su alma a la reacción en cadena de las noches sin dormir jugando al bicho.

Creo que siempre debe "construirse bien". Si el tiempo de comercialización es una gran preocupación, utilice un proceso de desarrollo incremental. En el peor de los casos, tiene un producto con menos funciones, pero al menos tiene un producto de alta calidad para enviar que puede ampliarse en futuras versiones.

Equilibrar

No es práctico diseñar tu código a la perfección o combinar algún código en un santiamén, ¿verdad? Realmente se trata de lograr el equilibrio correcto. Lo que importa en mi opinión es lo que haces cuando.

Creo que lo más importante aquí es garantizar absolutamente que el núcleo de la aplicación, la estructura fundamental, se construya realmente bien. Hermético. Una vez que se logre, dependiendo de las limitaciones de tiempo, si tiene poco tiempo, podría reunir algo de código y volver a factorizarlo más tarde, y puede permitirse ese lujo porque se habría ocupado de obtener la base correcto, y no estaría de más refactorizar el código.

Haz lo más simple que pueda funcionar. En su caso particular, su programa no se hará muy grande, siendo usted la única persona que trabaja en él a tiempo parcial. No estoy abogando por los malos modales como el abuso de goto, los nombres de variables indescriptibles, etc., pero no debe hacerlo más complejo de lo que debe ser. Quizás MVC es solo una exageración para su proyecto en particular.

que espero se transformará a medida que reciba comentarios de la gente

Lo dijiste mejor tú mismo:

Pero también he estado en una situación en la que ha incurrido en tanta deuda técnica por atajos que el código es increíblemente difícil de mantener y agregar nuevas funciones.

Si tiene poco tiempo, no tenga miedo de pedirle más tiempo para completar el proyecto a su empleador utilizando este mismo razonamiento. Estoy seguro de que te lo concederán. Habiendo dicho esto, entiendo lo frustrante que a veces puede ser sentir trabajar tan duro en algo y no ser capaz de mostrar mucho resultado. Pero no se preocupe, llegará allí, y construirlo bien valdrá la pena cuando lo haga.

Por lo general, me gusta construir bien la estructura y ahorrar tiempo al no preocuparme por detalles específicos de implementación. Como dices, cambiarán de todos modos. La idea detrás de construir una estructura inferior bien hecha es que los cambios pueden ocurrir muy rápido, una vez que se construye la base. Intento concentrarme en ser lo más genérico posible en mis clases y hacerlas valiosas siempre que sea posible. Por lo general, le doy al usuario una aplicación bien construida que satisface solo los requisitos de usabilidad más básicos. Los usuarios obtienen todo tipo de ideas una vez que una herramienta está en sus manos, por lo que no sirve de nada pensar en el futuro.

Construirlo bien . Si no tiene tiempo, reduzca el conjunto de funciones.

Diseñarlo tan universal como sea posible. Por ejemplo, diseñe una arquitectura de complementos, incluso si sabe, solo se utilizará un complemento la primera vez. Utilice esquemas de configuración universal (configuración extensible, lenguaje de organización), incluso si solo hay un parámetro al principio. Es una muy buena inversión , y puede hacer esta inversión solo al comienzo del proyecto.

¿Es mejor concentrarse en hacer que las cosas funcionen rápidamente y tomar atajos en el código, como mezclar la lógica del modelo con sus vistas, romper la encapsulación, olores típicos del código? O, ¿es mejor tomarse el tiempo por adelantado para construir más arquitectura?

En mis oídos, la forma en que lo pones allí, estás enumerando los dos extremos. La primera opción, romper la encapsulación, poner la lógica del modelo en las vistas, es simplemente una pobre programación perezosa. En mi humilde opinión, resolver esos problemas no es lo mismo que poner más arquitectura. Quizás a menos que esté hablando de que el código de la IU está ejecutando sentencias SQL. Pero entonces no diría que construya más arquitectura, luego diría que tiene una falta total de diseño y arquitectura y debería obtener una.

Cuando se trata de arquitectura, elegiría el más simple que resuelva su problema en este momento, y luego me expandiría a medida que surjan problemas.

Por ejemplo, es lo que necesita en este momento la funcionalidad para devolver datos de una sola tabla de base de datos, no me preocuparía por problemas como cómo cargar datos de tablas relacionadas, aunque sabría que el problema eventualmente surgiría. Comenzaría a preocuparme cuando implemente esa funcionalidad.

Entonces, para mis propios proyectos de desarrollo de viviendas, tomaría el siguiente enfoque: Construir la solución más simple posible que resuelva el problema con el que estoy trabajando en este momento, pero hágalo bien. Luego refactorizaría la solución a medida que se necesita más complejidad. Seguir las prácticas de TDD hace que la refactorización sea segura y también ayuda a evitar olores de código (es difícil crear buenas pruebas unitarias, si está rompiendo la encapsulación).

Por cierto, ese es también el enfoque que adopto cuando trabajo profesionalmente. ;)

Yo recomendaría que primero debe poner en pie el software, cubrir todos los aspectos y poner el software en primer lugar y luego gradualmente decorar y mejorar su rendimiento.

Por lo general, desea estar en el medio de estos dos bordes:

Constrúyalo bien = software vital en tiempo real del que depende la vida de las personas. es decir, control de software: reactores nucleares, máquina de diálisis, máquinas de resonancia magnética , etc.

Constrúyalo rápido = software inútil que nadie usa realmente.