Qual é a diferença entre programação declarativa e imperativa? [fechadas]

Eu tenho pesquisado na web procurando uma definição para programação declarativa e imperativa que me esclarecesse alguma coisa. No entanto, a linguagem usada em alguns dos recursos que encontrei é assustadora - por exemplo, na Wikipedia . Alguém tem um exemplo do mundo real que eles possam me mostrar que possa trazer alguma perspectiva para esse assunto (talvez em C #)?

Um ótimo exemplo de C # de programação declarativa vs. imperativa é o LINQ.

Com a programação imperativa , você diz ao compilador o que deseja que aconteça, passo a passo.

Por exemplo, vamos começar com esta coleção e escolher os números ímpares:

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

Com a programação imperativa, passaríamos por isso e decidiríamos o que queremos:

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

Aqui, estamos dizendo:

1. Crie uma coleção de resultados
2. Percorra cada número da coleção
3. Verifique o número, se for ímpar, adicione-o aos resultados

Com a programação declarativa , por outro lado, você escreve o código que descreve o que deseja, mas não necessariamente como obtê-lo (declare os resultados desejados, mas não o passo a passo):

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

Aqui, estamos dizendo "Dê-nos tudo o que for estranho", não "Passe pela coleção. Marque esse item, se for estranho, adicione-o a uma coleção de resultados".

Em muitos casos, o código também será uma mistura dos dois designs, portanto nem sempre é em preto e branco.

A programação declarativa é quando você diz o que deseja e a linguagem imperativa é quando você diz como conseguir o que deseja.

Um exemplo simples em 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)

O primeiro exemplo é declarativo porque não especificamos nenhum "detalhe de implementação" da criação da lista.

Para vincular um exemplo de C #, geralmente, o uso de LINQ resulta em um estilo declarativo, porque você não está dizendo como obter o que deseja; você está apenas dizendo o que deseja. Você poderia dizer o mesmo sobre SQL.

Um benefício da programação declarativa é que ele permite ao compilador tomar decisões que podem resultar em código melhor do que o que você pode fazer manualmente. Executando com o exemplo SQL, se você tivesse uma consulta como

SELECT score FROM games WHERE id < 100;

o "compilador" do SQL pode "otimizar" essa consulta porque sabe que idé um campo indexado - ou talvez não esteja indexado; nesse caso, terá que iterar todo o conjunto de dados de qualquer maneira. Ou talvez o mecanismo SQL saiba que esse é o momento perfeito para utilizar todos os 8 núcleos para uma rápida pesquisa paralela. Você , como programador, não está preocupado com nenhuma dessas condições e não precisa escrever seu código para lidar com nenhum caso especial dessa maneira.

Declarativo vs. Imperativo

Um paradigma de programação é um estilo fundamental de programação de computadores. Existem quatro paradigmas principais: imperativo, declarativo, funcional (que é considerado um subconjunto do paradigma declarativo) e orientado a objetos.

Programação declarativa : é um paradigma de programação que expressa a lógica de uma computação (O que fazer) sem descrever seu fluxo de controle (Como fazer). Alguns exemplos conhecidos de linguagens declarativas de domínio específico (DSLs) incluem CSS, expressões regulares e um subconjunto de SQL (consultas SELECT, por exemplo) Muitas linguagens de marcação como HTML, MXML, XAML, XSLT ... geralmente são declarativas. A programação declarativa tenta embaçar a distinção entre um programa como um conjunto de instruções e um programa como uma afirmação sobre a resposta desejada.

Programação imperativa : é um paradigma de programação que descreve a computação em termos de declarações que alteram o estado de um programa. Os programas declarativos podem ser visualizados dupla- mente como comandos de programação ou asserções matemáticas.

Programação funcional: é um paradigma de programação que trata a computação como a avaliação de funções matemáticas e evita dados de estado e mutáveis. Ele enfatiza a aplicação de funções, em contraste com o estilo de programação imperativa, que enfatiza as mudanças de estado. Em uma linguagem funcional pura, como Haskell, todas as funções não têm efeitos colaterais e as alterações de estado são representadas apenas como funções que transformam o estado.

