Perché le lingue concorrenti tendono ad avere una sintassi più complicata?

Question

Perché le lingue concorrenti tendono ad avere una sintassi più complicata?

#1 da (7 voti)
#2 da (4 voti)

3

Questa è una domanda che ho pensato per un po '. Recentemente ho controllato linguaggi concorrenti come Haskell o Go o Erlang.

Dal mio punto di vista, hanno enormi vantaggi in termini di prestazioni rispetto a linguaggi come C ++ o Python a causa del modo in cui gestiscono le funzioni in parallelo.

La mia domanda è: perché la sintassi per le lingue come C ++ o Python è così diversa (e IMO più semplice) da quelle dei linguaggi concorrenti, anche se la maggior parte dei linguaggi concorrenti vengono eseguiti in runtime (e quindi hanno più possibilità di semplificare sintassi)?

Ecco un esempio, considera Go sqrt :

// Package newmath is a trivial example package.
package newmath

// Sqrt returns an approximation to the square root of x.
func Sqrt(x float64) float64 {
    z := 1.0
    for i := 0; i < 1000; i++ {
        z -= (z*z - x) / (2 * z)
    }
    return z
}

Ora per la controparte Python (portalo da solo basandomi sull'esempio Sqrt di Go):

def Sqrt(x):
 z = 1.0
 for i in Range(0, 1000):
  z -= (z*z-x/2*z)
  return z

Ora come puoi vedere, c'è una sintassi come ":=" per l'assegnazione, Se prendi un esempio più complicato, la sintassi assomiglierà più a quello che sto cercando di indicare.

E Go è solo la lingua meno "strana". Se consideri Erlang sembra ancora più strano:

%% qsort:qsort(List)
%% Sort a list of items
-module(qsort).     % This is the file 'qsort.erl'
-export([qsort/1]). % A function 'qsort' with 1 parameter is exported (no type, no name)

qsort([]) -> []; % If the list [] is empty, return an empty list (nothing to sort)
qsort([Pivot|Rest]) ->
    % Compose recursively a list with 'Front' for all elements that should be before 'Pivot'
    % then 'Pivot' then 'Back' for all elements that should be after 'Pivot'
    qsort([Front || Front <- Rest, Front < Pivot])
    ++ [Pivot] ++
    qsort([Back || Back <- Rest, Back >= Pivot]).

Le parti che hanno attirato la mia attenzione erano "++ [] ++", "< -" e "- >"

Sono convinto che questi linguaggi abbiano questo aspetto per una ragione, ma non posso fare a meno di pensare: non può essere più semplice? Perché sono linguaggi concorrenti come questo? Perché se usano un runtime come Python e JavaScript, sono ancora sicuri per tipo?

So che i linguaggi sicuri per tipo hanno il vantaggio di non mescolare i tipi di variabili, ma, tuttavia, deve esserci qualcuno che ha fatto un linguaggio concorrente che non ha la sicurezza del tipo, se possibile giusto?

Sembra che quasi tutte le lingue concorrenti abbiano una cosa in comune: un elenco più grande di sintassi possibile / valida.

Spero di aver spiegato abbastanza bene la mia domanda.

javascript python go erlang

posta user125756 03.04.2014 - 21:50

fonte

2 risposte

4

Sembra che le tue osservazioni sulla sintassi siano semplicemente delle preferenze, quindi permettimi di fare alcune osservazioni personali.

Prima di tutto, lasciatemi affermare inequivocabilmente che la sintassi è importante. La sintassi più semplice di tutto è Lisp:

(defun fib (n)
  (if (< n 2)
    n
    (+ (fib (- n 1)) (fib (- n 2)))))

Poiché il codice è essenzialmente dati in Lisp, il lisp può comprendere il codice scritto in lisp, il che rende la scrittura di un parser per Lisp in Lisp (o in qualsiasi altra lingua, peraltro) un esercizio quasi banale. Il Lisp è ampiamente considerato come un linguaggio in cui i problemi possono essere risolti da zero, in settori problematici che normalmente sarebbero resistenti alle soluzioni di codifica (specialmente nei domini in cui i requisiti cambiano costantemente). Lisp è un linguaggio molto espressivo e, alla fine della giornata, la sintassi è il modo in cui ci esprimiamo in una lingua. Tuttavia, non è considerato il più leggibile delle lingue (tutte quelle parentesi).

I programmatori di solito rientrano in uno dei due campi, sintassi-saggio: quelli che preferiscono una rappresentazione in codice più simile all'inglese, e quelli che preferiscono una rappresentazione di codice più simbolica, in stile matematico. La sintassi del linguaggio stesso sarà modellata, in gran parte, dagli obiettivi della lingua.

Ad esempio, C è fondamentalmente un linguaggio di assemblaggio di alto livello. Usa la sintassi che lo fa, in gran parte, perché si adatta bene alle istruzioni di assemblaggio sottostanti. Non ha bisogno di concetti elevati come la traduzione in linguaggio naturale, preferendo mappare più vicino al metallo. Molte lingue che sono venute dopo C hanno adottato la struttura di rinforzo e altre idiosincrasie della sintassi perché C l'aveva già fatto. C è nel campo "simbolico".

unsigned int fib_rec(unsigned int n) {
    if (n == 0) {
        return 0;
    } 
    if (n == 1) {
        return 1;
    }
    return fib_rec(n - 1) + fib_rec(n - 2);
}

Alcune lingue, tuttavia, come Python, preferiscono lavorare a livelli più alti di astrazione e cercare di essere più vicini al linguaggio usato dagli umani. Queste lingue preferiranno cose come spazi vuoti significativi, perché producono meno confusione tra le parole rispetto alle parentesi. Python è nel campo "inglese".

def F(n):
    if n == 0: return 0
    elif n == 1: return 1
    else: return F(n-1)+F(n-2)

Sono stato programmatore di Visual Basic per anni, e così ero nel campo di tipo inglese, fino a quando ho imparato C #. Ora preferisco la migliore precisione e la minore ambiguità che offre C #; Penso in termini di cosa ho bisogno che faccia il computer, e C # sembra mappare più strettamente a quello. Mi piace il fatto che puoi allineare blocchi di codice in parentesi graffe. Mi piace il fatto che certe cose siano espresse più sinteticamente in C #. Ma le funzionalità di VB.NET e C # sono quasi identiche, quindi la scelta tra questi due linguaggi dipende davvero dalle preferenze personali.

risposta data 03.04.2014 - 22:18

fonte

Leggi altre domande sui tag javascript python go erlang

Come gestisci i clienti che chiedono modifiche dei dati manuali nel database? [duplicare] Come posso "ispezionare" il codice C ++?

score 7 · Accepted Answer

Sei un po 'confuso sulla terminologia e su quali fattori sono rilevanti, come le persone menzionate nei commenti. Lasciatemi solo indirizzare la sintassi di Erlang, che è una lingua funzionale .

Ha più operatori perché fa di più. Ha bisogno di un ++ perché stava già usando + per qualcos'altro. Usa ++ invece di una parola come concat perché il linguaggio era destinato a favorire la concisione. Ad esempio, il codice:

[Front || Front <- Rest, Front < Pivot]

Richiede il seguente codice in C ++ (copiato da qui ):

int partition(int* input, int p, int r)
{
    int pivot = input[r];

    while ( p < r )
    {
        while ( input[p] < pivot )
            p++;

        while ( input[r] > pivot )
            r--;

        if ( input[p] == input[r] )
            p++;
        else if ( p < r )
        {
            int tmp = input[p];
            input[p] = input[r];
            input[r] = tmp;
        }
    }

    return r;
}

Sebbene lo stesso codice in python che utilizza le list comprehensions è appena più lungo:

[front for front in rest if front < pivot]

A causa dell'immutabilità e della mancanza di effetti collaterali nella programmazione funzionale, sono stati adottati alcuni metodi di elaborazione delle liste che rendono più semplice. Ciò include la corrispondenza dei modelli e la destrutturazione. Potresti voler fare qualche ricerca su questi, ma il mio punto è al fine di ottenere l'espressività e la concisione che cose come il pattern matching forniscono, devi accettare più complessità nella sintassi.

Tieni presente che C ++ e python sembrano più naturali in gran parte perché li hai imparati per primi. Se avessi imparato prima erlang, allora la sintassi C ++ e python sembrerebbe limitante ed eccessivamente prolissa.