B (langage de programmation) - B (programming language)

Cet article concerne un langage développé aux Bell Labs. Pour le langage "b" de Meertens et Pemberton, voir ABC (langage de programmation) . Pour d'autres utilisations, voir B (homonymie) .
B
Conçu par Ken Thompson
Développeur Ken Thompson , Dennis Ritchie
Première apparition 1969 ; il y a 52 ans ( 1969 )
Discipline de frappe sans type (tout est un mot )
Extensions de nom de fichier .b
Influencé par
BCPL , PL/I , TMG
Influencé
C

B est un langage de programmation développé aux Bell Labs vers 1969. Il a été développé par Ken Thompson et Dennis Ritchie .

B est dérivé de BCPL , et son nom est peut-être une contraction de BCPL. Le collègue de Thompson, Dennis Ritchie, a supposé que le nom pourrait être basé sur Bon, un langage de programmation antérieur, mais sans rapport, que Thompson a conçu pour être utilisé sur Multics .

B a été conçu pour les applications récursives, non numériques et indépendantes de la machine, telles que les logiciels système et de langage. C'était un langage sans type, le seul type de données étant le format de mot de mémoire naturel de la machine sous-jacente , quel qu'il soit. Selon le contexte, le mot a été traité soit comme un entier ou une adresse mémoire .

Au fur et à mesure que les machines avec traitement ASCII sont devenues courantes, notamment le DEC PDP-11 qui est arrivé chez Bell, la prise en charge des données de caractères fourrées dans les mots de mémoire est devenue importante. La nature de la langue sans type a été considérée comme un désavantage, ce qui a conduit Thompson et Ritchie pour développer une version élargie de la langue charge de nouveaux types internes et définis par l' utilisateur, qui est devenu le langage de programmation C .

Histoire

Vers 1969, Ken Thompson et plus tard Dennis Ritchie ont développé B en le basant principalement sur le langage BCPL Thompson utilisé dans le projet Multics . B était essentiellement le système BCPL dépouillé de tout composant dont Thompson pensait pouvoir se passer afin de l'adapter à la capacité de mémoire des mini-ordinateurs de l'époque. La transition BCPL vers B comprenait également des modifications apportées pour s'adapter aux préférences de Thompson (principalement dans le sens de la réduction du nombre de caractères non blancs dans un programme typique). Une grande partie de la syntaxe typique de type ALGOL de BCPL a été assez fortement modifiée dans ce processus. L'opérateur d'affectation est :=revenu au =de Rutishauser de Superplan , et l'opérateur d'égalité =a été remplacé par ==.

Thompson a ajouté des "opérateurs d'affectation à deux adresses" en utilisant la x =+ ysyntaxe pour ajouter y à x (en C, l'opérateur s'écrit +=). Cette syntaxe est venue de l' implémentation de Douglas McIlroy de TMG , dans laquelle le compilateur de B a été implémenté pour la première fois (et elle est venue à TMG de la syntaxe d' ALGOL 68x +:= y ). Thompson est allé plus loin en inventant les opérateurs d'incrémentation et de décrémentation ( ++et --). Leur position de préfixe ou de suffixe détermine si la valeur est prise avant ou après la modification de l'opérande. Cette innovation ne figurait pas dans les premières versions de B. Selon Dennis Ritchie, les gens pensaient souvent qu'ils avaient été créés pour les modes d'adresse à incrémentation automatique et à décrémentation automatique du DEC PDP-11, mais cela est historiquement impossible car la machine n'a pas n'existait pas lorsque B a été développé pour la première fois.

La version point-virgule de la boucle for a été empruntée par Ken Thompson aux travaux de Stephen Johnson .

B est sans type, ou plus précisément a un type de données : le mot informatique. La plupart des opérateurs (par exemple +, -, *, /) ont traité cela comme un entier, mais d'autres l'ont traité comme une adresse mémoire à déréférencé . À bien d'autres égards, cela ressemblait beaucoup à une première version de C. Il existe quelques fonctions de bibliothèque, y compris certaines qui ressemblent vaguement à des fonctions de la bibliothèque d'E/S standard en C. Selon les mots de Thompson : « B et l'ancien vieux C étaient langages très très similaires sauf pour tous les types [en C]".

Les premières implémentations concernaient les mini-ordinateurs DEC PDP-7 et PDP-11 utilisant les premiers Unix , et les mainframes Honeywell GE 645 36 bits exécutant le système d'exploitation GCOS . Les premières implémentations de PDP-7 ont été compilées en code threadé , et Ritchie a écrit un compilateur utilisant TMG qui a produit du code machine. En 1970, un PDP-11 a été acquis et un code fileté a été utilisé pour le port ; un assembleur,courant continu, et le langage B lui-même ont été écrits en B pour amorcer l'ordinateur. Une première version de yacc a été produite avec cette configuration PDP-11. Ritchie a pris en charge la maintenance pendant cette période.

La nature sans type de B avait du sens sur le Honeywell, le PDP-7 et de nombreux ordinateurs plus anciens, mais était un problème sur le PDP-11 car il était difficile d'accéder avec élégance au type de données de caractère que le PDP-11 et la plupart des ordinateurs modernes prennent entièrement en charge. . À partir de 1971, Ritchie a apporté des modifications au langage tout en convertissant son compilateur pour produire du code machine, en ajoutant notamment le typage des données pour les variables. Au cours des années 1971 et 1972, B a évolué en "Nouveau B" (NB) puis en C.

B est presque éteint, ayant été remplacé par le langage C . Cependant, il continue d'être utilisé sur les mainframes GCOS (à partir de 2014) et sur certains systèmes embarqués (à partir de 2000) pour diverses raisons : matériel limité dans les petits systèmes, bibliothèques étendues, outillage, problèmes de coût de licence et tout simplement bon assez pour le travail. Le très influent AberMUD a été écrit à l'origine en B.

Exemples

Les exemples suivants sont tirés de la référence des utilisateurs à B par Ken Thompson : 

/* The following function will print a non-negative number, n, to
   the base b, where 2<=b<=10.  This routine uses the fact that
   in the ASCII character set, the digits 0 to 9 have sequential
   code values.  */

printn(n, b) {
        extrn putchar;
        auto a;
        /* Wikipedia note: the auto keyword declares a variable with
           automatic storage (lifetime is function scope), not
           "automatic typing" as in C++11. */

        if (a = n / b)        /* assignment, not test for equality */
                printn(a, b); /* recursive */
        putchar(n % b + '0');
}

/* The following program will calculate the constant e-2 to about
   4000 decimal digits, and print it 50 characters to the line in
   groups of 5 characters.  The method is simple output conversion
   of the expansion
     1/2! + 1/3! + ... = .111....
   where the bases of the digits are 2, 3, 4, . . . */

main() {
	extrn putchar, n, v;
	auto i, c, col, a;

	i = col = 0;
	while(i<n)
		v[i++] = 1;
	while(col<2*n) {
		a = n+1;
		c = i = 0;
		while (i<n) {
			c =+ v[i] *10;
			v[i++]  = c%a;
			c =/ a--;
		}

		putchar(c+'0');
		if(!(++col%5))
			putchar(col%50?' ': '*n');
	}
	putchar('*n*n');
}
v[2000];
n 2000;

Voir également

Octicons-terminal.svg Portail de programmation informatique

Remarques

Les références

Liens externes