Conceitualmente, as opções para atribuir um valor a uma variável ou a uma constante diferem apenas de uma maneira: Um compilador daria um aviso quando você tentar reatribuir uma constante

Você está correto. Se você atribuir o valor a uma variável em vez de uma constante, ela executará o trabalho desde que você esteja tomando cuidado para não alterar o valor atribuído a ela.

Pode parecer redundante para você, por exemplo, se você estiver fazendo um programa para encontrar a área de um círculo de um determinado raio, pode escrever

float pi =  3.14
float area (float r) : 
    return pi*r*r

e pense que se alguém mudasse o valor de pi para algo como 2.5, então eles são realmente vítimas de sua própria estupidez.

E ninguém quer se sobrecarregar com um recurso desnecessário.

No entanto, os programadores tendem a eliminar tantos possíveis problemas futuros quanto puderem. Pode acontecer que, se o programa for grande e tiver muitos programadores trabalhando nele, alguém possa redefinir sua variável (para que funcione para eles), mas a próxima chamada para sua função que dependesse do valor correto de sua variável retornaria resultados errados.

Agora, existem duas maneiras de eliminar essa possibilidade: você pode tornar sua variável local para a função em si, mas isso resulta em redundância porque você teria que fazer isso para cada função que se refere a ela.

Ou você pode usar o recurso interessante fornecido pela linguagem de programação e declarar seu valor como uma constante para que o compilador forneça um aviso se o valor da constante for reatribuído.

1. O nome em inglês deixa claro qual é o propósito do número.
2. A precisão do Pi é a mesma em todo o seu programa.
3. Pi é definido em um lugar, portanto, você não precisa alterá-lo em todos os lugares se decidir alterar o número de casas decimais.
4. Permitir que o compilador imponha uma constante significa que não há possibilidade de qualquer parte do código mudar para algo diferente, eliminando uma fonte de bugs potencialmente obscuros.

who cares if the value never changes during the lifetime of the program or it's programing best practise.

Quem se importa? Pessoas que precisam manter seu código.

O que acontece se o seu gerente de projeto retornar a você em vários meses e disser que "3,14" já não é uma aproximação boa o suficiente para o seu aplicativo? Ele quer tornar o programa mais preciso, porque ele será usado para construir o próximo ônibus espacial e precisa de precisão de até 8 pontos decimais.

O que você faz? Basta fazer um grande achado e substituir "3,14" para "3,14159265" em todo o seu código em seu projeto? Bem, parabéns. Agora você errou outro cálculo em algum outro lugar onde outro programador brilhante embutiu o valor "23.14994". Agora esse valor é "23.14159265994" e o ônibus espacial explodiu.

As constantes ajudam a manter os valores consistentes onde você precisa deles. Claro, você não espera que seu jogo de Tic-Tac-Toe tenha mais de três colunas e três linhas, mas alguém pode querer expandir o jogo para uma grade de 5-5. Isso também torna seu código mais legível. Você também pode refatorar seu código no futuro clicando com o botão direito do mouse em uma variável / constante e renomeá-lo no aplicativo ou arquivo.

EDIT: O título original da pergunta era "Por que precisamos de constantes na programação?" Desde que a questão foi alterada para "Por que não podemos simplesmente usar variáveis em vez de constantes?" Eu vou responder a essa pergunta também.

Variáveis podem mudar. Constantes não podem. Se alguém decide que precisa apenas de dois dígitos de precisão e sua variável tem 8 dígitos de precisão, eles podem truncar os dígitos insignificantes de sua variável. Infelizmente, isso pode causar problemas para outras partes do aplicativo que dependiam do valor original e mais preciso. Ao tornar o valor uma constante, isso resultaria em um erro de tempo de compilação e manteria a integridade do aplicativo.

Comunicação de intenção

No seu exemplo, você definiu uma variável mutável PI , que você pode referenciar em todo o seu programa. Você criou o código DRY , que só precisa ser atualizado em um único local se você quiser alterar sua definição. Isso é bom, e funciona para pequenos programas onde há apenas um desenvolvedor, e não um monte de código.

No entanto, à medida que uma base de código cresce, e à medida que mais pessoas começam a trabalhar no código, torna-se muito mais importante comunicar sua intenção . Embora a maioria das pessoas esteja ciente de que Pi é uma constante matemática e não espera que ela mude, o mesmo não acontece com as constantes mais . Ao declarar algo como uma constante, você está dizendo a outros desenvolvedores (incluindo o seu futuro) sobre o significado dessa constante.

O que uma constante se comunica?

Quando você vê que um valor é declarado como uma constante, o código está comunicando as seguintes coisas para você, como desenvolvedor:

1. Este valor nunca será alterado durante o tempo de execução do programa.
2. Este valor provavelmente é thread safe (ele será sempre lido, não gravado).
3. Esse valor provavelmente é referenciado em muitas áreas em todo o código.
4. O nome do valor provavelmente informa algo importante sobre o que isso significa.
   • A maioria de nós sabe que 3.14 é uma aproximação de Pi , mas muitas constantes não têm sentido sem um nome. if (i > MaxNumberOfUsers) é muito mais significativo que if (i > 10) .

