Si vous apprenez une langue, vous avez probablement entendu le mot « syntaxe » et vous l'utilisez tout le temps. (Putain d'erreur de syntaxe).

C'était il y a quelques nuits que je pensais, je n'ai jamais suivi sérieusement les paradigmes et les techniques de programmation, et aujourd'hui j'ai commencé à apprendre des plus petits sujets que j'entends toujours (même si je m'en souviens déjà). J'ai créé ce référentiel. Le parcours d'apprentissage que j'ai suivi est caractéristique (dans le fichier LEARNING_LIST.md). Passons, contrairement aux langages naturels, avec lesquels nous communiquons nos pensées et nos sentiments, les langages de programmation peuvent être considérés comme des langages artificiels définis par des hommes et des femmes initialement dans le but de communiquer avec des ordinateurs mais, tout aussi important, pour communiquer des algorithmes entre les gens. .
Par exemple, les définitions de langage se composent de trois composants :

• Syntaxe : la syntaxe d'un langage de programmation est l'ensemble de règles qui définissent les combinaisons de symboles qui sont considérées comme des programmes correctement structurés dans ce langage. La syntaxe d'un langage définit sa forme superficielle. Les langages de programmation textuels sont basés sur des séquences de caractères. La grammaire lexicale d'un langage textuel spécifie comment les caractères doivent être regroupés en jetons. La syntaxe fait référence à la manière dont les symboles peuvent être combinés pour créer des phrases (ou des programmes) bien formées dans le langage. La syntaxe définit les relations formelles entre les constituants d'une langue, fournissant ainsi une description structurelle des différentes expressions qui constituent les chaînes juridiques de la langue. La syntaxe traite uniquement de la forme et de la structure des symboles dans une langue sans aucune considération pour leur signification, la syntaxe est le concept qui se préoccupe uniquement de savoir si la phrase est valide ou non pour la grammaire de la langue

• Sémantique : la sémantique indique si la phrase a ou non un sens valide. La sémantique révèle la signification des chaînes syntaxiquement valides dans un langage. Pour les langues naturelles, cela signifie corréler des phrases et des expressions avec les objets, les pensées et les sentiments de nos expériences. Pour les langages de programmation, la sémantique décrit le comportement qu'un ordinateur suit lors de l'exécution d'un programme dans le langage. Nous pourrions divulguer ce comportement en décrivant la relation entre l'entrée et la sortie d'un programme ou en expliquant étape par étape comment un programme s'exécutera sur une machine réelle ou abstraite. La sémantique est le terme général désignant l'étude du sens. En informatique, le sujet de la sémantique des langages de programmation cherche à donner une signification mathématique précise aux programmes.

Sémantique de bas niveau :

Dans les langues naturelles, une phrase peut être grammaticalement correcte mais sémantiquement dénuée de sens. Par exemple, la phrase :

"L'homme a acheté l'Infinity au magasin."

C'est grammaticalement correct mais n'a aucun sens dans le monde réel. De même, dans les langages de programmation, une instruction peut être syntaxiquement correcte mais sémantiquement incorrecte car elle viole les règles du langage ou sa signification prévue.

Au niveau de la sémantique de bas niveau de la programmation, nous nous demandons si une instruction dont la syntaxe est correcte a également un sens selon le système de types du langage ou d'autres règles. Même si la syntaxe peut être valide, la signification sémantique de l'opération peut être invalide. Le système de types dans les langages à typage statique, comme Java, permet d'appliquer ces règles avant l'exécution, mais les langages à typage dynamique comme JavaScript n'appliquent pas toujours ces règles avant l'exécution.

Exemple en JavaScript :

En JavaScript, qui est peu typé, vous ne bénéficierez peut-être pas de la protection offerte par un système de types plus strict, et le langage autorisera certaines opérations qui n'ont pas de sens d'un point de vue sémantique. Considérez le code JavaScript suivant :

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

