Domanda breve semplice e concisa....

[Danyblu]

Dunque ... cè qualcuno che mi sappia dire solamente quali sono il 2 linguaggi di programmazione piu' diffusi su Pc?? adatti (nel caso mio) alla creazione di Demo ???
scusate il disturbo per questa domanda banale .
Grazie!

[riko]

Dunque ... cè qualcuno che mi sappia dire solamente quali sono il 2 linguaggi di programmazione piu' diffusi su Pc?? adatti (nel caso mio) alla creazione di Demo ???

Demo in "senso" amighista? Se usi OpenGL il linguaggio che usi è tendenzialmente ininfluente. Tuttavia per maggiori performance (e tenendo conto che comunque non hai nessuna necessità di rispettare dettami di forma stile e manutensibilità) direi di farli in C.

Credo che scendere sull'assembly non abbia vantaggi sostanziali su un PC, visto che (fortunatamente) l'OS ti isola comunque dalla macchina.

Direi C o C++. Ma se vuoi lavorare comodo vai di Python e vedi se il tutto è abbastanza veloce per i tuoi gusti (anche se io ho i miei dubbi in questo caso specifico).

Si, direi decisamente C.

[Danyblu]

ok grazie! Si difatti mi era gia stato consigliato i C++ da un amico , era giusto per avere un'idea di quale fosse il piu' diffuso. Ciao!

[riko]

ok grazie! Si difatti mi era gia stato consigliato i C++ da un amico , era giusto per avere un'idea di quale fosse il piu' diffuso. Ciao!

Il più diffuso? Probabilmente è Java (purtroppo). Al secondo posto dovrebbe venire il C. C++ solo terzo. Ma poi per la maggior parte del sw proprietario non ci sono statistiche, quindi in effetti non è facile stabilirlo.

Addirittura alcuni dicono che il linguaggio in cui sono state scritte più linee di codice è il COBOL (e tenendo conto di quanto è verboso, ci credo).

Ad ogni modo la diffusione di un linguaggio non è minimamente un indice della sua bontà. Anzi.

Java a mio parere (e a parere di tanti altri) è una mezza ciofeca. C# poco meglio.

C è un buon linguaggio per quello che deve fare, ma è oltremodo di basso livello. Usarlo per altro è spesso sintomo di masochismo.

C++ gliene hanno combinate parecchie. Diciamo che nella migliore delle ipotesi è un coacervo di buone idee... solo che forse non era il caso di mettercele dentro *tutte*. È il linguaggio più complesso da imparare fra gli imperativlo/object oriented.

Le "regole" del C le impari in due settimane. Ad imparare a programmarci ci metti un lustro. Per le sole "regole" del C++ ci vanno una decina di mesi. Poi bisogna imparare quando usarle, quando no, quando costrutti simili vanno preferiti etc etc etc.

Un linguaggio ancora più caotico è il Perl: ma li puoi usare un approccio di tipo "prova e vedi".

Rimane il fatto che fra i linguaggi imperativi/object oriented i più interessanti sono senza dubbio Python e Ruby.

