Posso scrivere codice ... ma non riesco a progettare bene. Eventuali suggerimenti? [chiuso]


83

Sento di essere bravo a scrivere codice in frammenti, ma i miei progetti fanno davvero schifo. La domanda è: come posso migliorare i miei progetti e diventare a mia volta un designer migliore?

Penso che le scuole e i college facciano un buon lavoro nell'insegnare alle persone come diventare bravi a risolvere i problemi matematici, ma ammettiamo che la maggior parte delle applicazioni create a scuola sono generalmente lunghe circa 1000-2000 righe, il che significa che si tratta principalmente di un esercizio accademico che non riflette la complessità del software del mondo reale, nell'ordine di poche centinaia di migliaia a milioni di righe di codice.

È qui che credo che anche progetti come topcoder / project euler non saranno di grande aiuto, potrebbero affinare la tua capacità matematica di risoluzione dei problemi - ma potresti diventare un programmatore accademico; qualcuno che è più interessato alle cose belle e pulite, che non è assolutamente interessato alle cose quotidiane banali e pelose che la maggior parte dei programmatori di applicazioni affronta.

Quindi la mia domanda è: come posso migliorare le mie capacità di progettazione? Cioè, la capacità di progettare applicazioni su piccola / media scala che andranno in poche migliaia di righe di codice? Come posso apprendere le capacità di progettazione che mi aiuteranno a costruire un kit editor HTML migliore o alcuni programmi di grafica come Gimp?


1
"ammettiamo che la maggior parte delle applicazioni create a scuola sono generalmente lunghe circa 1000 - 2000 righe, il che significa che si tratta principalmente di un esercizio accademico che non riflette la complessità del software del mondo reale": dove insegnavo ne avevamo due progetto software del semestre in cui un team di dieci studenti ha sviluppato un'applicazione abbastanza complessa per un periodo da 6 a 8 mesi. Inoltre, molte aziende (almeno in Germania) offrono contratti brevi per gli studenti che vogliono esercitarsi prima di completare gli studi.
Giorgio,

Risposte:


87

L'unico modo per diventare davvero bravi in ​​qualcosa è provare, fallire in modo spettacolare, riprovare, fallire un po 'meno di prima e nel tempo sviluppare l'esperienza per riconoscere cosa causa i tuoi fallimenti in modo da poter gestire in seguito potenziali situazioni di fallimento. Questo è altrettanto vero per imparare a suonare uno strumento musicale, guidare un'auto o guadagnare un po 'di età PWN nel tuo sparatutto in prima persona preferito, come lo è imparare qualsiasi aspetto dello sviluppo del software.

Non ci sono scorciatoie reali, ma ci sono cose che puoi fare per evitare che i problemi sfuggano di mano mentre stai acquisendo esperienza.

  • Identifica un buon mentore . Non c'è niente di meglio che essere in grado di parlare dei tuoi problemi con qualcuno che ha già pagato le quote. La guida è un ottimo modo per aiutare l'apprendimento rapido.
  • Leggi , leggi ancora un po ', pratica ciò che hai letto e ripeti per tutta la vita della tua carriera. Faccio queste cose da più di 20 anni e continuo a imparare qualcosa di nuovo ogni giorno. Scopri non solo la progettazione frontale, ma anche la progettazione, i test, le migliori pratiche, i processi e le metodologie emergenti. Tutti hanno diversi gradi di impatto sul modo in cui i tuoi progetti emergeranno, prenderanno forma e, soprattutto, su come dureranno nel tempo.
  • Trova il tempo di armeggiare . Lasciati coinvolgere da un progetto di lavoro a domicilio attraverso il tuo posto di lavoro o fai pratica nel tuo tempo libero. Questo va di pari passo con la tua lettura, mettendo in pratica le tue nuove conoscenze e vedendo come funzioneranno tali cose. Questa è anche la materia che rende una buona discussione con il tuo mentore.
  • Lasciati coinvolgere da qualcosa di tecnico al di fuori del tuo posto di lavoro. Questo potrebbe essere un progetto o un forum. Qualcosa che ti permetterà di mettere alla prova le tue teorie e idee al di fuori della tua cerchia immediata di colleghi per mantenere una nuova prospettiva sulle cose.
  • Sii paziente . Riconosci che l'esperienza di guadagno richiede tempo e impara ad accettare che devi ritirarti per un po 'per capire perché e dove hai fallito.
  • Tieni un diario o un blog delle tue attività, dei tuoi pensieri, dei tuoi fallimenti e dei tuoi successi. Questo non è strettamente necessario, tuttavia ho scoperto che può essere di grande beneficio per te vedere come ti sei sviluppato nel tempo, come sono cresciute le tue capacità e i tuoi pensieri sono cambiati. Torno alle mie riviste ogni pochi mesi e guardo le cose che ho scritto 4-5 anni fa. È una vera rivelazione scoprire quanto avevo imparato in quel periodo. È anche un promemoria che ogni tanto ho sbagliato le cose. È un promemoria salutare che mi aiuta a migliorare.

