[.NET] Perchè il goto è così usato?

[DioBrando]

Originariamente inviato da WhiteWolf42

l'ho usato una volta .... voto -> 2, da quel momento ho capito ... goto-> BRUTTO

"Scusa Egon ho sempre fatto confusione tra bene e male...che intendi?"
"Immagina che la vita per come la conosci si fermasse instantaneamente e le particelle esplodessero alla velocità della luce..."

[DioBrando]

Originariamente inviato da guyver

allora se un programmatore ha i cosiddetti OO
può usare il goto per velocizzare il codice (vedi linus) se riesce a non fare casini e anche se si perde di leggibilità e manutenzione, in alcuni casi, dove la performance viene prima di tutto può essere accettato..?

una specie di tricks da usare con coscenza e metodo...

tralasciando Linus&co, quella delle performance è una baggianata colossale ormai Sono stati scritti fiumi di inchiostro ma con i compilatori JIT che ci ritroviamo ora, il calo di prestazioni è pressochè irrilevante ed è questo il motivo per cui in questi ultimi anni lo sviluppo si è spostato ad un livello di astrazione + alto con i linguaggi interpretati che hanno preso piede in praticamente tutte le branche di sviluppo del software.
Poi d'accordo, ti serve un'applicazione che giri in ambiente realtime, magari mission critical (siamo già in un contesto di ampia minoranza) e causa forza maggiore parte del codice sarà Assembly (riduciamo ancora di + la fetta di cui sopra), qui userai probabilmente dei GoTo...sì ma nicchia...

[kernel::panic]

Originariamente inviato da DioBrando

quella delle performance è una baggianata colossale ormai Sono stati scritti fiumi di inchiostro ma con i compilatori JIT che ci ritroviamo ora, il calo di prestazioni è pressochè irrilevante ed è questo il motivo per cui in questi ultimi anni lo sviluppo si è spostato ad un livello di astrazione + alto con i linguaggi interpretati che hanno preso piede in praticamente tutte le branche di sviluppo del software.

Se mi parli delle performance tra linguaggi compilati in codice macchina e compilati in IL ti do pienamente ragione
Mi sono ricreduto anche io lavorando sia in c++ che in c#: a parte il tempo di startup maggiore dovuto al compilatore JIT l'esecuzione di codice managed è davvero molto veloce, in alcuni casi meglio del codice unmanaged. E soprattutto quando metti l'applicazione su un IA64 non devi ricompilare