Un linguaggio davvero bello (ma è un funzionale, per usarlo a pieno bisogna avere un po' di skill teoriche) è Haskell. Piccolo, velocissimo, potentissimo. Forth poi è un piccolo capolavoro. Performance da capogiro, uno dei linguaggi più facili da implementare, risorse minime (i vecchi Mac avevano una shell Forth al posto del BIOS, per darti una misura di quanto poco ciuccia).

Poi volendo c'è Prolog. A modo suo geniale. Ma se mi provocate sui linguaggi posso parlare per delle ore (sono una mia piccola passione).

[ncc-1700]

[snip]....
Poi volendo c'è Prolog. A modo suo geniale. Ma se mi provocate sui linguaggi
posso parlare per delle ore (sono una mia piccola passione).

Parla, parla pure, su questo argomento ti starei ad ascoltare settimane.....

Ciao,
ncc-1700

[Danyblu]

Accipicchia Riko ! in effetti da come ne parli si sente la passione dei linguaggi, tempo fa conoscevo un ragazzo di Quarona che era appassionato parrecchio in Assembly e in meno di due mesi ti preparava degli engine grafici degni di tale nome
ebbravi!!!

[riko]

Parla, parla pure, su questo argomento ti starei ad ascoltare settimane.....

Sul Prolog? Non sono ferratissimo: sto imprecando in questi giorni che devo farmi una full immersion perchè la tesi dovrò farla in Prolog.

Che va anche bene eh...

Beh, comunque questo è il quicksort in Prolog

Codice: Seleziona tutto

quicksort([], []).
quicksort([Pivot|Tail], Sorted) :-
            partition(Pivot, Tail, Smaller, Greater),
                quicksort(Smaller, SmallerSorted),
                    quicksort(Greater, GreaterSorted),
                        append(SmallerSorted, [Pivot|GreaterSorted], Sorted).

partition(_, [], [], []).
partition(Pivot, [Head|Tail], [Head|Smaller], Greater) :-
            Pivot > Head,
                partition(Pivot, Tail, Smaller, Greater).
partition(Pivot, [Head|Tail], Smaller, [Head|Greater]) :-
            Pivot =< Head,
                partition(Pivot, Tail, Smaller, Greater).


Immagina un po' a come descriveresti a parole l'algoritmo e poi leggi il sorgente... se avete bisogno di note sintattiche ve le do.

Comunque Prolog è un linguaggio *logico*. Non imperativo. Non gli dico come deve fare le cose, ma quello che deve cercare di fare.

Invece in ruby (per dirne uno)...

Codice: Seleziona tutto

def qsort(list)
  return [] if list.empty?

  qsort( list.select {|a| a <  list[0]} )  +
         list.select {|a| a == list[0]}    +
  qsort( list.select {|a| a >  list[0]} )
end


Ancora una volta... pensa a quello che diresti a qualcuno se gli dovessi spiegare l'algoritmo... inoltre questi funzionano per tutti i possibili dati che possono essere confrontati con >.


Questo è Java 1.5

Codice: Seleziona tutto


import java.util.Arrays;
import java.util.Random;

public class QuickSort<E extends Comparable<E>> {
    public static final Random RND = new Random();

    private void swap(E[] array, int i, int j) {
        E tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

    private int partition(E[] array, int begin, int end) {
        int index = begin + RND.nextInt(end - begin + 1);
        E pivot = array[index];
        swap(array, index, end);
        for (int i = index = begin; i < end; ++i) {
            if (array[i].compareTo(pivot) <= 0) {
                swap(array, index++, i);
            }
        }
        swap(array, index, end);
        return (index);
    }

    private void qsort(E[] array, int begin, int end) {
        if (end > begin) {
            int index = partition(array, begin, end);
            qsort(array, begin, index - 1);
            qsort(array, index + 1, end);
        }
    }

    public void sort(E[] array) {
        qsort(array, 0, array.length - 1);
    }

    // Example uses
    public static void main(String[] args) {
        Integer[] l1 = { 5, 1024, 1, 88, 0, 1024 };
        System.out.println("l1  start:" + Arrays.toString(l1));
        QuickSort<Integer> qs = new QuickSort<Integer>();
        qs.sort(l1);
        System.out.println("l1 sorted:" + Arrays.toString(l1));

        String[] l2 = { "gamma", "beta", "alpha", "zoolander" };
        System.out.println("l2  start:" + Arrays.toString(l2));
        QuickSort<String> qs2 = new QuickSort<String>();
        qs2.sort(l2);
        System.out.println("l2 sorted:" + Arrays.toString(l2));
    }
}


È perfino più incasinato della versione in assembly per z80

Codice: Seleziona tutto

;
; Usage: bc->first, de->last,
;        call qsort
; Destroys: abcdefhl
;
qsort   ld      hl,0
        push    hl
qsloop  ld      h,b
        ld      l,c
        or      a
        sbc     hl,de
        jp      c,next1 ;loop until lo<hi
        pop     bc
        ld      a,b
        or      c
        ret     z       ;bottom of stack
        pop     de
        jp      qsloop
next1   push    de      ;save hi,lo
        push    bc
        ld      a,(bc)  ;pivot
        ld      h,a
        dec     bc
        inc     de
fleft   inc     bc      ;do i++ while cur<piv
        ld      a,(bc)
        cp      h
        jp      c,fleft
fright  dec     de      ;do i-- while cur>piv
        ld      a,(de)
        ld      l,a
        ld      a,h
        cp      l
        jp      c,fright
        push    hl      ;save pivot
        ld      h,d     ;exit if lo>hi
        ld      l,e
        or      a
        sbc     hl,bc
        jp      c,next2
        ld      a,(bc)  ;swap (bc),(de)
        ld      h,a
        ld      a,(de)
        ld      (bc),a
        ld      a,h
        ld      (de),a
        pop     hl      ;restore pivot
        jp      fleft
next2   pop     hl      ;restore pivot
        pop     hl      ;pop lo
        push    bc      ;stack=left-hi
        ld      b,h
        ld      c,l     ;bc=lo,de=right
        jp      qsloop


E allora andiamo con una versione classica in C

Codice: Seleziona tutto

static void swap(void *x, void *y, size_t l) {
   char *a = x, *b = y, c;
   while(l--) {
      c = *a;
      *a++ = *b;
      *b++ = c;
   }
}

static void sort(char *array, size_t size, int (*cmp)(void*,void*), int begin, int end) {
   if (end > begin) {
      void *pivot = array + begin;
      int l = begin + size;
      int r = end;
      while(l < r) {
         if (cmp(array+l,pivot) <= 0) {
            l += size;
         } else {
            r -= size;
            swap(array+l, array+r, size);
         }
      }
      l -= size;
      swap(array+begin, array+l, size);
      sort(array, size, cmp, begin, l);
      sort(array, size, cmp, r, end);
   }
}

void qsort(void *array, size_t nitems, size_t size, int (*cmp)(void*,void*)) {
   sort(array, size, cmp, 0, (nitems-1)*size);
}


Ad ogni modo i linguaggi di alto livello hanno tutti delle versioni di sort iper-ottimizzate che se la vedono testa a testa con il C (anche perchè a dirla tutta sono generalmente scritte in C).

High level is good!

[ncc-1700]

@Riko

No, non intendevo sul prolog ma sui linguaggi di programmazione in genere, ma quello che hai fatto con il quick-sort è proprio quello che intendevo, mi esalto quando sento e vedo il codice fluire copioso in questo modo. Grandissimo Riko, inventerei la notifica in modalità saccente di linguaggi per sapere quando ti scateni in questo modo, anzi, il tuo sito ha acquisito un indegno fan in più.

Ora vado a ripassare il codice assembly che hai scritto per il quick-sort.

Ciao,
ncc-1700

[riko]

Grandissimo Riko, inventerei la notifica in modalità saccente di linguaggi per sapere quando ti scateni in questo modo, anzi, il tuo sito ha acquisito un indegno fan in più.

Ma figurati... è il mio sito ad essere indegno

Ora vado a ripassare il codice assembly che hai scritto per il quick-sort.

Ti confesso che non lo ho scritto io ma lo ho trovato in rete. Anche molti degli altri sorgenti hanno questa origine (non so più cosa viene da cosa, li ho reperiti sul mio disco). Quello Prolog sicuro non è mio, idem quello Haskell. Ma penso che in realtà nessuno sia mio... voglio dire, la letteratura sul genere è talmente copiosa che si fa prima a cercarli

Appena ho un po' di tempo, magari ci faccio su un bell'articolo in cui spiego un filino come funzionano, performances e tutto... bah, vediamo.

[ncc-1700]

Appena ho un po' di tempo, magari ci faccio su un bell'articolo in cui spiego un filino come funzionano, performances e tutto... bah, vediamo.

Non vedo l'ora, io sono avido di articoli e discussioni pratiche di programmazione.

Ciao,
ncc-1700

[afxgroup]

il Visual Basic è il più diffuso...