# [OT] Molti programmi usano l'infame goto... perché?

## daniele_dll

distcc mi è appena caduto dalle braccia  (in senso metaforico)   :Crying or Very sad:   :Crying or Very sad: 

è la seconda volta che vedo in un codice sorgente C l'utilizzo del goto   :Shocked:   :Shocked:   :Shocked:   :Crying or Very sad:   :Crying or Very sad: 

randomaze: Ho splittato questo topic da questo thread

----------

## Peach

 *daniele_dll wrote:*   

> è la seconda volta che vedo in un codice sorgente C l'utilizzo del goto      

 

beh è possibile che abbiano svolto a manina delle tail recursions  :Smile: 

----------

## gutter

 *daniele_dll wrote:*   

> 
> 
> [CUT]
> 
> è la seconda volta che vedo in un codice sorgente C l'utilizzo del goto      

 

Non vedo tutto questo dramma, se è un token del linguaggio un motivo ci sarà o pensi che coloro che hanno creato il linguaggio (K&R) erano degli incompetenti   :Evil or Very Mad: 

Cerchiamo di pensare a quello che diciamo   :Wink: 

----------

## randomaze

 *daniele_dll wrote:*   

> è la seconda volta che vedo in un codice sorgente C l'utilizzo del goto 

 

```
#cd /usr/src/linux/mm

#grep "goto " * | wc -l 

420

#cd ../net

#grep "goto " * | wc -l 

63

```

 :Rolling Eyes: 

----------

## daniele_dll

 *Peach wrote:*   

>  *daniele_dll wrote:*   è la seconda volta che vedo in un codice sorgente C l'utilizzo del goto       
> 
> beh è possibile che abbiano svolto a manina delle tail recursions 

 

programmo da tanti anni e non ho mai avuto la necessità di usare il goto...e credo che per evitare "incasinamenti" nel codice si eviti principalmente l'uso

immagina un'unica funzione...di 5000 righe...con 100 goto...se devi seguire la "logica" del codice...che fai? ti getti giù da un ponte :\

------

 *gutter wrote:*   

>  *daniele_dll wrote:*   
> 
> [CUT]
> 
> è la seconda volta che vedo in un codice sorgente C l'utilizzo del goto       
> ...

 

io ci penso e ci rifletto su e ti rispondo con quello che ho risposto su

e ps... il fatto che qualcosa ci sia non vuol dire che sia una cosa buona usarla, non vuol dire che sia una cosa inteliggente usarla e non vuol dire che non ci siano altri modi migliori per farlo

------

 *randomaze wrote:*   