O exemplo a seguir de programação imperativa no MSDN , percorre os números de 1 a 10 e localiza os números pares.

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);

Ambos os exemplos produzem o mesmo resultado, e um não é nem melhor nem pior que o outro. O primeiro exemplo requer mais código, mas o código é testável e a abordagem imperativa fornece controle total sobre os detalhes da implementação. No segundo exemplo, o código é indiscutivelmente mais legível; no entanto, o LINQ não fornece controle sobre o que acontece nos bastidores. Você deve confiar que o LINQ fornecerá o resultado solicitado.

Todas as respostas acima e outras postagens on-line mencionam o seguinte:

• Com a programação declarativa , você escreve um código que descreve o que deseja, mas não necessariamente como obtê-lo
• Você deve preferir a programação declarativa à programação imperativa

O que eles não nos disseram é como alcançá-lo . Para que parte do programa seja mais declarativa, outras partes devem fornecer a abstração para ocultar os detalhes da implementação (que são os códigos imperativos ).

• Por exemplo, LINQ é mais declarativo que loops (por, enquanto, etc.), por exemplo, você pode usar list.Where()para obter uma nova lista filtrada. Para que isso funcione, a Microsoft fez todo o trabalho pesado por trás da abstração do LINQ.

De fato, uma das razões pelas quais a programação funcional e as bibliotecas funcionais são mais declarativas é porque abstraíram loops e listam criações, ocultando todos os detalhes da implementação (provavelmente códigos imperativos com loops) nos bastidores.

Em qualquer programa, você sempre terá códigos imperativos e declarativos, o que você deve procurar é ocultar todos os códigos imperativos atrás das abstrações, para que outras partes do programa possam usá-los declarativamente .

Por fim, embora a programação funcional e o LINQ possam tornar seu programa mais declarativo, você sempre pode torná-lo ainda mais declarativo fornecendo mais abstrações. Por exemplo:

// 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 o extremo da programação declarativa é inventar novas linguagens específicas de domínio (DSL):

1. Pesquisa por sequência : expressão regular em vez de código imperativo personalizado
2. React.js : JSX em vez de manipulação direta do DOM
3. AWS CloudFormation : YAML em vez de CLI
4. Banco de dados relacional : SQL em vez de APIs de leitura e gravação mais antigas, como ISAM ou VSAM.

Vou adicionar outro exemplo que raramente aparece na discussão sobre programação declarativa / imperativa: a interface do usuário!

Em C #, você pode criar uma interface do usuário usando várias tecnologias.

No final imperativo, você pode usar o DirectX ou o OpenGL para desenhar imperativamente seus botões, caixas de seleção, etc. linha por linha (ou, na verdade, triângulo por triângulo). Cabe a você dizer como desenhar a interface do usuário.

No final declarativo, você tem WPF. Você basicamente escreve um XML (sim, sim, "XAML" tecnicamente) e a estrutura faz o trabalho para você. Você diz como é a interface do usuário. Cabe ao sistema descobrir como fazê-lo.

Enfim, apenas mais uma coisa para pensar. Só porque um idioma é declarativo ou imperativo, não significa que ele não tenha certas características do outro.

Além disso, um benefício da programação declarativa é que o objetivo geralmente é mais facilmente compreendido pela leitura do código, enquanto que o imperativo fornece um controle mais preciso sobre a execução.

A essência de tudo:

Declarativo -> whatvocê quer fazer

Imperativo -> how você quer que seja feito

Gostei de uma explicação de um curso de Cambridge + dos exemplos deles:

• Declarativo - especifique o que fazer, não como fazê-lo
  • Por exemplo: HTML descreve o que deve aparecer em uma página da Web, não como deve ser desenhado na tela
• Imperativo - especifique o que e como
  • int x; - o que (declarativo)
  • x=x+1; - como

A diferença tem a ver principalmente com o nível geral de abstração. Com declarativo, em algum momento, você está tão longe das etapas individuais que o programa tem muita margem de lucro em relação a como obter seu resultado.

Você pode considerar cada instrução como caindo em algum lugar em um continuum:

Grau de abstração:

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

Exemplo declarativo do mundo real:

1. Bibliotecária, por favor, me dê uma cópia do Moby Dick. (O bibliotecário, a seu critério, escolhe o melhor método para executar a solicitação)

Exemplo imperativo do mundo real:

1. Vá para a Biblioteca
2. Encontre Sistema de Organização de Livros (Catálogo de Cartões - Old school)
3. Pesquise como usar catálogos de cartões (você esqueceu também, certo)
4. Descubra como as prateleiras são rotuladas e organizadas.
5. Descubra como os livros são organizados em uma prateleira.
6. Faça uma referência cruzada da localização do livro no catálogo de cartões com o sistema da organização para encontrar o livro.
7. Leve o livro ao sistema de check-out.
8. Confira o livro.

A programação imperativa exige que os desenvolvedores definam passo a passo como o código deve ser executado. Para dar instruções de maneira imperativa, você diz: "Vá para a 1st Street, vire à esquerda na Main, dirija dois quarteirões, vire à direita na Maple e pare na terceira casa à esquerda". A versão declarativa pode parecer algo assim: "Dirija para a casa de Sue". Alguém diz como fazer algo; o outro diz o que precisa ser feito.

O estilo declarativo tem duas vantagens sobre o estilo imperativo:

• Não força o viajante a memorizar um longo conjunto de instruções.
• Permite ao viajante otimizar a rota sempre que possível.

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

A programação imperativa é dizer explicitamente ao computador o que fazer e como fazê-lo, como especificar a ordem e tal

C #:

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

Declarativo é quando você diz ao computador o que fazer, mas não como realmente fazê-lo. Datalog / Prolog é a primeira língua que vem à mente a esse respeito. Basicamente, tudo é declarativo. Você não pode realmente garantir a ordem.

C # é uma linguagem de programação muito mais imperativa, mas certos recursos de C # são mais declarativos, como o Linq

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

A mesma coisa pode ser escrita imperativamente:

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

(exemplo da wikipedia Linq)

Na ciência da computação, a programação declarativa é um paradigma de programação que expressa a lógica de uma computação sem descrever seu fluxo de controle.

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

em poucas palavras, a linguagem declarativa é mais simples porque carece da complexidade do fluxo de controle (loops, se, etc.)

Uma boa comparação é o modelo 'code-behind' do ASP.Net. Você tem arquivos declarativos '.ASPX' e, em seguida, os arquivos de código imperativos 'ASPX.CS'. Costumo achar que, se eu puder fazer tudo o que preciso na metade declarativa do script, muito mais pessoas poderão acompanhar o que está sendo feito.

Roubando de Philip Roberts aqui :

• A programação imperativa diz à máquina como fazer algo (resultando no que você deseja que aconteça)
• A programação declarativa diz à máquina o que você gostaria que acontecesse (e o computador descobre como fazê-lo)

Dois exemplos:

1. Dobrar todos os números em uma matriz

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]

Declarativamente:

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. Somando todos os itens em uma lista

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

Declarativamente

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

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

Observe como os exemplos imperativos envolvem a criação de uma nova variável, a mutação e o retorno desse novo valor (ou seja, como fazer algo acontecer), enquanto os exemplos declarativos são executados em uma determinada entrada e retornam o novo valor com base na entrada inicial (ou seja, , o que queremos que aconteça).

Programação imperativa
Uma linguagem de programação que requer disciplina de programação como C / C ++, Java, COBOL, FORTRAN, Perl e JavaScript. Os programadores que escrevem nessas linguagens devem desenvolver uma ordem adequada de ações para resolver o problema, com base no conhecimento de processamento e programação de dados.

Programação declarativa
Uma linguagem de computador que não requer a escrita da lógica de programação tradicional; Os usuários se concentram na definição da entrada e da saída, em vez das etapas do programa necessárias em uma linguagem de programação procedural, como C ++ ou Java.

Exemplos de programação declarativos são CSS, HTML, XML, XSLT, RegX.

programa declarativo é apenas um dado para sua implementação imperativa mais ou menos "universal" / vm.

