Ci sono effetti collaterali negativi della divisione di moduli di grandi dimensioni? [chiuso]

Stavo navigando in un progetto github e ho trovato questo modulo che ha più di 10 mila righe.

È pratica comune avere quel codice in un singolo modulo?

Mi sembra che questo dovrebbe essere suddiviso su più moduli. Forse uno per ogni motore db.

Quale vantaggio ottiene lo sviluppatore dalla creazione di un enorme modulo come questo (diverso da "avere tutto in un unico posto") o quale svantaggio c'è dalla sua divisione (diverso dalla "complessità")?

Quello che hai incontrato è il cosiddetto " oggetto di Dio ", perché fa tutto o sa tutto. Scappa da esso (se puoi).

Non esiste un numero definito di LOC per modulo, ma dovrebbe essere qualcosa che semplifica la ricerca del codice e la comprensione delle azioni dei metodi. Dalla mia esperienza personale, se il tuo modulo supera 1k righe ^* , stai facendo qualcosa di sbagliato.

^{* Anche un modulo di linea 1k è molto grande.}

Questo sembra essere un modulo in cui i limiti di dimensioni tipiche potrebbero non essere applicabili. La maggior parte delle funzionalità è nelle prime 2k righe di codice e commenti. Il resto del file sembra essere costituito da molte classi di adattatori e altre classi di supporto che sembrano essere strettamente collegate al modulo. In altre lingue le classi sarebbero in file separati di dimensioni ragionevoli.

Alcune stringhe di documenti potrebbero essere utili, ma aumenterebbero le dimensioni di un modulo già grande. Il codice è chiaro e autoesplicativo con opportuni commenti ove necessario.

Naturalmente il "limite" effettivo varia a seconda del progetto e di una moltitudine di fattori.

Ma entro con una regola empirica: 200 linee di Python decente. Cioè, nessun codice C o Java scritto in Python, ma buon Python in Python.

Wow.

Immagino di non conoscere la risposta completa a questa domanda, ma mi piace pensare come risposta alla domanda del titolo "Quanto dovrebbe essere grande un modulo Python?" come il concetto di Parnas, nascondendo un segreto. In questo caso il modulo sembra farlo correttamente (e questo è un grande segreto che nasconde).

Più tardi ho scavato nei documenti che parlano molto dell'accoppiamento e della coesione. Forse avere molti moduli db costringerebbe troppe chiamate tra i moduli portando ad aumentare ciò che è considerato una cattiva pratica, cioè una minore coesione e un accoppiamento più elevato?

Ho visto dati sperimentali parlare di programmatori che decidevano di sacrificare le buone pratiche per motivi di semplicità e comprensione, nonostante ciò che le buone pratiche dettano. In effetti, potrebbe esserci anche un conflitto tra buone pratiche. Diciamo, le prestazioni di solito non rendono felici le persone che eseguono la manutenzione in seguito. Non sono sicuro di come la leggibilità sarebbe migliorata in questo caso con un modulo così grande.

Un'altra cosa che ho notato è che parte del codice è dichiarata come generica e il resto dei dbs ne è esteso. Non sono un programmatore di Python, ma forse questo potrebbe giustificare qualcosa?

Quindi, non ho una risposta definitiva, ma spero che qualcuno sottolinei anche questi punti!