45
+1 per tentativi falliti. Perché quando non capisci perché esiste un modello di progettazione, non puoi usarlo in modo efficace.
Mert Akcakaya,

2
+1 ottima risposta, ma trovo che sia in qualche modo incompleto. Credo che il contributo più importante sarebbe di gran lunga avere un ottimo appetito per il refactoring. Scrivi, guarda cosa dice la teoria (articoli, libri o tutor), refactor / rewrite, torna alla teoria, refactor / rewrite - questo ti darà il tempo di concentrarti sulla struttura, mentre lavori con un codice familiare. Sii il tuo peggior critico. Direi anche che è molto importante non perdere mai questo appetito per rivisitare costantemente il proprio lavoro.
vski,

1
@vski Ci sono molti concetti che avrei potuto includere, ma la domanda è se tali concetti possano di per sé fornire un percorso ragionevole per guadagnare l'esperienza necessaria affinché l'OP consideri se stesso un progettista migliorato. Nell'ambito della mia risposta, vedo il refactoring come una pratica (secondo il mio secondo punto). Lo stesso vale per la pratica di Clean Code, Test First, BDD e molti altri concetti. Ho adottato l'approccio secondo il quale ci sono molte competenze ed esperienze necessarie per svilupparsi fino al punto in cui emergeranno e cresceranno le capacità di progettazione, con l'esperienza e le conoscenze acquisite nel tempo. :)
S.Robins,

2
+1 per ottenere un mentore. Idealmente, chiedi al tuo mentore di fare recensioni di codice con te. Avere qualcun altro a leggere e criticare il tuo codice può davvero aiutarti quando si tratta di un design migliore e più pulito.
Leone,

2
"Mai provato. Mai fallito. Non importa. Riprova. Fallisci ancora. Fallisci meglio." --- Samuel Beckett.
Peter K.,

16

Bene, non esiste una mela d'oro per questo tipo di domanda, e penso che forse questo sia per ogni programmatore stesso trovare ciò che è giusto per lui. Ecco la mia opinione, comunque.

Si potrebbe leggere libri sull'argomento. Grandi libri. Libri fantastici. Ma trovo che questi libri ti siano d'aiuto solo dopo aver provato a creare e progettare un'applicazione, ma non ci sono riuscito.

Per me, si tratta solo di esperienza. Quando ho iniziato come novellino, ho letto libri su come progettare. Allora non capivo molto del contenuto. Quando ho iniziato a lavorare e ho dovuto progettare applicazioni da solo, ho creato applicazioni molto complicate. Hanno funzionato, ma sono stati un dolore da mantenere. Poi ho letto di nuovo quei libri - e questa volta ho capito meglio.

Ora continuo a fare nuovi errori e ad imparare da quelli vecchi.