>  *daniele_dll wrote:*   è la seconda volta che vedo in un codice sorgente C l'utilizzo del goto  
> 
> ```
> #cd /usr/src/linux/mm
> 
> ...

 

perfetto...esattamente come ho risposto su...

...

usare goto vuol dire rendere complicata la vita ad un programmatore che vuole prendersi in mano il sorgente e studiarlo...

se usi goto...lo metti dentro un if...e allora...xche usare un goto e non mettere direttamente il codice li dentro? allora mi risponderai...magari è usato in + punti in una funzione...perfetto allora per maggiore facilità si crea una funzione...e si mette tutto li dentro, proprio per maggiore flessibilità

il fatto che tu mi abbia tirato in ballo il kernel e che li venga usato non vuol dire perfettamente nulla...tu, sai meglio di me, le dimensioni del kernel linux, quanto sono grandi i sorgenti, e cosa vuol dire mettersi a spulciare una grande funzione che fa avanti ed indietro per gestire un qualcosa

il fatto che venga usato...non vuol dire molto...poi, persoalmente lo abborro, ma in generale, e credo che anche tu sarai daccordo, rende più difficoltosa la comprensione di un sorgente...xche non solo devi saltare da una funzione ad un'altra ma se dentro la funzione devi fare avanti e indietro nel codice stesso per capire...beh...poi magari mettici che in base ad un ifdef ci stanno più sezioni richiamate da un sol goto...li è da suicidio ^^

poi ognuno la pensa come gli pare di certo io non ti costringo in niente ed in nulla ^^ e non so se parli per esperienza (quindi di programmazione e di tentate letture di codice criptico strutturato admuzzum) o se parli tanto per invilarti nella discussione

il kernel, come Xfree e tanti altri "mastodondi" sono considerati, per l'appunto, mastodondi troppo complessi da gestire e mantenere facilmente, tanto che sono nate svariate riscritture di X, ed in particolare una del kernel, la HURD, che se mi permetti, credo che sia il TOP, e questo non da ora ma da tempo solo che, come tanti bei progetti, è stato discontinuato.

Ogni cosa ha i suoi difetti...non esiste la perfezione...è inutile che mi fai vedere il numero di righe nel quale è usato il goto...a cosa servirebbe? a dire si lo usa anche il kernel linux? e quindi? cosa hai concluso? hai idea di quante persone ci lavorano sul kernel linux? hai idea di cosa vuol dire gestire una bestia del genere e doversi trovare a saltellare da un punto ad un'altro? hai idea del perche è cosi difficile potersi agganciare a questo tipo di progetti? proprio perche è difficile muoversi all'interno del sorgente...non metto in dubbio che essendo grandi non è stato facile progettarlo, ma ti assicuro che le pecché della progettazione vengono sempre a galla dopo...mesi, anni...tanto tempo, ma vengono a galla e per risistemare certi problemi, ammesso che siano sistemabili, ci vuole tempo, spesso tempo che non si ha. Se il kernel fosse perfetto non ci continuerebberò a lavorare per togliere problemi e altro, ma aggiungerebberò il supporto per nuove periferiche  :Smile: 

cmq...questo non vuole essere ne un'attakko ne nulla, ma solo uno spunto di riflessione ^^

ciauz

PS: dopo di che il thread mi sa che è andato al quanto ot ^^

[EDIT]

http://www.web-hits.org/txt/codingunmaintainable.html

se volete ridere...

scendete nella sezione

Tricks In Offbeat Languages

e poi scendete nella parte relativa al delphi e al pascal

----------

## randomaze

 *daniele_dll wrote:*   

> il fatto che venga usato...non vuol dire molto...poi, persoalmente lo abborro, ma in generale, e credo che anche tu sarai daccordo, rende più difficoltosa la comprensione di un sorgente...

 

Mediamente si, tuttavia se per non usare il goto devi usare un kilo di variabili booleane per valutare il come mai é uscito da un loop o altro, beh, non é detto che senza il goto sia piú leggibile.

In definitiva, anche il goto puó servire, dipende da come lo si usa, certo il vederlo usare fa storcere il naso anche a me ma capisco che una label di goto ben data puó essere piú leggibile di altri acrocchi fatti proprio per evitare il goto.

 *Quote:*   

> PS: dopo di che il thread mi sa che è andato al quanto ot ^^

 

 :Embarassed:  vero.... se vogliamo continuare con questa discussione lo splitto...

----------

## daniele_dll

penso, che se la portiamo avanti in modo costruttivo, possa essere molto interessante e istruttivo  :Smile: )))

anche xche è un'argomento che penso possa essere ritenuto hot  :Smile: 

----------

## randomaze

 *daniele_dll wrote:*   

> penso, che se la portiamo avanti in modo costruttivo, possa essere molto interessante e istruttivo )))

 

Ok, ho splittato il topic. Spero che il titolo sia di vostro gradimento  :Razz: 

----------

## daniele_dll

 *randomaze wrote:*   

>  *daniele_dll wrote:*   penso, che se la portiamo avanti in modo costruttivo, possa essere molto interessante e istruttivo ))) 
> 
> Ok, ho splittato il topic. Spero che il titolo sia di vostro gradimento 

 

ho la sensazione che riceverò molti colpi di frusta ^^

cmq

 *Quote:*   

> 
> 
> Mediamente si, tuttavia se per non usare il goto devi usare un kilo di variabili booleane per valutare il come mai é uscito da un loop o altro, beh, non é detto che senza il goto sia piú leggibile.
> 
> In definitiva, anche il goto puó servire, dipende da come lo si usa, certo il vederlo usare fa storcere il naso anche a me ma capisco che una label di goto ben data puó essere piú leggibile di altri acrocchi fatti proprio per evitare il goto.
> ...

 

mediamente no :DDD

nel senso che se faccio...

```

