Se você está aprendendo um idioma, provavelmente já ouviu a palavra "sintaxe" e lida com ela o tempo todo. (Porra de erro de sintaxe).

Faz algumas noites que eu estava pensando comigo mesmo, nunca segui paradigmas e técnicas de programação a sério, e hoje comecei a aprender com os menores tópicos que sempre ouço (mesmo que já me lembre). Eu criei este repositório. O caminho de aprendizagem que segui é característico (no arquivo LEARNING_LIST.md). vamos passar, Em contraste com as linguagens naturais, com as quais comunicamos nossos pensamentos e sentimentos, as linguagens de programação podem ser vistas como linguagens artificiais definidas por homens e mulheres inicialmente com o propósito de se comunicarem com computadores, mas, igualmente importante, para comunicar algoritmos entre pessoas .
Por exemplo, as definições de linguagem consistem em três componentes:

• Sintaxe: a sintaxe de uma linguagem de programação é o conjunto de regras que definem as combinações de símbolos que são considerados programas corretamente estruturados naquela linguagem. A sintaxe de uma linguagem define sua forma superficial. As linguagens de programação baseadas em texto são baseadas em sequências de caracteres. A gramática lexical de uma linguagem textual especifica como os caracteres devem ser divididos em tokens. A sintaxe se refere às maneiras pelas quais os símbolos podem ser combinados para criar sentenças (ou programas) bem formadas na linguagem. A sintaxe define as relações formais entre os constituintes de uma linguagem, fornecendo assim uma descrição estrutural das diversas expressões que constituem as cadeias legais na linguagem. A sintaxe trata apenas da forma e estrutura dos símbolos em uma língua sem qualquer consideração ao seu significado, a sintaxe é o conceito que se preocupa apenas se a frase é ou não válida para a gramática da língua

• Semântica: A semântica trata de saber se a frase tem ou não um significado válido. A semântica revela o significado de strings sintaticamente válidas em uma linguagem. Para as línguas naturais, isso significa correlacionar sentenças e frases com os objetos, pensamentos e sentimentos de nossas experiências. Para linguagens de programação, a semântica descreve o comportamento que um computador segue ao executar um programa na linguagem. Poderíamos revelar esse comportamento descrevendo a relação entre a entrada e a saída de um programa ou através de uma explicação passo a passo de como um programa será executado em uma máquina real ou abstrata. Semântica é o termo geral para o estudo do significado. Na ciência da computação, o tema da semântica da linguagem de programação busca dar significado matemático preciso aos programas.

Semântica de baixo nível:

Em línguas naturais, uma frase pode ser gramaticalmente correta, mas semanticamente sem sentido. Por exemplo, a frase:

"O homem comprou o infinito na loja."

Isso é gramaticalmente correto, mas não faz sentido no mundo real. Da mesma forma, em linguagens de programação, uma declaração pode ser sintaticamente correta, mas semanticamente incorreta, porque viola as regras da linguagem ou o significado pretendido.

Na semântica de baixo nível da programação, estamos preocupados em saber se uma instrução que tem sintaxe correta também faz sentido de acordo com o sistema de tipos da linguagem ou outras regras. Mesmo que a sintaxe possa ser válida, o significado semântico da operação pode ser inválido. O sistema de tipos em linguagens de tipo estaticamente, como Java, ajuda a impor essas regras antes do tempo de execução, mas linguagens de tipo dinâmico, como JavaScript, nem sempre impõem essas regras até o tempo de execução.

Exemplo em JavaScript:

Em JavaScript, que é digitado livremente, você pode não ter a proteção que vem com um sistema de tipos mais rígido, e a linguagem permitirá certas operações que não fazem sentido de uma forma semanticamente significativa. Considere o seguinte código JavaScript:

let name = "Alice";
name = 42;  // No error, but semantically this doesn't make sense.

Aqui, a sintaxe é perfeitamente válida e o JavaScript permite a atribuição, mas semanticamente é estranho. Você está tentando atribuir um número (42) a uma variável que provavelmente se destina a conter uma string (nome). Não há verificação de tipo em JavaScript para impedir que você cometa esse erro, mas é um erro semântico de baixo nível porque é inconsistente com a intenção do desenvolvedor.
Se implementarmos isso. É executado. sem nenhum erro!

Em linguagens mais rígidas, como TypeScript ou Java, isso acionaria um erro de tipo imediatamente durante a compilação.

Exemplo em TypeScript:

TypeScript, um superconjunto de JavaScript, introduz verificação de tipo para evitar estes problemas semânticos de baixo nível:

let name: string = "Alice";
name = 42;  // Error: Type 'number' is not assignable to type 'string'.