10
C'è un ottimo punto qui che vale la pena sottolineare: continua a fare nuovi errori; non continuare a fare gli stessi vecchi errori, impara da loro e fai qualcosa di nuovo.
Bevan,

11

Smetti di progettare e impara a refactor code. Lo sviluppo incrementale con refactoring continuo e aggressivo si tradurrà in un prodotto finale molto più pulito rispetto a qualsiasi progetto iniziale.


2
Il design emergente è una cosa bella IMHO, ma senza disciplina rischi di creare "spaghetti emergenti". Il problema con il design frontale è che le persone lo vedono come una proposta tutto o niente, dandogli una cattiva reputazione quando le cose vanno male. Questo mi ricorda uno degli articoli di Joel in cui menziona l'importanza del design. Ciò che è necessario, tuttavia, è sufficiente affinché un progetto possa fare la differenza senza privarti di tempo, risorse e possibilità di vedere emergere organicamente bellissimi progetti di supporto attraverso un codice pulito.
S.Robins,

@ S.Robins: ho sentito che l'OP sta ancora attaccando progetti abbastanza piccoli da essere completati molto bene con TDD e refactoring continuo. Può quindi apprendere la disciplina necessaria per sapere quanta progettazione è necessaria per progetti più complessi.
Kevin Cline,

Ho pensato che potesse essere il caso, tuttavia ho ritenuto che valesse la pena aggiungere un contrappunto all'implicazione che "qualsiasi progetto iniziale" sarà potenzialmente peggiore di qualcosa di puramente emergente. Concordo tuttavia sul fatto che il modo per costruire l'esperienza necessaria che l'OP sta cercando è di preoccuparsi meno all'inizio della progettazione e concentrarsi invece sulla scrittura di codice ben ponderato e pulito. :-)
S.Robins,

Non sono d'accordo sul fatto che il refactoring porti sempre al miglior design. Naturalmente, il refactoring spesso consente di esplorare e comprendere il problema, ma un buon design non sempre emerge in modo incrementale attraverso il refactoring. A volte vedi una soluzione molto migliore e ti rendi conto che il tuo codice attuale è così lontano da esso che la riscrittura è molto più veloce del refactoring.
Giorgio,

Ho avuto questa esperienza di recente: ho continuato a refactoring e refactoring e ad andare in un circolo con gli stessi problemi ancora e ancora: stavo usando iteratori per codificare qualcosa e il codice continuava a essere complesso. Poi ho deciso di dimenticare gli iteratori e ho dovuto riscrivere gran parte del codice, ma la logica è diventata molto più chiara e più concisa di prima. Non so se si chiamerebbe questo "refactoring aggressivo": la struttura generale dell'applicazione non è stata modificata ma alcune parti fondamentali sono state semplicemente eliminate e riscritte da zero.
Giorgio,

7

Leggi gli schemi, certo, ma prima di tutto leggi gli anti-schemi. Riconoscere gli anti-schemi è importante ed è più facile capire perché qualcosa non dovrebbe essere fatto in modo tale da non farlo.

Vedi http://sourcemaking.com/antipatterns/software-development-antipatterns per esempio.