if (asd) {

  goto XYZ;

}

```

o se faccio

```

if (asd) {

  /* codice dentro il goto XYZ; */

}

```

non c'è differenza  :Smile: 

al max mi faccio una macro che [se chi programma non applica la faq che ho postato poco fa] la mette all'inizio del codice sorgente o in unico file  :Smile: 

o per lo meno...io lo usavo quando programmavo in vb per dos...ma è passato abbastanza tempo e credo che facendo esperienza si ci rende conto che certi costrutti e meglio evitarli per esempio, per "prassi" di solito si usa di solito il while e non il do until (se non ricordo si chiama cosi) per evitare confusione a chi legge

chi legge il codice non solo deve capire il codice cosa fa...ma cosa voleva fargli fare lo sviluppatore quando lo ha scritto e quindi capire come ragionava in quel momento xche se non si capisce il ragionamento che ha fatto lo sviluppatore per arrivare a quel punto, se non si capisce quale fulmine lo ha trapanato si impiega 100 volte di + per studiarsi il sorgente e ci sono costrutti che decisamente lo rendono + complesso questo lavoro :\

poi...come torno a ripetere...è un'opinione personale derivata da mie esperienze ^^

----------

## randomaze

 *daniele_dll wrote:*   

> ...io lo usavo quando programmavo in vb per dos...ma è passato abbastanza tempo e credo che facendo esperienza si ci rende conto che certi costrutti e meglio evitarli per esempio, per "prassi" di solito si usa di solito il while e non il do until (se non ricordo si chiama cosi) per evitare confusione a chi legge

 

Ribadisco, ci sono casi in cui otterresti l'effetto contrario incrementando il mal di testa di chi legge che si troverebbe a dover seguire vari if annidati e strane condizioni, ad esemio se tu avessi uno spezzone complesso in cui il programmatore ha cercato di fare qualcosa di simile ai try/catch di Java...

----------

## federico

Penso che in un programma piccolo e snello l'utilizzo della funzione goto sia facile da evitare e consigliabile da evitare, tuttavia posso immaginare che in alcune applicazioni -veramente grandi- possano esserci dei casi in cui un goto risolverebbe il problema della riscrittura di migliaia di righe di codice  :Smile: 

Del resto tutti i software sono in continuo sviluppo, saranno probabilmente casi che verranno sistemati un futuro !

----------

## Sparker

Nel mio vecchio libro di cobol c'era un capitolo intitolato "Il famigerato goto"   :Laughing: 

----------

## GhePeU

 *daniele_dll wrote:*   

> 
> 
>  tanto che sono nate svariate riscritture di X, ed in particolare una del kernel, la HURD, che se mi permetti, credo che sia il TOP, e questo non da ora ma da tempo solo che, come tanti bei progetti, è stato discontinuato.
> 
> 

 

io la sapevo diversa la storia

----------

## n3m0

Dando una scorsa ho visto che si parla per la maggiore del goto in relazione alla leggibilità del codice.

Bisognerebbe parlarne anche in relazione al contributo di prestazionale che può dare in grandi applicazioni che per natura devono risparmiare, quanto più è possibile, sul numero di cicli di clock: compilatori, sistemi operativi, etc.

In strutture codizionali molto complesse, per evitare i goto (regola santa di buona programmazione, che pero' sfuma di fronte allo sviluppo di un sistema operativo, ad esempio) si finisce con lo scrivere test in più (altri cicli di clock), strutture if-then-else annidate e complicate (altri cicli di clock e perdita di leggibilità).

Un esempio di codice con goto: 

```

if (a) goto SALTO;

op;

op;

op;

if (b) goto SALTO;

op;

op;

if (c) goto SALTO;

op;

op;

op;

op;

