Langage

Home

Language.

Besoin

Fournir des informations à la machine.

Analyse

Le langage de programmation est un formalisme (généralement textuel) :

compréhensible par l'homme (qui écrit le code source)
traduisible par un logiciel (compilateur, interpréteur) en une suite instructions compréhensibles par la machine (langage machine) : le code objet.

On peut distinguer les langages par :

leur mode d'exécution :
- interprétés : les instructions du code sources sont examinées à l'exécution puis traduite en langage machine.
- compilés : la traduction de l'interprétation est effectuée à l'avance, de sorte de le programme exécuté est dès le départ un ensemble d'instructions pour la machine.
- virtuels : à la fois compilés pour et interprétés par une machine virtuelle (Virtual Machine ou VM), c'est-à-dire une machine simulée par un logiciel réécrit pour différentes machines. L'objectif de cette virtualité est la portabilité et ce qu'elle implique (indépendance des contraintes d'un OS, d'une machine, optimisations dynamiques).
leur paradigme :
- procédural, qui se focalise sur le verbe : ouvre (porte). On se préoccupe alors plus des événements qui peuvent survenir dans une application, et de comment ils doivent survenir.
- OO, qui se focalise sur l'objet : porte.ouvre(). On se préoccupe alors plus des entités existantes et de leurs relations/interactions.
- hiérarchique
leur domaine d'application :
- programmation
- requêtes
- représentation
leur niveau d'abstraction :
- élévé : langages fonctionnels
- moyen : langages OO
- faible
- nul
leur génération :
- 1ère : langage machine (suite de bits)
- 2ème : assembleur (mnémoniques, manipulation de registres)
- 3ème : procédural
- 4ème : automatisation
- 5ème : interprétation du sens (langue naturelle, IA)

Conception

Un langage est constitué de :

mots-clés ou mots réservés, utiliser pour représenter des :
- déclarations
- affectations
- structures de contrôles
  - tests (if)
  - boucles (for, while)
  - branchements (goto, appel de méthode)

Exemples

Langages de programmation OO
		Version/ Fournisseur	GNU				1			1		ANSI	Borland
		Nom	Ada	C++	C#	Eiffel	Java			JavaScript		Pascal			SmallTalk	Commentaire
Domaine	Technologie	Produit/ Release	95					4	5	0	2		5	Delphi
Exécution			Machine	Machine	CLR		JVM			Interpréteur		Machine			Interpréteur
Compilation	Préprocesseur			Oui			Non			Non			Oui
Structures de données	Constantes		`constant`				`final`						`const`
	Enumérations		`type MonEnum is (A, B, C);`	`enum MonEnum { a, b, c}`			Non		`enum MonEnum { a, b, c }`			Oui
	Numériques	Entiers	`var: Integer var: Short_Integer`	`[unsigned] char, [unsigned] [long] int`	`byte short int long` `Byte Short Integer Long`	`INTEGER`	`byte short int long`		`Byte Short Integer Long`
	Numériques	Flottants	`Float Long_Float`	`float, [long] double`	`float Float`	`REAL DOUBLE`	`float`		`Float`
	Caractères	Unique	`Character`	`char` (8 bits)	`char`		`char`		`Character`
	Caractères	Chaîne	`String var`	`char*`	`String`	`CHARACTER`	`String`
	Booléen		`Boolean`		`boolean Boolean`		`boolean Boolean`
	Enregistrements		`record`	`struct`		Classes	Classes					record
	Type génériques	Templates	`generic type MonType`	Oui		`var : Classe[ Type]`	Non		`Classe<Type>`	Non						Modèles ou "patrons" de classes
	OO	Héritage simple	Oui	Oui	`Classe1: Classe2`	`Classe1 inherit Classe2`	`Classe1 extends Classe2`					Non	Oui		Oui
	OO	Héritage multiple	Non	Oui	`Classe1: Interface1, Interface2`	`Classe1 inherit Classe2 Classe3`	`Classe1 implements Interface1, Interface2`					Non			Oui
Structures de contrôle	Condition		`if (cond) then`	`if (cond) ...`	`if (cond) ...`		`if (cond) ...`			`if (cond) ...`		`if cond then ...`
	Cas		`case var is when val1 => ... when val2 => ... end case;`	`switch (var) { case x: break; }`	`switch (var) { case val1: break; case val2: break; }`		`switch (var) { case val1: break; case val2: break; }`			`switch (var) { x: break; }`
	Boucle	Itération	`for var in [reverse] discreteRange loop ... end loop;`	`for (init; while; inc) ...`	`foreach (var in col) ...`		`for (init; while; inc) ...`			`for (init; while; inc) ...`
		Un au moins		`do ... while`			`do ... while`			`do ... while`
		Tant que		`while (cond) ...`			`while (cond) ...`			`while (cond) ...`
		Suite		`continue`			`continue`			`continue`
		Stop		`break`			`break`			`break`
Gestion des erreurs	Exceptions		Oui	Oui			Oui			Non	Oui	Non		Oui
Robustesse	Contrôle des conversions			Non			Oui								Non
	Contrôle des limites de tableau			Non			Oui
	Contrôle division par zéro						Oui
Gestion mémoire	Pointeurs			Oui			Non						Oui	Oui
	Allocation	Automatique		Non			Oui					Non	Non	Non
	Libération	GC	Oui	Non			Oui					Non	Non	Non	Oui	Garantie de robustesse
Mise au point	Assertions			`assert.h`			Non	Oui

L2G
		Version/ Fournisseur		Microsoft
		Nom	BASIC		COBOL	PERL	Commentaire
Domaine	Technologie	Produit/ Release		Visual Basic
Exécution	Interpréteur		Oui			Oui
	VM		Non			Non
	Machine					Non
Compilation	Préprocesseur
Structures de données	Constantes		Non
	Enumérations		Non
	Numériques	Entiers	`var%`			32 bits
	Numériques	Flottants	`var! var#`			32 bits
	Caractères	Unique	Non			32 bits
	Caractères	Chaîne	`var$`			Suite de 32 bits
	Enregistrements		Non
	Type génériques	Templates	Non				Modèles ou "patrons" de classes
Structures de contrôle	Condition		`if cond then ...`			`if (cond) { }`
	Cas
	Boucle	Itération	`FOR var=exp TO exp [STEP exp]`			`foreach $var (liste) ...`
		Un au moins
		Tant que
		Suite	`NEXT var`
		Stop
Gestion des erreurs	Exceptions
Robustesse	Contrôle des conversions
	Contrôle des limites de tableau
	Contrôle division par zéro
Gestion mémoire	Pointeurs
	Allocation	Automatique
	Libération	GC					Garantie de robustesse
Mise au point	Assertions

Langages de requêtes
		Version/ Fournisseur
		Nom	SQL	OQL	EJBQL	JDOQL	Commentaire
Domaine	Technologie	Release

Langages de représentation
		Version/ Fournisseur
		Nom	SGML	HTML	XML	Commentaire
		Produit/ Release
Domaine	Technologie	FixPack

Notes

Niveau d'abstraction où apparaissent généralement les traces
Utilisé lors de l'implémentation
Généralement réalisée à l'aide d'un EDI

Home