Scrivi il codice in modo che possa essere modificato rapidamente in caso di modifica dei requisiti (cosa molto comune nell'ambiente di produzione).

Sii super scettico sull'aggiunta di "solo un altro piccolo trucco". Un altro qui, un altro lì, e il codice diventa non modificabile.

Valutare il principio aperto / chiuso .

Scrivi test (come nel TDD). Ti costringono a pensare al tuo progetto anche prima di implementarlo.

Sfoglia il codice dei progetti open source (quelli di dimensioni ragionevoli, cioè). Ero sorpreso di - di solito - vedere così tanti livelli di astrazione. Ora capisco che non è arte per l'arte, c'è un motivo per cui è fatto in questo modo.


4

Un principio che trovo molto importante per un buon design è la decomposizione: se una classe è troppo grande (più di, diciamo, 300-400 righe di codice) la scompone in classi più piccole; se un metodo è troppo grande (diciamo, più di 50 righe di codice) lo scompone; se un progetto contiene più di 50 classi, scomporlo.

La chiave è stimare le dimensioni del sistema e costruire diversi livelli di astrazione (ad esempio sottosistema, applicazione, progetto, modulo, classe, metodo) che consentono di scomporre il codice in unità comprensibili con relazioni chiare tra loro e poche dipendenze.


1
Mentre c'è qualche merito nel tuo suggerimento, le righe di codice non contano davvero, il comportamento lo fa. Se il tuo metodo sta facendo più di una cosa, probabilmente è il momento di riformattarlo. Se quella cosa è solo chiamare metodi che fanno una cosa da soli, e metterli insieme, va bene.
Jer

1
@jer: è una regola empirica, ovviamente. Un metodo che chiama altri 100 metodi è, come dici tu, semplicemente unendo le cose (sta chiamando un elenco di sotto-funzioni). Sto più pensando a metodi che contengono una vera logica: normalmente è un brutto segno se devi scorrere molto avanti e indietro per capire cosa sta facendo un metodo. Stessa cosa se guardi una definizione di classe con molti membri (e la classe non è solo una grande raccolta piatta di proprietà).
Giorgio,

"il progetto contiene più di 50 classi, decomponelo" non è grave
dinamica

@ yes123: doveva dare un'idea. Dipende davvero da cosa stai sviluppando, in che lingua, ecc.
Giorgio

Penso che sarebbe sensato notare che questo non aiuterà per la progettazione anticipata (dal momento che stai effettuando il refactoring) ma aiuterà a imparare modelli e migliori pratiche che miglioreranno i tuoi progetti futuri.
Craig Bovis,

0

È difficile, quello di cui stiamo veramente parlando è la capacità di astrarre piuttosto che creare un codice migliore, ma due cose ti renderanno migliore e una cosa ti renderà più felice:

"Meglio"

A) Trova il miglior designer che puoi e abbina il programma / fai un disegno insieme. Chiedi loro di spiegare cosa stanno pensando mentre affrontano il problema, non accontentarti di "sembra giusto" e continuare a scavare. Tale processo aiuterà anche la parte del "mentoring"

B) Immagina tutto come singoli attori e conversazioni tra di loro. Ciascuno degli attori dovrebbe avere un unico ruolo / responsabilità e gruppi di essi gestiscono sistemi diversi. Se quella conversazione funziona e ogni attore si sente coerente e coeso allora sei sulla buona strada.

E "più felice"

C) Se hai fatto del tuo meglio e non sta ancora accadendo, non c'è niente di sbagliato nell'accettare che alcune persone non possono fare alcune cose. Potresti scrivere un codice stretto e brillante, ma non essere mai in grado di progettare o progettare. E allora? Non riesco a praticare sport fisici per il toffee, non sono di bell'aspetto e la mia guida in auto non sarà mai migliore della media. Goditi e utilizza ciò in cui sei bravo.


-1

Nella mia esperienza personale leggere il codice degli altri è una buona fonte di "ispirazione". Voglio dire, cerca di capire i disegni degli altri e chiediti perché fa le cose in quel modo?

puoi trovare molti progetti open source per la ricerca.

comunque hai bisogno di pratica.


-1

Non vivere nella paura

Cerca la semplicità

Ascolta i tuoi utenti

Prova molte idee

Crea qualcosa, quindi miglioralo

Lavora su cose che aggiungono valore, abbandona cose che non lo fanno


-1

Impara a porre le domande giuste. Il più delle volte migliorerai il tuo design guardando il problema da una prospettiva diversa. In particolare, questo ti aiuterà ad allontanarti dalla concentrazione sulla risoluzione del problema attuale e ad approfondire le soluzioni che risolvono molteplici problemi correlati.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.