vantagens: especificar apenas um dado, em algum formato codificado (e verificado), é mais simples e menos suscetível a erros do que especificar diretamente a variante de algum algoritmo imperativo. algumas especificações complexas simplesmente não podem ser escritas diretamente, apenas em alguma forma DSL. best e freq usados ​​nas estruturas de dados DSLs são conjuntos e tabelas. porque você não tem dependências entre elementos / linhas. e quando você não possui dependências, tem liberdade para modificar e facilitar o suporte. (compare, por exemplo, módulos com classes - com módulos felizes e com classes com problemas frágeis de classe base) todos os bens de declaratividade e DSL seguem imediatamente os benefícios dessas estruturas de dados (tabelas e conjuntos). outra vantagem - você pode alterar a implementação da linguagem declarativa vm, se o DSL for mais ou menos abstrato (bem projetado). faça implementação paralela, por exemplo.

desvantagens: você acha certo. A implementação de algoritmo imperativo genérico (e parametrizado por DSL) / vm pode ser mais lenta e / ou com menos memória do que uma específica. em alguns casos. se esses casos forem raros - esqueça, deixe-o lento. se for frequente - você sempre poderá estender seu DSL / vm para esse caso. em algum lugar atrasando todos os outros casos, com certeza ...

PS Frameworks está a meio caminho entre DSL e imperativo. e como todas as soluções intermediárias ... elas combinam deficiências, não benefícios. eles não são tão seguros E não são tão rápidos :) olhe para o haskell do tipo "tudo de todos" - está a meio caminho entre um ML simples e forte e o metaprog flexível Prolog e ... que monstro ele é. você pode ver o Prolog como um Haskell com funções / predicados somente booleanos. e quão simples é sua flexibilidade contra Haskell ...

Eu só me pergunto por que ninguém mencionou as classes de atributo como uma ferramenta de programação declarativa em c #. A resposta popular desta página acabou de falar sobre o LINQ como uma ferramenta de programação declarativa.

De acordo com a Wikipedia

As linguagens declarativas comuns incluem as linguagens de consulta do banco de dados (por exemplo, SQL, XQuery), expressões regulares, programação lógica, programação funcional e sistemas de gerenciamento de configuração.

Portanto, o LINQ, como sintaxe funcional, é definitivamente um método declarativo, mas as classes Attribute em C #, como ferramenta de configuração, também são declarativas. Aqui está um bom ponto de partida para ler mais sobre isso: Visão geral rápida da programação de atributos em C #

Apenas para adicionar outro exemplo em termos de desenvolvimento de aplicativos para dispositivos móveis. No iOS e Android, temos os Interface Builders, onde podemos definir a interface do usuário dos aplicativos.

A interface do usuário desenhada usando esses construtores é de natureza declarativa, onde arrastamos e soltamos os componentes. O desenho real acontece por baixo e é executado pela estrutura e pelo sistema.

Mas também podemos desenhar todos os componentes no código, e isso é de natureza imperativa.

Além disso, algumas novas linguagens, como o Angular JS, estão focando no design de UIs declarativamente e podemos ver muitas outras linguagens oferecendo o mesmo suporte. Como o Java não tem uma boa maneira declarativa de desenhar aplicativos de desktop nativos em Java swing ou Java FX, mas em um futuro próximo, eles apenas poderão.

Do meu entendimento, ambos os termos têm raízes na filosofia, existem tipos de conhecimento declarativos e imperativos. Conhecimento declarativo são afirmações da verdade, declarações de fato como axiomas matemáticos. Isso diz uma coisa. O conhecimento imperativo ou processual diz a você passo a passo como chegar a algo. Isso é o que é essencialmente a definição de um algoritmo. Se preferir, compare uma linguagem de programação de computadores com a língua inglesa. Frases declarativas afirmam algo. Um exemplo chato, mas aqui está uma maneira declarativa de exibir se dois números são iguais entre si, em Java:

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

Frases imperativas em inglês, por outro lado, dão um comando ou fazem algum tipo de solicitação. A programação imperativa, então, é apenas uma lista de comandos (faça isso, faça aquilo). Aqui está uma maneira imperativa de exibir se dois números são iguais um ao outro ou não ao aceitar a entrada do usuário, em 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);
}

Essencialmente, o conhecimento declarativo pula certos elementos para formar uma camada de abstração sobre esses elementos. A programação declarativa faz o mesmo.