Ici, la syntaxe est parfaitement valide, et JavaScript autorise l'affectation, mais sémantiquement c'est étrange. Vous essayez d'attribuer un nombre (42) à une variable qui est vraisemblablement destinée à contenir une chaîne (nom). Il n'y a pas de vérification de type en JavaScript pour vous empêcher de commettre cette erreur, mais il s'agit d'une erreur sémantique de bas niveau car elle n'est pas cohérente avec l'intention du développeur.
Si nous le mettons en œuvre. Il est exécuté. sans aucune erreur !

Dans des langages plus stricts, comme TypeScript ou Java, cela déclencherait une erreur de type immédiatement lors de la compilation.

Exemple en TypeScript :

TypeScript, un sur-ensemble de JavaScript, introduit la vérification de type pour éviter ces problèmes sémantiques de bas niveau :

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

Dans TypeScript, le compilateur détecte l'erreur sémantique car 42 est un nombre et ne peut pas être affecté à une variable déclarée sous forme de chaîne. Cette application des types protège le développeur des erreurs involontaires.

En JavaScript, pour éviter ces problèmes sémantiques de bas niveau, les développeurs utilisent souvent des contrôles d'exécution :

let name = "Alice";

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

Même si JavaScript n'impose pas les types, l'ajout de vérifications manuelles peut aider à éviter les erreurs lorsque des types incorrects entraînent des problèmes dans le programme.

Sémantique de haut niveau :

À un niveau supérieur, la sémantique concerne ce que votre programme est censé réaliser. Il ne s'agit pas seulement de savoir si le programme a une syntaxe valide ou si les types s'alignent correctement : il s'agit de savoir si le programme se comporte de la manière souhaitée par le développeur ou résout le problème pour lequel il a été conçu.

Par exemple, disons que vous construisez un système de négociation d'actions simple. La sémantique de haut niveau de votre code vise à garantir que le système négocie les actions de la bonne manière, avec la bonne logique métier. Même si le code ne produit pas d'erreurs de type ou de syntaxe, il peut quand même ne pas répondre aux fonctionnalités prévues.

Exemple en JavaScript :

Regardons un exemple JavaScript de sémantique de haut niveau utilisant un scénario de négociation d'actions simplifié :

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

La syntaxe est correcte et le programme s'exécute sans erreur. Cependant, imaginez que nous introduisions maintenant une erreur à un niveau supérieur, comme la saisie accidentelle de deux transactions pour le même symbole, ce qui viole les règles commerciales du système.

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

Ici, les deux transactions sont traitées indépendamment, mais le système se retrouve avec deux transactions sur le même symbole, une dans le sens d'achat et une dans le sens de vente. Cela enfreint la règle commerciale de haut niveau selon laquelle nous ne devrions avoir qu'une seule transaction ouverte par symbole à un moment donné.

Bien que le code s'exécute sans erreurs de syntaxe ou de type, il est sémantiquement incorrect à un niveau élevé. La logique du système aurait dû garantir qu'une seule transaction par symbole puisse être active à la fois. Cette erreur entraînerait probablement des conséquences inattendues dans un système commercial réel, telles qu'une perte financière.

Pour résoudre ce problème sémantique de haut niveau, vous devez ajuster la logique pour garantir qu'une seule transaction est ouverte pour un symbole particulier :

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

Ici, la logique garantit qu'une nouvelle transaction ne peut pas être ouverte s'il existe déjà une transaction active pour le même symbole. Il s'agit d'un correctif sémantique de haut niveau car il répond à la logique métier de base que le programme est censé suivre, plutôt qu'à un problème de syntaxe ou de type.

• Pragmatique : La pragmatique fait allusion aux aspects du langage qui impliquent les utilisateurs du langage, à savoir les phénomènes psychologiques et sociologiques tels que l'utilité, le champ d'application et les effets sur les utilisateurs. Pour les langages de programmation, la pragmatique inclut des questions telles que la facilité de mise en œuvre, l'efficacité de l'application et la méthodologie de programmation.

Il ne s'agissait que d'informations de base sur chacun. Pour plus d'informations, vous pouvez lire ces éléments :

• Source-1
• Source-2 - | est une excellente ressource |
• Source-3
• Source-4
• Source-5
• Syntaxe Wikipédia
• wikipedia-Sémantique