Sviluppo di un'interfaccia in un sistema dinamico

2

Lavoro per una piccola azienda e sto progettando una GUI per interfacciare il nostro sistema embedded. Il problema con questo sistema incorporato è che non è un prodotto finito (potrebbe non essere mai) ed è costantemente in fase di sviluppo e viene ottimizzato e aggiornato per diversi clienti e applicazioni in piccoli volumi.

Quindi, per far fronte a questo ho creato un programma in grado di esportare tutti i dati da un foglio di calcolo in cui vengono prelevate la maggior parte delle variabili di sistema incorporate e di inserirle in un piccolo database per l'applicazione GUI da utilizzare. Questo programma di database che ho creato sputa anche un file di riferimento incrociato per il sistema embedded che consente alla GUI di cercare tutte le variabili.

Questo sistema funziona abbastanza bene finora ed è addirittura integrato con il controllo della versione tra la GUI, il database e il sistema embedded. Il grosso problema è che c'è uno sviluppo costante su diversi progetti che utilizzano questo sistema e diventa terribilmente noioso mantenere il sistema aggiornato e apportare nuove modifiche. Questo è arrivato al punto in cui ho dovuto codificare la GUI per generare in modo dinamico (genericamente) tutte le interfacce poiché non mi è mai garantito di trovare gli stessi dati allo stesso modo. Non sono stato in grado di trovare un modo valido per identificare in modo univoco i dati importati da Excel, poiché tutti i campi possono essere modificati (a causa di testardaggine ingegneristica, rielaborazione del codice e / o problemi di Excel) e non posso assegnare un riferimento fisso all'interno del foglio stesso.

Quindi, ci sono dei buoni metodi o idee su come gestire il caos?

    
posta radix07 06.07.2012 - 20:52
fonte

2 risposte

1

Penso che questa non sia una programmazione, ma un problema di gestione, e quello che fai attualmente sembra essere il meglio che puoi ottenere. Sono anche d'accordo: questo è molto meno di quello che dovresti avere.

Il problema qui è che la struttura del componente e le definizioni dell'interfaccia (il vero cuore del sistema) sembra un parco giochi . Se questo fosse un prodotto software, vorrebbe che i programmatori cambiassero costantemente i "loro" componenti "perché devono", e non si preoccupano del fatto che gli altri codici del programmatore non vengano compilati o interrotti. Sembra un incubo ... La buona notizia: lo stesso scenario è già stato risolto nello sviluppo del software con i sistemi di controllo delle versioni (commit, testing, branching, ecc.).

Non so nulla del tuo ambiente, ma penso che tu (e, cosa più importante, i tuoi manager) dovresti considerare questo un problema (fonte di bug, frustrazione, diminuzione dell'efficienza e motivo per i colleghi che vogliono andarsene), e gestirlo adeguatamente. Benjamin ha dettagliato correttamente la parte tecnica, vorrei aggiungere il lato gestione e architettura. La mia idea veloce e non verificata è la seguente:

  • implementa o utilizza un semplice tipo di gestione che descrive i componenti, gli attributi, i servizi - il risultato deve essere un file di configurazione, json o xml in chiaro! Questi file dovrebbero essere controllato in versione per seguire le modifiche.
  • per qualsiasi modifica, i ragazzi di hw dovrebbero creare un nuovo ramo, dove aggiungere i componenti. Il punto: puoi semplicemente diffare i descrittori di tipi e modificare il codice di conseguenza.

Se questa parte del descrittore di componenti ottiene il suo vero ruolo di "master" in azienda con uno specifico background tecnico, possono apparire altri strumenti, come:

  • generatori di codice sorgente di intestazione sia sulla GUI che sul livello di servizio HW;
  • runtime di fogli di proprietà di lavoro generato dal tipo defs, ...

Questo non è un granché, ho fatto cose del genere solo perché questo rende lo sviluppo più efficiente: avere la "funzionalità di base" disponibile dai configs lascia più tempo per fare il vero lavoro (e meno errori ripetuti). Mi dispiace che posso solo parlare di questo, le mie cose pubbliche sono solo a livello "proof of concept", ma le fonti qui potrebbero darti il gusto.

Si tratta di seri stimoli di efficienza di programmazione e di stabilità del sistema - ma questo non può essere raggiunto se i descrittori dei dati di base vengono gestiti in un foglio di calcolo e possono essere modificati in qualsiasi momento, "solo perché" - e, a mio parere, questo non è un problema sviluppatore gui, ma un problema a livello di gestione.

    
risposta data 07.07.2012 - 07:17
fonte
1

Quindi, quello che capisco è che si analizza un foglio di lavoro Excel che viene modificato costantemente dai colleghi. Ecco alcune idee su come rimediare a questa situazione:

  1. Insegna agli altri programmatori di fare attenzione alle loro modifiche. Non appena un'API (in questo caso, il formato del foglio di calcolo) è pubblica, deve rimanere tale o essere deprecata in modo controllato, a livello di sistema. È scomodo, ma necessario.

  2. Molto efficaci insieme a quanto sopra sarebbero test automatizzati. Hai detto che tutto è in controllo di versione. Configura un sistema che esegue test automatici ogni volta che qualcuno esegue una modifica. Se i test falliscono, il commit dovrebbe essere rifiutato, se il tuo VCS lo consente. L'obiettivo è avere sempre uno stato funzionante e affidabile archiviato.

  3. Se il foglio di calcolo deve essere costantemente modificato senza tenere conto della compatibilità, prova a trovare un sistema in modo che l'onere dell'adattamento della tua interfaccia sia rivolto al tizio che cambia il foglio di calcolo. Forse qualche lingua specifica del dominio, un'altra GUI o qualche tipo di annotazione nel foglio di calcolo stesso. Utilizza i test automatici di cui sopra per verificare la coerenza in modo che gli utenti siano obbligati a mantenere l'interfaccia aggiornata.

risposta data 07.07.2012 - 00:01
fonte

Leggi altre domande sui tag