Sto cercando di refactoring un design esistente; spostare un sacco di cose da un database e in memoria dove dovrebbe essere (ci sono molte ragioni per cui l'approcio del DB è pericoloso come lo è ora). Il mio primo atto è stato quello di prendere tutti gli oggetti esistenti e di espandere più stato per loro. Gli oggetti precedenti erano nuovi solo per i loro genitori, e così è stato. Dal bambino più piccolo si poteva camminare per trovare i genitori, ma non si poteva chiedere "quali sono i bordi su questo nodo".
Ho cambiato le cose per rendere lo stato più accessibile da ogni oggetto. Ora ogni oggetto conosce efficacemente il suo genitore e tutti i suoi figli. Ho pensato che fosse un'evidente semplificazione che avrebbe reso molto più semplice l'archiviazione delle cose in memoria. Il problema è che ho bisogno di essere in grado di costruire oggetti senza modificare il mio modello, fino a quando non viene chiamato addToModel, il che significa che devo essere in grado di costruire oggetti in uno stato, e quindi aggiornare alcuni dei loro stati per essere coerenti con lo stato del modello e rappresenta correttamente tutta l'interconnessione (il nodo deve essere informato quando viene aggiunto un bordo, il bordo deve sapere quali sono i percorsi ecc. ecc.)
Ciò si è dimostrato sorprendentemente complicato da mantenere coerente. Finisco con entrambi i problemi di incapsulamento (come supponendo che ogni oggetto sappia di non chiamare i metodi del pacchetto scope che cambiano la memoria da metodi pubblici che non dovrebbero essere in grado di cambiare stato), così come una preoccupazione sull'aliasing (cosa succede se qualcuno crea un nuovo Nodo A senza connessioni, quando il mio Modello dice che il nodo A deve essere collegato a B, C ed E?). Ho pensato a molti approcci che funzionano, ma nessuno si sente "pulito". È il problema che sto cercando di rendere i miei oggetti troppo consapevoli dello stato, e quindi mettendo troppo impegno sul mio modello per mantenere questo stato?