Ho due applicazioni, chiamate A e B. La versione corrente di queste applciations è 7.x (alcuni clienti eseguono 7.1, altri eseguono 7.2, ...). Entrambe le applicazioni usano una stessa struttura comune (chiamiamola C), in questo modo:
+---+ +---+
| A | | B |
+---------+
| C |
+---------+
A causa di alcuni nuovi clienti importanti, voglio avere le funzionalità di A e B in un'unica grande applicazione. L'unione di A e B in un'unica applicazione non è possibile, quindi ora sto cercando di integrare la funzionalità di A in B. Fin qui tutto bene, ma ho iniziato a riscontrare alcuni problemi.
Prima di tutto, i clienti che utilizzano solo la funzionalità di base di B non sono interessati a tutte le nuove funzionalità di A che viene aggiunta (e che causa un ulteriore sovraccarico per loro). Vogliono semplicemente aggiornare la loro versione B con il supporto per le nuove versioni di Windows, ... e forse anche tutte le funzionalità che sono state aggiunte a C (il framework comune).
In secondo luogo, i clienti che attualmente utilizzano l'applicazione A non vogliono spostarsi direttamente nell'applicazione B, sebbene la funzionalità combinata di A + B li possa aiutare nel lungo periodo. Per aggiornamenti facili, vogliono rimanere con A e persino vedere alcuni miglioramenti in C.
In terzo luogo, tutti gli sviluppi che sto facendo in B potrebbero avere un impatto sullo strato comune C. E.g. per migliorare le prestazioni di un modulo in B, devo rifattorizzare un modulo in C, ma poiché C è anche usato in A, ho bisogno di fare molto più lavoro. Inoltre, A è un'applicazione più vecchia e meno strutturata e ogni modifica in C potrebbe rendere A più instabile.
La domanda è come procedere? Attualmente sto pensando di dividere B in una versione 7.x (potrei ancora fare alcuni sviluppi minori qui e rilasciare 7.3, 7.4 nei prossimi anni se necessario) e una versione 8.x (che conterrà tutte le nuove funzionalità) . Per risolvere il problema del livello comune, potrei anche suddividere C in una vecchia C (7.x) e una nuova C (8.x). Questo dà il seguente risultato:
+-------+ +-------+ +-------+
| A 7.x | | B 7.x | | B 8.x |
+-----------------+ +-------+
| C 7.x | | C 8.x |
+-----------------+ +-------+
L'applicazione A non si evolve più e si attacca alla versione 7.x del livello comune C.
Splitting C significa che tutti gli sviluppi in C non saranno visti nei vecchi A e B (che sarebbe comunque la versione 7.x), o se devono essere eseguiti nella release 7.x di A e B, sarebbe richiede di fare gli sviluppi in entrambe le versioni.
Un'alternativa potrebbe essere quella di dividere B in B 7.xe B 8.x, ma ciò limiterebbe le possibilità di refactoring in C, e in realtà risolverà solo i primi due problemi.
Qualcuno ha esperienza con un tale tipo di cambiamento di versione? Altre idee?