Qual è la differenza tra programmazione dichiarativa e imperativa? [chiuso]

Ho cercato sul web una definizione di programmazione dichiarativa e imperativa che mi avrebbe fatto luce. Tuttavia, il linguaggio utilizzato in alcune delle risorse che ho trovato è scoraggiante, ad esempio su Wikipedia . Qualcuno ha un esempio del mondo reale che potrebbe mostrarmi che potrebbe portare qualche prospettiva su questo argomento (forse in C #)?

Un ottimo esempio in C # di programmazione dichiarativa vs. imperativa è LINQ.

Con la programmazione imperativa , dici al compilatore cosa vuoi che accada, passo dopo passo.

Ad esempio, iniziamo con questa raccolta e scegliamo i numeri dispari:

List<int> collection = new List<int> { 1, 2, 3, 4, 5 };

Con la programmazione imperativa, faremmo questo passo avanti e decideremo cosa vogliamo:

List<int> results = new List<int>();
foreach(var num in collection)
{
    if (num % 2 != 0)
          results.Add(num);
}

Qui stiamo dicendo:

1. Crea una raccolta di risultati
2. Passa attraverso ogni numero nella raccolta
3. Controlla il numero, se è dispari, aggiungilo ai risultati

Con la programmazione dichiarativa , d'altra parte, scrivi un codice che descrive ciò che vuoi, ma non necessariamente come ottenerlo (dichiara i risultati desiderati, ma non il passo per passo):

var results = collection.Where( num => num % 2 != 0);

Qui stiamo dicendo "Dacci tutto dove è strano", non "Passa attraverso la raccolta. Controlla questo elemento, se è strano, aggiungilo a una raccolta di risultati".

In molti casi, il codice sarà anche una combinazione di entrambi i disegni, quindi non è sempre in bianco e nero.

La programmazione dichiarativa è quando dici quello che vuoi, e il linguaggio imperativo è quando dici come ottenere ciò che vuoi.

Un semplice esempio in Python:

# Declarative
small_nums = [x for x in range(20) if x < 5]

# Imperative
small_nums = []
for i in range(20):
    if i < 5:
        small_nums.append(i)

Il primo esempio è dichiarativo perché non specifichiamo alcun "dettaglio di implementazione" per la creazione dell'elenco.

Per legare un esempio in C #, generalmente, usando LINQ si ottiene uno stile dichiarativo, perché non si sta dicendo come ottenere ciò che si desidera; stai solo dicendo quello che vuoi. Si potrebbe dire lo stesso di SQL.

Un vantaggio della programmazione dichiarativa è che consente al compilatore di prendere decisioni che potrebbero comportare un codice migliore di quello che si potrebbe prendere a mano. In esecuzione con l'esempio SQL, se hai avuto una query simile

SELECT score FROM games WHERE id < 100;

il "compilatore" SQL può "ottimizzare" questa query perché sa che si idtratta di un campo indicizzato - o forse non è indicizzato, nel qual caso dovrà iterare comunque sull'intero set di dati. O forse il motore SQL sa che questo è il momento perfetto per utilizzare tutti gli 8 core per una rapida ricerca parallela. Come programmatore, non ti preoccupi di nessuna di queste condizioni e non devi scrivere il tuo codice per gestire un caso speciale in quel modo.

Dichiarativo vs. Imperativo

Un paradigma di programmazione è uno stile fondamentale della programmazione informatica. Esistono quattro paradigmi principali: imperativo, dichiarativo, funzionale (che è considerato un sottoinsieme del paradigma dichiarativo) e orientato agli oggetti.

Programmazione dichiarativa : è un paradigma di programmazione che esprime la logica di un calcolo (cosa fare) senza descriverne il flusso di controllo (come fare). Alcuni esempi ben noti di linguaggi dichiarativi specifici di dominio (DSL) includono CSS, espressioni regolari e un sottoinsieme di SQL (query SELECT, ad esempio) Molti linguaggi di markup come HTML, MXML, XAML, XSLT ... sono spesso dichiarativi. La programmazione dichiarativa tenta di confondere la distinzione tra un programma come un insieme di istruzioni e un programma come un'affermazione sulla risposta desiderata.

Programmazione imperativa : è un paradigma di programmazione che descrive il calcolo in termini di istruzioni che cambiano lo stato di un programma. I programmi dichiarativi possono essere visti due volte come comandi di programmazione o asserzioni matematiche.

Programmazione funzionale: è un paradigma di programmazione che considera il calcolo come la valutazione di funzioni matematiche ed evita dati di stato e mutabili. Sottolinea l'applicazione di funzioni, in contrasto con lo stile di programmazione imperativo, che enfatizza i cambiamenti di stato. In un linguaggio funzionale puro, come Haskell, tutte le funzioni sono prive di effetti collaterali e i cambiamenti di stato sono rappresentati solo come funzioni che trasformano lo stato.

Il seguente esempio di programmazione imperativa in MSDN , scorre i numeri da 1 a 10 e trova i numeri pari.

var numbersOneThroughTen = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//With imperative programming, we'd step through this, and decide what we want:
var evenNumbers = new List<int>();
foreach (var number in numbersOneThroughTen)
{    if (number % 2 == 0)
    {
        evenNumbers.Add(number);
    }
}
//The following code uses declarative programming to accomplish the same thing.
// Here, we're saying "Give us everything where it's odd"
var evenNumbers = numbersOneThroughTen.Select(number => number % 2 == 0);

Entrambi gli esempi producono lo stesso risultato e uno non è né migliore né peggiore dell'altro. Il primo esempio richiede più codice, ma il codice è verificabile e l'approccio imperativo ti dà il pieno controllo sui dettagli di implementazione. Nel secondo esempio, il codice è probabilmente più leggibile; tuttavia, LINQ non ti dà il controllo su ciò che accade dietro le quinte. Devi fidarti che LINQ fornirà il risultato richiesto.

Tutte le risposte sopra e altri post online menzionano quanto segue:

• Con la programmazione dichiarativa , scrivi il codice che descrive ciò che desideri, ma non necessariamente come ottenerlo
• Dovresti preferire la programmazione dichiarativa alla programmazione imperativa

Quello che non ci hanno detto è come raggiungerlo . Perché una parte del programma sia più dichiarativa, altre parti devono fornire l'astrazione per nascondere i dettagli dell'implementazione (che sono i codici imperativi ).

• Ad esempio, LINQ è più dichiarativo dei loop (per, mentre, ecc.), Ad esempio, è possibile utilizzare list.Where()per ottenere un nuovo elenco filtrato. Perché questo funzioni, Microsoft ha fatto tutto il lavoro pesante dietro l'astrazione LINQ.

In effetti, uno dei motivi per cui la programmazione funzionale e le librerie funzionali sono più dichiarative è perché hanno sottratto loop e creazioni di elenchi, nascondendo tutti i dettagli dell'implementazione (molto probabilmente codici imperativi con loop) dietro la scena.

In qualsiasi programma, avrai sempre sia codici imperativi che dichiarativi, quello che dovresti mirare a nascondere tutti i codici imperativi dietro le astrazioni, in modo che altre parti del programma possano usarli in modo dichiarativo .

Infine, sebbene la programmazione funzionale e LINQ possano rendere il tuo programma più dichiarativo, puoi sempre renderlo ancora più dichiarativo fornendo più astrazioni. Per esempio:

// JavaScript example

// Least declarative
const bestProducts = [];
for(let i = 0; i < products.length; i++) {
    let product = products[i];
    if (product.rating >= 5 && product.price < 100) {
        bestProducts.push(product);
    }
}


// More declarative
const bestProducts = products.filter(function(product) {
    return product.rating >= 5 && product.price < 100;
});

// Most declarative, implementation details are hidden in a function
const bestProducts = getBestProducts();

PS l'estremo della programmazione dichiarativa è inventare nuovi linguaggi specifici di dominio (DSL):

1. Ricerca stringa : espressione regolare anziché codice imperativo personalizzato
2. React.js : JSX anziché manipolazione DOM diretta
3. AWS CloudFormation : YAML anziché CLI
4. Database relazionale : SQL anziché API di lettura-scrittura meno recenti come ISAM o VSAM.

Aggiungerò un altro esempio che raramente compare nella discussione sulla programmazione dichiarativa / imperativa: l'interfaccia utente!

In C #, puoi creare un'interfaccia utente usando varie tecnologie.

All'estremità imperativa, potresti usare DirectX o OpenGL per disegnare in modo molto imperativo i tuoi pulsanti, caselle di controllo, ecc ... riga per riga (o davvero, triangolo per triangolo). Sta a te dire come disegnare l'interfaccia utente.

Alla fine dichiarativa, hai WPF. Fondamentalmente scrivi un po 'di XML (sì, sì, "XAML" tecnicamente) e il framework fa il lavoro per te. Dici come appare l'interfaccia utente. Spetta al sistema capire come farlo.

Comunque, solo un'altra cosa a cui pensare. Solo perché una lingua è dichiarativa o imperativa non significa che non abbia determinate caratteristiche dell'altra.

Inoltre, uno dei vantaggi della programmazione dichiarativa è che lo scopo è generalmente più facile da leggere leggendo il codice mentre l'imperativo ti dà un controllo più preciso sull'esecuzione.

L'essenza di tutto:

Dichiarativo -> whatvuoi farlo

Imperativo -> howvuoi che sia fatto

Mi è piaciuta una spiegazione da un corso di Cambridge + i loro esempi:

• Dichiarativo : specificare cosa fare, non come farlo
  • Ad esempio: HTML descrive ciò che dovrebbe apparire su una pagina web, non come dovrebbe essere disegnato sullo schermo
• Imperativo : specificare cosa e come
  • int x; - cosa (dichiarativo)
  • x=x+1; - Come

La differenza ha principalmente a che fare con il livello complessivo di astrazione. Con dichiarativo, ad un certo punto, sei così lontano dai singoli passaggi che il programma ha molta latitudine su come ottenere il tuo risultato.

Puoi guardare ogni istruzione come cadere da qualche parte su un continuum:

Grado di astrazione:

Declarative <<=====|==================>> Imperative

Esempio dichiarativo del mondo reale:

1. Bibliotecario, per favore, guardami una copia di Moby Dick. (Il bibliotecario, a propria discrezione, sceglie il metodo migliore per eseguire la richiesta)

Esempio imperativo del mondo reale:

1. Vai in libreria
2. Trova il sistema di organizzazione dei libri (Catalogo delle carte - Vecchia scuola)
3. Scopri come usare i cataloghi di carte (anche tu l'hai dimenticato, vero)
4. Scopri come gli scaffali sono etichettati e organizzati.
5. Scopri come sono organizzati i libri su uno scaffale.
6. Ubicazione del libro con riferimenti incrociati dal catalogo delle carte con il sistema organizzativo per trovare il libro.
7. Prendi il libro per il check-out del sistema.
8. Dai un'occhiata al libro.

La programmazione imperativa richiede agli sviluppatori di definire passo dopo passo come eseguire il codice. Per dare indicazioni in modo imperativo, dici "Vai alla 1st Street, svolta a sinistra in Main, prosegui per due isolati, svolta a destra in Maple e fermati alla terza casa a sinistra". La versione dichiarativa potrebbe suonare in questo modo: "Guidi a casa di Sue". Uno dice come fare qualcosa; l'altro dice cosa bisogna fare.

Lo stile dichiarativo presenta due vantaggi rispetto allo stile imperativo:

• Non obbliga il viaggiatore a memorizzare una lunga serie di istruzioni.
• Permette al viaggiatore di ottimizzare il percorso quando possibile.

Calvert, C Kulkarni, D (2009). LINQ essenziale. Addison Wesley. 48.

La programmazione imperativa sta dicendo esplicitamente al computer cosa fare e come farlo, come specificare l'ordine e così via

C #:

for (int i = 0; i < 10; i++)
{
    System.Console.WriteLine("Hello World!");
}

Dichiarativo è quando dici al computer cosa fare, ma non proprio come farlo. Datalog / Prolog è la prima lingua che viene in mente in questo senso. Fondamentalmente tutto è dichiarativo. Non puoi davvero garantire l'ordine.

C # è un linguaggio di programmazione molto più imperativo, ma alcune funzionalità di C # sono più dichiarative, come Linq

dynamic foo = from c in someCollection
           let x = someValue * 2
           where c.SomeProperty < x
           select new {c.SomeProperty, c.OtherProperty};

La stessa cosa potrebbe essere scritta imperativamente:

dynamic foo = SomeCollection.Where
     (
          c => c.SomeProperty < (SomeValue * 2)
     )
     .Select
     (
          c => new {c.SomeProperty, c.OtherProperty}
     )

(esempio da Wikipedia Linq)

In informatica, la programmazione dichiarativa è un paradigma di programmazione che esprime la logica di un calcolo senza descriverne il flusso di controllo.

Da http://en.wikipedia.org/wiki/Declarative_programming

in poche parole il linguaggio dichiarativo è più semplice perché manca la complessità del flusso di controllo (loop, se istruzioni, ecc.)

Un buon confronto è il modello 'code-behind' di ASP.Net. Sono presenti file ".ASPX" dichiarativi e quindi i file di codice "ASPX.CS" imperativi. Trovo spesso che se posso fare tutto ciò di cui ho bisogno nella metà dichiarativa della sceneggiatura molte più persone possono seguire ciò che viene fatto.

Rubare da Philip Roberts qui :

• La programmazione imperativa dice alla macchina come fare qualcosa (portando a ciò che vuoi che accada)
• La programmazione dichiarativa dice alla macchina cosa vorresti succedere (e il computer capisce come farlo)

Due esempi:

1. Raddoppiare tutti i numeri in un array

Imperativamente:

var numbers = [1,2,3,4,5]
var doubled = []

for(var i = 0; i < numbers.length; i++) {
  var newNumber = numbers[i] * 2
  doubled.push(newNumber)
}
console.log(doubled) //=> [2,4,6,8,10]

dichiarativo:

var numbers = [1,2,3,4,5]

var doubled = numbers.map(function(n) {
  return n * 2
})
console.log(doubled) //=> [2,4,6,8,10]

2. Sommando tutti gli elementi in un elenco

Imperativamente

var numbers = [1,2,3,4,5]
var total = 0

for(var i = 0; i < numbers.length; i++) {
  total += numbers[i]
}
console.log(total) //=> 15

dichiarativo

var numbers = [1,2,3,4,5]

var total = numbers.reduce(function(sum, n) {
  return sum + n
});
console.log(total) //=> 15

Nota come gli esempi imperativi implicano la creazione di una nuova variabile, la sua mutazione e la restituzione di quel nuovo valore (ovvero, come far accadere qualcosa), mentre gli esempi dichiarativi vengono eseguiti su un dato input e restituiscono il nuovo valore basato sull'input iniziale (cioè , cosa vogliamo che accada).

Programmazione imperativa
Un linguaggio di programmazione che richiede una disciplina di programmazione come C / C ++, Java, COBOL, FORTRAN, Perl e JavaScript. I programmatori che scrivono in tali lingue devono sviluppare un corretto ordine di azioni per risolvere il problema, basato su una conoscenza dell'elaborazione e della programmazione dei dati.

Programmazione dichiarativa
Un linguaggio informatico che non richiede la scrittura della logica di programmazione tradizionale; Gli utenti si concentrano sulla definizione dell'input e dell'output piuttosto che sulle fasi del programma richieste in un linguaggio di programmazione procedurale come C ++ o Java.

Esempi di programmazione dichiarativa sono CSS, HTML, XML, XSLT, RegX.

il programma dichiarativo è solo un dato per la sua implementazione / vm imperativa più o meno "universale".

vantaggi: specificare solo un dato, in un formato hardcoded (e controllato), è più semplice e meno soggetto a errori rispetto alla specifica diretta di una variante di un algoritmo imperativo. alcune specifiche complesse non possono essere scritte direttamente, solo in una forma DSL. best e freq utilizzati nelle strutture di dati DSL sono set e tabelle. perché non si hanno dipendenze tra elementi / righe. e quando non hai dipendenze hai la libertà di modificare e facilità di supporto. (confronta ad esempio i moduli con le classi - con i moduli che sei soddisfatto e con le classi hai un fragile problema di classe base) tutti i beni di dichiaratività e DSL seguono immediatamente i vantaggi di tali strutture di dati (tabelle e set). un altro vantaggio: è possibile modificare l'implementazione del linguaggio dichiarativo vm, se DSL è più o meno astratto (ben progettato). eseguire un'implementazione parallela, ad esempio.

svantaggi: indovina. L'implementazione dell'algoritmo / vm imperativo generico (e parametrizzato da DSL) può essere più lenta e / o affamata di memoria di quella specifica. in alcuni casi. se quei casi sono rari - dimenticatene, lascia che sia lento. se è frequente, puoi sempre estendere il tuo DSL / vm per quel caso. da qualche parte rallentando tutti gli altri casi, certo ...

PS Frameworks è a metà strada tra DSL e imperativo. e come tutte le soluzioni a metà strada ... combinano carenze, non benefici. non sono così sicuri E non così veloci :) guarda l'hashell jack-of-all-trades - è a metà strada tra un forte ML semplice e flessibile metaprog Prolog e ... che mostro è. puoi vedere Prolog come un Haskell con funzioni / predicati solo booleani. e quanto sia semplice la sua flessibilità contro Haskell ...

Mi chiedo solo perché nessuno abbia menzionato le classi di attributi come strumento di programmazione dichiarativa in C #. La risposta popolare di questa pagina ha appena parlato di LINQ come strumento di programmazione dichiarativo.

Secondo Wikipedia

I linguaggi dichiarativi comuni includono quelli dei linguaggi di query del database (ad esempio, SQL, XQuery), espressioni regolari, programmazione logica, programmazione funzionale e sistemi di gestione della configurazione.

Quindi LINQ, come sintassi funzionale, è sicuramente un metodo dichiarativo, ma anche le classi di attributi in C #, come strumento di configurazione, sono dichiarative. Ecco un buon punto di partenza per saperne di più: Panoramica rapida sulla programmazione degli attributi C #

Solo per aggiungere un altro esempio in termini di sviluppo di app mobili. In iOS e Android abbiamo Interface Builders, dove possiamo definire l'interfaccia utente delle app.

L'interfaccia utente disegnata usando questi Builders è di natura dichiarativa, in cui trasciniamo i componenti. Il disegno reale avviene sotto ed eseguito dal framework e dal sistema.

Ma possiamo anche disegnare tutti i componenti nel codice, e questo è di natura imperativa.

Inoltre, alcuni nuovi linguaggi come Angular JS si stanno concentrando sulla progettazione di interfacce utente in modo dichiarativo e potremmo vedere molte altre lingue che offrono lo stesso supporto. Come Java non ha un buon modo dichiarativo per disegnare app desktop native in Java swing o Java FX, ma nel prossimo futuro potrebbero semplicemente.

Secondo la mia comprensione, entrambi i termini hanno radici nella filosofia, ci sono tipi dichiarativi e imperativi di conoscenza. Le conoscenze dichiarative sono affermazioni di verità, affermazioni di fatti come assiomi matematici. Ti dice qualcosa. Conoscenza imperativa o procedurale, ti dice passo dopo passo come arrivare a qualcosa. Questa è essenzialmente la definizione di un algoritmo. Se lo desideri, confronta un linguaggio di programmazione per computer con la lingua inglese. Le frasi dichiarative affermano qualcosa. Un esempio noioso, ma ecco un modo dichiarativo di mostrare se due numeri sono uguali tra loro, in Java:

public static void main(String[] args)
{
    System.out.print("4 = 4.");
}

Le frasi imperative in inglese, invece, danno un comando o fanno una sorta di richiesta. La programmazione imperativa, quindi, è solo un elenco di comandi (farlo, farlo). Ecco un modo imperativo di mostrare se due numeri sono uguali tra loro o meno mentre si accetta l'input dell'utente, in Java:

private static Scanner input;    

public static void main(String[] args) 
{
    input = new Scanner(System.in);
    System.out.println();
    System.out.print("Enter an integer value for x: ");
    int x = input.nextInt();
    System.out.print("Enter an integer value for y: ");        
    int y = input.nextInt();

    System.out.println();
    System.out.printf("%d == %d? %s\n", x, y, x == y);
}

In sostanza, la conoscenza dichiarativa salta alcuni elementi per formare uno strato di astrazione su quegli elementi. La programmazione dichiarativa fa lo stesso.