Java - Diseñar antes de empezar a escribir

Estoy muy frustrada: estuve una semana entera pensando sobre cómo se iba a estructurar mi prorgama, que clases existirían, interfaces, que patrones usar...
Me pongo a escribir pensando que ya estaba hecho lo dificil, que solo tenía que hacer que todos los métodos en los que había pensado cobraran vida, pero...
He tenido que quitar métodos que no sirven, he tenido que añadir de nuevos, he tenido que cambiar toda la estructura del programa a medida que avanzo. Y cada vez que completo una parte del nuevo diseño, tengo que rediseñar las otras partes. En general siempre añadiendo funciones.
Pero me desanima ver que del diseño al que le dediqué más de 30 horas solo quedan 2 o 3 métodos y un par de interfaces. Me está costando mucho pensar en que métodos usar para cada función que hay que añadir, ya que no había pensado en ella.

Mi proceso para diseñar es algo como:
¿Qué tareas va a realizar? <-- Se me pasan algunas
¿Cómo las va a realizar? <--- Como se me pasaron algunas tareas el diseño de esto queda mediocre
¿Que partes de los procesos para realizarlas están directamente relacionados? <--- Para crear herencia e interfaces

Al final, como he visto que no avanzaba, he tomado la estrategia de fijarme objetivos pequeños e ir diseñando las cosas a medida que voy escribiendo código y viendo por donde va el camino. Pero dudo que sea una buena práctica hacer esto y realmente me gustaría aprender bien :c

Algún consejo para mejorar en este aspecto?
Estaba pensando en comprar un par de libros sobre diseño de sistemas para mejorar, alguna recomendación?

Hola Andrea, yo creo que lo estas haciendo de la manera correcta... pero entiendo que te falta experiencia para realizar un buena análisis... pero es una muy buena práctica lo que estas haciendo.

A medida que vayas cogiendo experiencia, veras que te van saliendo cada vez mejor!!!

Yo diría que eso es lo normal.

El diseño previo nos da una idea de que necesitamos y como pensamos que podemos conseguirlo.

Pero luego, cuando empezamos a dar forma es muy habitual encontrarnos con métodos y/o clases que no son necesarios, o que no son tan funcionales como pensábamos, o bien nos damos cuenta sobre la marcha que hay una forma más simple y eficiente de conseguir un determinado propósito, pero va a implicar modificar y eliminar gran parte de lo que ya teníamos escrito.

Muchas de estas cosas no podemos verlas hasta que no empezamos a trabajar en el código.

Seguro que con el tiempo y ganando experiencia, cada vez seremos más capaces de que nuestro diseño previo sea tan acertado y maravilloso que apenas requiera cambios una vez empezamos a codificarlo.

Pero me atrevería a decir que no hay nadie que no acabe modificando parte de su diseño previo cuando lo traslada al código, ya sea por algún detalle que había olvidado, ya sea porque ha descubierto una forma más eficiente y mejor que la planteó en su diseño inicial.

Pero que pasa con programas de gran envergadura?
Osea, no es lo mismo tener que cambiar unas clases de un programa que será una calculadora a cambiar las clases que usará Microsoft Excel o un sistema operativo... Allí te puedes cargar el trabajo de 40 personas con un simple error de diseño de una clase

Ah, y muchas gracias por la ayudita :3

Desconozco como será trabajar a ese nivel....

Pero pienso que cuanto más grande es un programa, más fácil es separar en distintos módulos independientes unos de otros.

En Excel, por ejemplo unos programadores se encargarán tan solo de la parte visual: como cambiar colores de background y foreground, aplicar formatos al texto, tamaños de fuentes... y no necesitan estar pendientes ni saber qué y cómo lo están haciendo los programadores que se encargan de los cálculos matemáticos que realizan las hojas,... ni de los programadores que se encargan de la parte E/S (guardar hoja, abrir hoja, importar hoja, elegir/convertir a formatos compatibles...)

Pero vamos, seguro que entre los programadores que se encargan de una determinada parte/modulo, muchas veces se encontrarán que una decisión de última hora, algún impedimento inesperado, etc.. les obliga a reescribir código, alterar el diseño original, dejar en el olvido alguna idea que no ha sido posible implementar y ya se verá que pasa con ella en próximas versiones...

Por poner un ejemplo extremo, antes del famoso (o infame) Windows Vista, el proyecto que estaba creando Microsoft con nombre interno Windows LongHorn..era muy ambicioso.... pero la cosa se complicó tanto, fue tan dificil hacer que los distintos modulos encajasen bien unos con otros.... que decidieron tirar a la basura prácticamente 3/4 años de trabajo y empezar casi desde cero otra vez.
Tuvieron que renunciar a un montón de cosas y al final se lanzó Windows Vista, que necesitó muchas actualizaciones para ser considerado aceptable, aunque nunca terminó de cuajar.

Así que hasta los "grandes genios" pueden meter la pata con sus diseños y posterior implementación.

En un proyecto grande los programadores "novatos" no diseñan.
A veces se usan métodos de diseño iterativos incrementales (se comienza con poco, y se va rediseñando a la par que se implementan funcionalidades y casos de uso).