Appello di Laboratorio di programmazione del 19 gennaio 2021

Alcune osservazioni sugli errori più comuni fatti (ed evitabili)

• lettura di interi: con bufioscanner.Text() (e anche con fmt.Scan(s string), ma perché?!?

  • Ricordatevi che esiste fmt.Scan(&num) con num int

• Se vi accorgete che fate conversioni avanti e indietro (ad es. int -> string -> int o string -> int –> string), fatevi due domande su se/come evitare la cosa (vedi sopra)

• controlli a posteriori. Es. su os.Args o con !=EOF dopo aver usato il dato che non c’è. Vanno fatti sempre prima

• lettura delle specifiche: spesso è approssimativa (e vi penalizza)

• uso dei test e sistemazione dei FAIL : qualcuno sembra non usarli o non guardare proprio le segnalazioni (e sembra non far girare nemmeno il programma, al di là dei test da noi forniti), non ci fate bella figura, soprattutto quando gli errori sono delle banalità: sorge il legittimo dubbio che non sappiate testare i programmi e/o correggere l’errore. Vi invito quindi a dimostrare di sapere almeno testare, se non correggere. Potreste mettere dei commenti nel codice del vostro programma in cui indicate quali sono i test non passati o gli aspetti che sapete andrebbero sistemati, anche tutti insieme in una sezione “TO DO”.

• ridondanze nel codice: se vedete istruzioni o blocchi di istruzioni che si ripetono identici o quasi in più punti del vostro programma, vede come / se è possibile evitare la ripetizione

• attenzione ad implementare correttamente il pattern precedente-corrente. Nel codice che segue, viene (impropriamente) fatta la conversione di ogni elemento i due volte: all’iterazione i-esima e alla i+1-esima (no comment qui sulla conversione byte-string-int, vedi poi sotto)

for i := 0; i < len(num); i++ {
    cifraAttuale, _ := strconv.Atoi(string(num[i]))
    cifraPrecedente, _ := strconv.Atoi(string(num[i-1]))

Lo schema corretto è il seguente:

for i := 0; i < len(num); i++ {
    cifraPrecedente = cifraAttuale
    cifraAttuale, _ := strconv.Atoi(string(num[i]))
    

• uso della memoria: salvate e tenete in memoria solo quello che non vi serve istante per istante. Ad esempio, se avete un for e un dato che viene usato solo all’iterazione i-esima, non serve che quel dato stia in memoria dall’inizio alla fine.
• if senza else: quanche volta non ci vuole l’else, ma qualche volta sì; in questo caso ci vorrebbe:

if temperatura > max {
    max = temperatura
}
if temperatura < min {
    min = temperatura
}

• lunghezza e capacità di slice: non numeri a caso, soprattutto se la lunghezza finale è nota. Perché 10 qui?
  walk = make([]Location,0,10)
• NO all’uso di codici ASCII. Es lettera = 10; lettera = 32. Usate per favore i letterali ' ' e '\n', oltre a 'a', ecc
• > e < si possono usare anche su byte e rune (a maggior ragione se rappresentano cifre!) (esercizio sequenze ;-) )

// inutile conversione byte ->stringa -> int per fare un confronto
cifraAttuale, _ := strconv.Atoi(string(num[i])) 
if cifraPrecedente <= cifraAttuale {
    numeroAttuale += string(num[i])
} else {
    fmt.Println(numeroAttuale)
    numeroAttuale = string(num[i])
---
//ma i byte sono numeri! Quindi posso fare direttamente 
if num[i-1] <= num[i]

• se la richiesta è di stampare dei valori, (spesso) non occorre salvarli prima in una struttura (slice o stringona) e stamparli poi, si possono stampare man mano, senza usare inutilmente la memoria
• gestione di sotto-problemi: cercate di comporre il più possibile le sotto-soluzioni (vedete lezione del 7/01/21), almeno per questa dimensione di problemi (“programmazione in piccolo”). La modularità ha un suo valore, ma non deve impattare troppo sull’efficienza e la dimensione del codice.
• rand.Seed: il seme va creato, ma solo una volta, e possibilmente nel main del programma (una funzione potrebbe essere poi invocata più volte)

Non so se la lista è completa, ma almeno avete una prima manciata di spunti su cui riflettere e lavorare.