Que outros benefícios as constantes podem conferir?

Declarar um valor como constante muitas vezes também está dizendo ao compilador algumas coisas (embora isso varie dependendo da linguagem e do compilador):

Muitos compiladores otimizam valores constantes em tempo de compilação e inserem seus resultados diretamente no código.

// No calculation will take place at runtime - all of these values
// can be replaced with their calculated results at compile time
const long BytesPerKilobyte = 1024;
const long BytesPerMegabyte = 1024 * BytesPerKilobyte; // Compiles as 1048576
const long BytesPerGigabyte = 1024 * BytesPerMegabyte; // Compiles as 1073741824

// ... elsewhere in the code ...
const long maxFileSize = BytesPerMegabyte * 40;
if (fileSize > maxFileSize) // actually compiles to 'if (fileSize > 41943040) {...}'
{
    println("The file is too large to work with");
}

Então ...

Quando comecei a aprender programação, não entendi o ponto das constantes. Eu nunca tinha trabalhado em um projeto com mais de algumas aulas, e foi fácil manter tudo na minha cabeça.

A maioria dos códigos não é assim. A maioria dos códigos existe em ambientes muito grandes, sendo mantida por várias pessoas, em momentos diferentes. À medida que os projetos nos quais você trabalha crescem, torna-se cada vez mais importante poder se comunicar com outros desenvolvedores e com você mesmo sobre o que seu código pretende fazer.

Nesse tipo de ambiente, você irá apreciar qualquer coisa que tire um pouco da carga mental que acompanha manter tudo na sua cabeça.

À medida que os projetos se tornam cada vez maiores, eles ficam cada vez mais difíceis de manter - principalmente porque a mente humana é limitado no número de coisas que ele pode manter em seu contexto imediato . Para superar isso, geralmente queremos dividir o projeto em componentes menores e mais simples, para que possamos trabalhar em um componente sem ter que ter em mente como os outros componentes funcionam. Mesmo se usarmos outros componentes, gostaríamos de usá-los como caixas pretas para que possamos nos concentrar no componente em que trabalhamos atualmente.

Muitas técnicas, ferramentas, bibliotecas e recursos de linguagem de programação são dedicados para nos ajudar a dividir nossos projetos em componentes mais fáceis de serem trabalhados. Um dos princípios para deixar claro qual parte do código é responsável por quê.

Normalmente, você vai querer que a declaração de coisas (variáveis, constantes, classes, funções, etc.) seja responsável por definir o que a coisa pode e não pode fazer, e é muito útil ter suas ferramentas inteligentemente. alertá-lo quando você usa mal essa coisa. Quando você chama sqrt(-18) , é legal ter um erro de compilação que diz "você não pode chamar sqrt com um número negativo!". É menos legal, mas ainda assim, ter esse erro em tempo de execução. Você realmente não quer obter uma saída estranha mais abaixo porque sqrt(-18) retornou algum valor aleatório porque você usou errado ...

Aqui é onde as constantes se encaixam. Elas permitem que você defina na declaração que o valor não deve ser alterado no tempo de execução, e essa definição é aplicada no uso . Então, se algum desenvolvedor achar que pode mudar seu valor, o compilador gritará com ele.

Agora, ninguém em sã consciência mudaria o valor de PI , mas outros valores podem aparecer modificáveis mesmo quando eles não são. Torná-los constantes significa que seu mantenedor não suportará as implicações de alterá-los em tempo de execução e proíbe que outros desenvolvedores os modifiquem.

BTW - Eu continuo me referindo a "este desenvolvedor" e "outro desenvolvedor", mas eles podem ser o mesmo desenvolvedor. Já que você não pode manter toda a estrutura do programa em sua limitada mente humana, quando você trabalha em outro componente, você pode também ser outro desenvolvedor, porque você mudou seu contexto.

Uma das principais razões para constantes (em particular, constantes do compilador) é dar um valor consistente para uma coisa predefinida (ou seja, pi, e, null, etc.).

As constantes também economizam tempo. Eu não preciso procurar os valores quando preciso realizar certos tipos de matemática.

Em algumas linguagens de programação, chamar algo de constante é uma forma de marcá-lo como imutável. Usando seu exemplo de PI, você poderia definir uma variável chamada PI e atribuí-la 3.14 e usá-la em todo o código como o valor de PI. No entanto, o que acontece quando algum programador posterior usando seu código decide que seu código precisa de uma representação mais precisa do PI e eles configuram sua variável PI como 3.141592. Isso PODE não causar um problema se o seu código existente puder lidar com a precisão adicional ou pode quebrar tudo de alguma maneira estranha como arredondá-lo para 3.1416 (que definitivamente não é PI).

Para expandir a resposta da @Robert Harveys

5. Muitas linguagens compiladas incorporam constantes no código compilado, então existe uma razão de nível do compilador / interpretador
6. 3.14 como PI significa algo para o mundo exterior, mas isso não significa necessariamente nada no mundo (ou domínio) dos seus programas até que você o adicione como uma constante. Pense no seu programa como pessoa; quanto mais coisas você diz, mais inteligente fica.