SALTO: op; op; ...
```

Per tradurre tale codice in una forma "senza goto", bisognerebbe introdurre cose (scusate se vado sul vago, ma non sono proprio sveglio e pimpante) come: 

1. Test su condizioni in OR. Questo obbliga a controllare insieme le tre condizioni, quando non sempre è necessario.

2. Introduzioni di Else. Il codice prodotto dal compilatore per un if-then-else dovrebbe costare un ciclo di clock in più (ma posso errare) rispetto alla soluzione con if-goto.

3. Test ripetuti sulla stessa condizione. Altro overhead.

4. Il flusso di "SALTO" potrebbe non essere confinabile nella sezione IF o ELSE e pertanto potrebbe necessitare la scrittura di una funzione, la cui chiamata causerà uso ulteriore dello stack, etc. Altro overhead.

E' per questo che nel kernel spesso il goto si incontra in quelle sezioni di codice che costituiscono parti del kernel invocate spesso.

E' chiaro che se l'applicazione non e' un software critico come un SO, un compilatore, un software matematico, è buona cosa NON usare il goto.

Spero, col sonno che ho, di non aver detto troppe cavolate  :Wink: 

----------

## gutter

Per riallacciarmi al discorso di n3m0 posso dire che non sempre il GOTO è male e che le prestazioni a volte possono essere più importanti della leggibilità del codice, si pensi ad esempio al codice autogenerato da bison (o yacc) tali applicativi (parser) fanno grande uso del GOTO per la costruzione dell'automa a stati finiti che analizzerà il file che gli passerete e come ha sottolineato n3m0 l'overhead che si genera dal calcolo di condizioni booleane e dalle chiamate a funzioni può essere inutile.

----------

## randomaze

 *GhePeU wrote:*   

> io la sapevo diversa la storia

 

la storia é diversa... ma non ho corretto perché comunque il tema era un'altro...

----------

## n3m0

 *gutter wrote:*   

>  bison (o yacc) tali applicativi (parser) fanno grande uso del GOTO per la costruzione dell'automa a stati finiti

 

Già, anche se in teoria la gestione di NFA e DFA andrebba fatta a matrici di accesso e simili, grossa è la corrente dei sostenitori del mapping degli stati degli automi sulle label e, quindi, del relativo utilizzo di GOTO.

----------

## fedeliallalinea

Basta che non si abusi del goto poi che ogni tanto si usi non vedo neanche io il dramma.

----------

## daniele_dll

boh, io anche per principio evito di usare il goto, xo giustamente i miei soft non toccano milioni di righe di codice poi non so ^^

come ho detto su è una mia opinione personale

cmq...invece di fare...

```

if (a) goto SALTO;

op;

op;

op;

if (b) goto SALTO;

op;

op;

if (c) goto SALTO;

op;

op;

op;

op;

SALTO: op; op; ...

```

se si fa...

```

if (a) SALTO;

op;

op;

op;

if (b) SALTO;

op;

op;

if (c) SALTO;

op;

op;

op;

op;

function SALTO() {op; op; ...}