No TypeScript, o compilador detecta o erro semântico porque 42 é um número e não pode ser atribuído a uma variável declarada como uma string. Essa aplicação de tipos protege o desenvolvedor de erros não intencionais.

Em JavaScript, para evitar esses problemas semânticos de baixo nível, os desenvolvedores costumam usar verificações de tempo de execução:

let name = "Alice";

if (typeof name !== "string") {
    throw new Error("Expected a string!");
}

Mesmo que o JavaScript não imponha tipos, adicionar verificações manuais pode ajudar a evitar erros onde tipos incorretos levam a problemas no programa.

Semântica de alto nível:

Em um nível superior, a semântica se preocupa com o que seu programa deve alcançar. Não se trata apenas de saber se o programa tem sintaxe válida ou se os tipos estão alinhados corretamente – trata-se de saber se o programa se comporta da maneira pretendida pelo desenvolvedor ou se resolve o problema para o qual foi projetado.

Por exemplo, digamos que você esteja construindo um sistema simples de negociação de ações. A semântica de alto nível do seu código visa garantir que o sistema negocie ações da maneira certa, com a lógica de negócios correta. Mesmo que o código não produza erros de tipo ou de sintaxe, ele ainda pode não atender à funcionalidade pretendida.

Exemplo em JavaScript:

Vejamos um exemplo JavaScript de semântica de alto nível usando um cenário simplificado de negociação de ações:

let openTrade = {
    symbol: "EURUSD",
    direction: "buy",
    profit: 100
};

function closeTrade(trade) {
    if (trade.profit >= 50) {
        console.log(`Closing trade for ${trade.symbol} with profit of ${trade.profit}`);
    } else {
        console.log(`Trade for ${trade.symbol} is not ready to close.`);
    }
}

// Check if a trade is open for EURUSD and close it if the profit target is reached.
closeTrade(openTrade);

A sintaxe está correta e o programa é executado sem erros. No entanto, imagine que introduzimos agora um erro de nível superior, como inserir acidentalmente duas negociações para o mesmo símbolo, o que viola as regras de negócios do sistema.

let openTrades = [
    { symbol: "EURUSD", direction: "buy", profit: 100 },
    { symbol: "EURUSD", direction: "sell", profit: 20 }
];

// Check all trades and close any that hit their profit target.
openTrades.forEach(trade => closeTrade(trade));

Aqui, ambas as negociações são processadas de forma independente, mas o sistema termina com duas negociações no mesmo símbolo, uma na direção de compra e outra na direção de venda. Isso quebra a regra comercial de alto nível de que devemos ter apenas uma negociação aberta por símbolo a qualquer momento.

Embora o código seja executado sem erros de sintaxe ou de tipo, ele é semanticamente incorreto em alto nível. A lógica do sistema deveria ter garantido que apenas uma negociação por símbolo pudesse estar ativa por vez. Este erro provavelmente levaria a consequências indesejadas em um sistema comercial do mundo real, como perdas financeiras.

Para corrigir esse problema semântico de alto nível, você precisaria ajustar a lógica para garantir que apenas uma negociação esteja aberta para um símbolo específico:

let openTrades = [
    { symbol: "EURUSD", direction: "buy", profit: 100 }
];

function openNewTrade(newTrade) {
    // Ensure no other trades are open for the same symbol.
    const existingTrade = openTrades.find(trade => trade.symbol === newTrade.symbol);
    if (!existingTrade) {
        openTrades.push(newTrade);
        console.log(`Opened new trade for ${newTrade.symbol}`);
    } else {
        console.log(`Cannot open a new trade for ${newTrade.symbol}, trade already exists.`);
    }
}

openNewTrade({ symbol: "EURUSD", direction: "sell", profit: 0 });

Aqui, a lógica garante que uma nova negociação não possa ser aberta se já houver uma negociação ativa para o mesmo símbolo. Esta é uma correção semântica de alto nível porque aborda a lógica de negócios central que o programa deve seguir, em vez de um problema de sintaxe ou tipo.

• Pragmática: Pragmática alude aos aspectos da linguagem que envolvem os usuários da língua, nomeadamente fenômenos psicológicos e sociológicos como utilidade, escopo de aplicação e efeitos sobre os usuários. Para linguagens de programação, a pragmática inclui questões como facilidade de implementação, eficiência na aplicação e metodologia de programação.

Estas foram apenas informações básicas sobre cada um. Para mais informações, você pode ler estes itens:

• Fonte-1
• Fonte-2 - | é um ótimo recurso |
• Fonte-3
• Fonte-4
• Fonte-5
• Sintaxe da Wikipédia
• wikipedia-Semântica