Rigurado invece la velocità (all'interno dello stesso linguaggio) tra goto ed exception non sono d'accordo:

static void Main()
{
    int t = Environment.TickCount;
    for(int i = 0; i < 1000000; ++i) Exce();
    Console.WriteLine("EXCE: {0} ms", Environment.TickCount - t);

    t = Environment.TickCount;
    for(int i = 0; i < 1000000; ++i) GoTo();
    Console.WriteLine("GOTO: {0} ms", Environment.TickCount - t);

    Console.ReadKey();
}

static void Exce()
{
    try
    {
        for(int i = 0; i < 10; ++i)
        {
            if(i == 5)
                throw new Exception();
        }
    }
    catch
    { }
}

static void GoTo()
{
    for(int i = 0; i < 10; ++i)
    {
        if(i == 5)
            goto Exit;
    }
    Exit: ;
}

Chiaramente è un caso limite, però sul mio PC i risultati sono:

EXCE: 32422 ms
GOTO: 16 ms

Byez

[tomminno]

Originariamente inviato da ^TiGeRShArK^

imho è sicuramente così.
Anche in java, utilizzando diversi decompilatori, in certi casi si ottiene nel codice una label e delle GOTO che ovviamente in java non hanno senso.
Quindi è un artefatto derivante dalla non perfetta decompilazione del bytecode piuttosto che un'incapacità dei programmatori che hanno scritto .Net

Magari sarà così per Java.
Peccato che se scarichi i sorgenti del .NET sono identici a quelli visti con Reflector.
Quindi nessun errore di decompilazione.
Hanno usato il goto anche in codice C#.

[kernel::panic]

Siccome stanno facendo manutenzione al server col DB, e quindi per ora non ho una mazza da fare , per par condicio ho fatto lo stesso esempio in c++ (anche qui il goto è più veloce):

#include <windows.h>
#include <iostream>

void Exce()
{
    try
    {
        for(int i = 0; i < 10; ++i)
        {
            if(i == 5)
				throw std::exception();
        }
    }
    catch(...)
    { }
}

static void GoTo()
{
    for(int i = 0; i < 10; ++i)
    {
        if(i == 5)
            goto Exit;
    }
	Exit: ;
}

int main()
{
    DWORD t = GetTickCount();
    for(int i = 0; i < 1000000; ++i) Exce();
	std::cout << "EXCE: " << (GetTickCount() - t) << " ms" << std::endl;

    t = GetTickCount();
    for(int i = 0; i < 1000000; ++i) GoTo();
    std::cout << "GOTO: " << (GetTickCount() - t) << " ms" << std::endl;

	char c;
	std::cin >> c;
	return 0;
}

Risultati:

EXCE: 5016 ms
GOTO: 0 ms

[cionci]

Originariamente inviato da kernel::panic

Risultati:

EXCE: 5016 ms
GOTO: 0 ms

Questo perché il compilatore si è accorto che nel for non viene fatto niente
Evidentemente con il goto questa ottimizzazione esiste, mentre con le eccezioni no.

[^TiGeRShArK^]

Originariamente inviato da tomminno

Magari sarà così per Java.
Peccato che se scarichi i sorgenti del .NET sono identici a quelli visti con Reflector.
Quindi nessun errore di decompilazione.
Hanno usato il goto anche in codice C#.

da dove si scaricano i sorgenti del .net?

[kernel::panic]

Originariamente inviato da cionci

Questo perché il compilatore si è accorto che nel for non viene fatto niente
Evidentemente con il goto questa ottimizzazione esiste, mentre con le eccezioni no.

Cavolo, c'hai troppo ragione! Non pensavo che il compilatore se ne accorgesse

Modificando i for così:

if(i == 5)
{
    GetTickCount();
    throw std::exception();
}

if(i == 5)
{ 
    GetTickCount();
    goto Exit;
}

ottengo:

EXCE: 5017 ms
GOTO: 16 ms --> Come nel C#

Quindi si deduce che:
- Il compilatore VC++ e più intelligente del VC#
- Le eccezioni del C++ sono molto più veloci che nel C# (sempre che anche qui non ci siano ottimizzazioni solo in C++)
- I goto si equivalgono in C++ e C#

[fek]

Originariamente inviato da 71104

la fai facile, ma le classi ScopedFileWrapper e ScopedMutexWrapper chi le scrive?
se stai per dire che me le scrive MFC/ATL, o wxWidgets, o qualche altro framework, mi va benissimo: infatti in quei casi i goto non li uso

Te le scrivi tu se ne hai voglia, sono tre righe di codice, due se sai usare i template. Altrimenti usi boost.

a volte la uso per allinearmi alle nomenclature usate da Microsoft, ma mi sfugge dov'è che l'ho usata in questo topic

La vecchia nomenclatura MS era sbagliata.

[fek]

Originariamente inviato da 71104

per quanto riguarda l'uso dei distruttori: non so come giustificarlo alle mie teorie di ingegneria del software (tipo caso di dissonanza cognitiva ), ma creare una classe apposta per ogni tipo di risorsa che alloco mi sembra costituire una perdita di tempo

Prendere in mano un libro e imparare ad usare i template ti sembra una perdita di tempo?

[tomminno]

Originariamente inviato da ^TiGeRShArK^

da dove si scaricano i sorgenti del .net?

Qui

[fek]

Originariamente inviato da kernel::panic

Siccome stanno facendo manutenzione al server col DB, e quindi per ora non ho una mazza da fare , per par condicio ho fatto lo stesso esempio in c++ (anche qui il goto è più veloce):

Le eccezioni NON si usano per uscire dai cicli!

[kernel::panic]

Originariamente inviato da fek

Le eccezioni NON si usano per uscire dai cicli!

Lo so (infatti è meglio che il mio capo non veda quel codice ), era solo di esempio...

Originariamente inviato da tomminno

Qui

Molto interessante, grazie!

[^TiGeRShArK^]

Originariamente inviato da tomminno

Qui

tnx

[fek]

Nel frattempo quel linguaggio senza goto scritto da una scimmia (Python), mi ha fatto perdere una giornata di lavoro.

Eh si', e' troppo complesso dirmi che ho dimenticato di inizializzare una variabile a tempo di compilazione, o almeno inizializzarsela da solo... Me lo deve dire dopo tre ore di esecuzione e con un messaggio di errore che non c'entra nulla

Quanto amo Python... si' si'.

[marco.r]

Originariamente inviato da fek

Nel frattempo quel linguaggio senza goto scritto da una scimmia (Python), mi ha fatto perdere una giornata di lavoro.

Eh si', e' troppo complesso dirmi che ho dimenticato di inizializzare una variabile a tempo di compilazione, o almeno inizializzarsela da solo... Me lo deve dire dopo tre ore di esecuzione e con un messaggio di errore che non c'entra nulla

Quanto amo Python... si' si'.

Se scrivevi i test per quel codice l'errore lo trovavi ben prima .
C'e' una tecnica di sviluppo chiamata Test Driven Development che e' una bomba per questo tipo di problemi, potresti farci un pensierino




Si scherza eh !

[banryu79]

Originariamente inviato da marco.r

Se scrivevi i test per quel codice l'errore lo trovavi ben prima .
C'e' una tecnica di sviluppo chiamata Test Driven Development che e' una bomba per questo tipo di problemi, potresti farci un pensierino

A fek glielo vai a dire? Ma lol

[^TiGeRShArK^]

Originariamente inviato da marco.r

Se scrivevi i test per quel codice l'errore lo trovavi ben prima .
C'e' una tecnica di sviluppo chiamata Test Driven Development che e' una bomba per questo tipo di problemi, potresti farci un pensierino




Si scherza eh !

secondo me dovrebbe prendere qualche lezione da settantunomilacentoquattro

[fek]

Originariamente inviato da marco.r

Se scrivevi i test per quel codice l'errore lo trovavi ben prima .
C'e' una tecnica di sviluppo chiamata Test Driven Development che e' una bomba per questo tipo di problemi, potresti farci un pensierino

Mi dai un link che lo mando in giro qui?

[DioBrando]

Originariamente inviato da fek

Mi dai un link che lo mando in giro qui?

Paiton TìDìDì


per il diveloper che non deve chiedere mai