```

non è meglio? non è + facile gestire anche il codice?

certo...le prestazioni magari diminuiscono...ma...di quanto? se il soft ad eseguirsi ci sta 0.000000000000002 invece di 0.000000000000001 (sono numeri solo per fare un'esempio perché non credo che possa essereci una reale e pratica differenza)

da un punto di vista di soft embedded allora si, li lo potrei anche capire xche c'è poco spazio, poca memoria e processori (anche se per modo di dire) lenti

(PS: randomaze potresti chiarirmi in pvt la storia ^^ non mi piace dire faggianate  :Smile: ))

----------

## fedeliallalinea

Si ma se poi quella funzione la esegue tante volte anche i piccoli numeri risultano grossi

----------

## =DvD=

Se usato in modo infame anche un if è orribile.  :Wink: 

----------

## n3m0

 *daniele_dll wrote:*   

> boh, io anche per principio evito di usare il goto, xo giustamente i miei soft non toccano milioni di righe di codice poi non so ^^

 

Non alludevo al numero di LOC (righe di codice), ma di quanto importante sia il guadagno anche di un singolo ciclo di clock all'interno di particolari software (che poi, quelli che hanno questa esigenza spesso sono enormi, non c'entra nulla).

 *daniele_dll wrote:*   

> non è meglio?

 

Non è detto. Dipende se ti serve performance estrema o no.

 *daniele_dll wrote:*   

> non è + facile gestire anche il codice?

 

Sicuramente, ma continui a guardare la questione dal lato leggibilità/manutenibilità del codice.

Purtroppo, ripeto, in determinate circostanze, i parametri a cui fai riferimento sacrificano le performance. 

Quella chiamata a funzione costa in termini di battiti di clock di più rispetto al goto.

 *daniele_dll wrote:*   

> se il soft ad eseguirsi ci sta 0.000000000000002 invece di 0.000000000000001  (sono numeri solo per fare un'esempio)

 

se la funzione in questione è, per esempio, la wake_up_process o la context_switch del kernel, allora conta; se pensi a quante volte vengono chiamate in tempi impercettibili per un essere umano e quanto è importante che occupino il minor tempo possibile...

 *fedeliallalinea wrote:*   

> Si ma se poi quella funzione la esegue tante volte anche i piccoli numeri risultano grossi

 

Per l'appunto

----------

## daniele_dll

 *fedeliallalinea wrote:*   

> Si ma se poi quella funzione la esegue tante volte anche i piccoli numeri risultano grossi

 

ok...x vedere le differenze nei tempi di esecuzione...ho fatto questo codicillo  :Smile: 

in pratica esegue le stesse operazione...in una ci sta il goto e nell'altra no ma fanno le stesse cose...ovvero nell'if, invece di inserire il codice ho inserito un goto e il codice dell'if l'ho messo nel goto, nel primo bench, mentre nel secondo l'ho lasciato nell'if

ho compilato con questi parametri

```

gcc ./bench_goto.c -o bench_goto -lm -O3 -pipe -fomit-frame-pointer

```

i risultati sono stati questi (l'ho lanciato 3 volte);

```

Testing goto...

Average Execution time for 50 testes: 0.180200s

Testing without goto...

Average Execution time for 50 testes: 0.180000s

```

---

```

Testing goto...

Average Execution time for 50 testes: 0.179800s

Testing without goto...

Average Execution time for 50 testes: 0.180000s

```

---

```

Testing goto...

Average Execution time for 50 testes: 0.180000s

Testing without goto...

Average Execution time for 50 testes: 0.180200s

```

ora, come si può notare...se il codice che ho scritto per fare il test ha senso (lo trovate all'indirizzo http://www.phpsoft.it/private/bench_goto.c )

le differenze con i tempi di esecuzione sono quasi nulli...xche praticamente ho richiamato la funzione 50 volte...e dentro la funzione c'è un ciclo che gira 10.000.000 di volte e che esegue semplici operazioni, un'if ed anche una radice quadrata (tanto per fargli fare qualcosa)

quindi (ripeto se il codice che ho scritto effettivametne serve a qualcosa) le effettive differenze a questo punto sono non tanto nei tempi di esecuzione (perché le differenze con tutti questi cicli sono solo di 2 millisecondi un po qua ed un po la) ma credo principalmente da un punto di vista di leggibilità

ora non metto in dubbio che il test non copre (se valido) il 100% dei casi, ma credo che una buona percentuale di casi possano essere coperti, e in quei casi che non sono coperti, anche se il tempo di esecuzione è superiore...siamo sempre li...su tutti quei cicli (50 per 10 milioni) le differenze sono state di due millesimi...quindi anche in casi + complessi...per farla sporca...possono diventare 5 volte tanto in +? si può arrivare alla differenza di 10 millesimi? 50 millesimi di differenza? credo che non siano tempi cosi lunghi da metterli davanti alla leggibilità e alla manutentabilità del codice

PS: ovviamente ci sono i casi dove, come dici tu su, i tempi di esecuzione sono vitali e anche i 2 millesimi sono importanti...ma sono casi rari, credo che più qui sia una questione generale  :Smile: 

----------

## fedeliallalinea

Questo bench mark non ha nessun senso

----------

## n3m0

Ah, inoltre: 

 *daniele_dll wrote:*   

> cmq...invece di fare...
> 
> ```
> 
> if (a) goto SALTO;
> ...

 

Nel primo caso (con i goto) se in IF(a) faccio un jump a SALTO, il codice dopo l'IF(a) non verrà eseguito, mentre come hai scritto tu, il codice ritornerà dalla funzione SALTO() ed eseguirà lo stesso il codice dopo l'IF(a).

E così via per i restanti.

Questo ti fa capire che dovresti ancora riorganizzare il codice in altre funzioni (altre chiamate, altro overhead), magari altre verifiche di condizioni (altro overhead), etc.

----------

## daniele_dll

 *fedeliallalinea wrote:*   

> Questo bench mark non ha nessun senso

 

quello che volevo fare era vedere le differenze in tempi di esecuzione dello stesso codice con un goto e senza goto

----------

## daniele_dll

pardon non avevo fatto caso a questo ^^

----------

## fedeliallalinea

Il tuo codice fa il salto a una funzione sia nel caso goto (che poi verra' eeseguito una solo volta per loop) che nel caso senza goto. Non e' questo che si vuole creare

----------

## daniele_dll

 *fedeliallalinea wrote:*   

> Il tuo codice fa il salto a una funzione sia nel caso goto (che poi verra' eeseguito una solo volta per loop) che nel caso senza goto. Non e' questo che si vuole creare

 

mmm

a parte questo ho appena notato un piccolissimo errore ^^

----------

## daniele_dll

reuppato...cosi va meglio?   :Embarassed: 

----------

## stefanonafets

<OT in OT>

Sorry, mi introduco interessato in questa discussione per chiedervi:

cerco doc su programmazione in C in ambiente unix...

Apparte il gapil (del quale nn capisco una benedetta ma**a (nn è vero, ma cmq per me è ancora troppo)), premesso che 2 stron*ate le so fare (e conosco discretamente java), qualcuno sa dirmi cosa posso prendere in mano per imparare???

E poi le api delle librerie (stdio ecc...) dove le trovo??

Grazie!!!!

</OT in OT>

----------

## randomaze

 *stefanonafets wrote:*   

> premesso che 2 stron*ate le so fare (e conosco discretamente java), qualcuno sa dirmi cosa posso prendere in mano per imparare???
> 
> E poi le api delle librerie (stdio ecc...) dove le trovo??
> 
> 

 

La bibbia incontrastata resta il Kernighan & Richie.

----------

## daniele_dll

e, se lavori su linux, usa le man pages  :Smile: 

man printf

man clock

man epoll

e cosi via  :Smile: 

----------

## n3m0

@stefanonafets: diciamo che ti leggi bello tutto il Kernighan come anche randomaze ti ha raccomandato.

Poi ti scoli qualche libro accessorio, poi un bel GaPiL, un bel Advanced Programming in Unix Enviroment di Stevens. Ci aggiungerei anche Object Oriented Programming in ANSI C.

Se ti interessa altro, fammi sapere  :Smile: 

----------

## stefanonafets

thx (<- no, è un TM della Lucas...  :Very Happy:  )

Grazie!!!

----------

## Peach

Tornando IT penso che tutti sappiano che il GOTO è considerato attualmente contrario ai principi della programmazione strutturata.

Storicamente parlando ha avuto il suo senso ed era risultato utile per l'uscita da centro di un loop, il ritorno di un sottoprogramma e per gestire le eccezioni, ma molte erano le problematiche che aveva suscitato questo tipo di istruzione al punto da accendere un vivo dibattito che sfociò pure in una pubblicazione considerata storica per le conclusioni a cui arriva Dijkstra (Go To Statement Considered Harmful - 1968).

Ora nei linguaggi di cui disponiamo ci sono altri modi per uscire dai loop (while, for, if then else, ...) e per gestire le eccezioni, senza parlare che java manco più ce l'ha come costrutto.

Penso che l'uso dell'istruzione GOTO sia usata soltanto per motivi di ottimizzazione del codice, diciamo, anticipando quasi quello che in linea teorica dovrebbe fare il compilatore.

Il caso più lampante che conosco personalmente in cui un particolare costrutto viene tradotto in una istruzione GOTO è quello della "Tail Recursion" (ricorsione di coda  :Surprised:  ) ovvero quando la chiamata ricorsiva è l'ultima della procedura.

Per fare un esempio considerate la seguente procedura:

```
int gcd (int a, int b) {

  if (a==b) return a;

  else if (a>b) return gcd(a-b, b);

  else return gcd(a, b-a);

}
```

è esprimibile dal compilatore con una iterazione goto:

```
int gcd (int a, int b) {

start:

  if (a==b) return a;

  else if (a>b) {

    a = a-b;

    goto start;

  } else {

    b = b-a;

    goto start;

  }

}
```

questo evita in fase di esecuzione la creazione di blocchi inutili nel record di attivazione, che invece verrebbe fatta nel caso di continue chiamate ricorsive.

chiaro,no?

----------

## daniele_dll

perfetto...secondo me questo post è stato abbastanza significativo  :Very Happy: 

[OT]

xo...pensate...se non c'ero io come passavate il vostro fine settimana in serenità?  :Smile: 

[/OT]

skerzi a parte

credo che sia un bene discutere su questo tipo di argomenti, che sembrano stupidi, ma uno si chiarisce TANTE idee di fondo e alla base delle sue conoscenze...le chiarisce a se...e studiandoci su le chiarisce agli altri  :Smile: 

danka a todos ^^

----------

## _sys/sid

Non ho letto tutti i post.. ma solo il titolo...

Cos'hai contro il goto... secondo me' se usata QUANDO SERVER e' una cosa molto utile e molto piu' semplice di tutti i vari cicli... E' un po' come i break e i continue...

W il goto quando server... (Battutona !!! quando server... :Laughing:  )

----------

## daniele_dll

 *_sys/sid wrote:*   

> Non ho letto tutti i post.. ma solo il titolo...
> 
> Cos'hai contro il goto... secondo me' se usata QUANDO SERVER e' una cosa molto utile e molto piu' semplice di tutti i vari cicli... E' un po' come i break e i continue...
> 
> W il goto quando server... (Battutona !!! quando server... )

 

il titolo non l'ho messo io, se avessi letto anche solo il primo post avresti capito ^^ [essendo un thread splittato il titolo non l'ho scritto io, anche se, a parte l'infame, calza a pennello  :Smile:  ]

dopo di che l'ho detto cosa ho contro il goto nei vari (tanti) post precedenti

e quando alla leggibilità si mette davanti la performance (soprattutto dove non serve o dove non è richiesta) penso che sia un grave problema...è vero che uno anche usando normalmente la sintassi ma questo è ovvio a priori

cmq quoto a pieno quello detto da Peach  :Smile: 

----------

## gutter

@Peach, davvero un ottimo intervento e davvero interessante l'articolo che hai linkato.   :Wink: 

----------

## n3m0

A questo punto segnalerei anche Structured Programming with GOTO Statement

----------

## Peach

 *gutter wrote:*   

> @Peach, davvero un ottimo intervento e davvero interessante l'articolo che hai linkato.  

 

bisogna ringraziare il mio prof di Paradigmi di Programmazione  :Wink: 

----------

## gutter

 *Peach wrote:*   

> 
> 
> [CUT]
> 
> bisogna ringraziare il mio prof di Paradigmi di Programmazione 

 

Ringrazialo anche da parte mia.   :Wink: 

----------

## randomaze

 *gutter wrote:*   

> Ringrazialo anche da parte mia.  

 

Non sottovalutate neanche il link che ha postato n3m0... IMHO la firma di Donald Knuth vale almeno quanto (se non di più) quella di Dijkstra

----------

## nomadsoul

io penso che l'abbiano usato per difendersi dalla microsoft... almeno ci mettono degli anni prima di poterlo copiare su windows il codice  :Very Happy: 

----------

## gutter

 *randomaze wrote:*   

> 
> 
> [CUT]
> 
> Non sottovalutate neanche il link che ha postato n3m0... IMHO la firma di Donald Knuth vale almeno quanto (se non di più) quella di Dijkstra

 

Senza dubbio, solo che dal momento che l'articolo di knuth è un poco più lunghetto e quindi volevo leggerlo successivamente con calma.  :Wink: 

Sono entrambi ottimi autori non penso che uno sia migliore dell'altro.

----------

