Combien de types de langages de programmation existe-t-il?
Fondamentalement, je veux apprendre beaucoup de langages de programmation pour devenir un excellent programmeur. Je ne connais qu'une poignée de détails et j'espérais que quelqu'un pourrait expliquer le nombre de classes ou types de langages de programmation existent. Comme la façon dont vous les regrouperiez si vous deviez les apprendre en groupe.
Venant d'un Java background, je suis familier avec la frappe statique, mais je sais qu'en plus de la frappe dynamique il doit y avoir une telle variété dans les langues disponibles que j'aimerais voir une ventilation catégorique si possible.
Cela dépend de la façon dont vous souhaitez classer les langues. Fondamentalement, les langues peuvent être divisées en deux types: impératif langues dans lesquelles vous indiquez à l'ordinateur comment effectuer une tâche, et déclaratif langues dans lesquelles vous dites à l'ordinateur ce que vous devez faire. Les langages déclaratifs peuvent en outre être décomposés en fonctionnel langages, dans lesquels un programme est construit en composant des fonctions, et logique langages de programmation, dans lequel un programme est construit à travers un ensemble de connexions logiques. Les langues impératives se lisent plus comme une liste d'étapes pour résoudre un problème, un peu comme une recette. Les langages impératifs incluent C, C++ et Java; les langages fonctionnels incluent Haskell; les langages de programmation logiques incluent Prolog.
Les langages impératifs sont parfois divisés en deux sous-groupes: procéduraux langages comme C, et langages orientés objet. Les langages orientés objet sont un peu orthogonaux aux regroupements, cependant, car il existe des langages fonctionnels orientés objet (OCaml et Scala étant des exemples).
Vous pouvez également regrouper les langues en tapant: statique et dynamique. Les langues à typage statique sont celles dans lesquelles la frappe est vérifiée (et généralement appliquée) avant d'exécuter le programme (généralement pendant une phase de compilation); les langages typés dynamiquement reportent la vérification de type à l'exécution. C, C++ et Java sont des langages à typage statique; Python, Ruby, JavaScript et Objective-C sont des langages à typage dynamique. Il existe également des langages non typés, qui incluent le langage de programmation Forth.
Vous pouvez également regrouper les langues par leur typage discipline : faible typage, qui prend en charge les conversions de types implicites, et fort typage, qui interdit les conversions de types implicites. Les lignes entre les deux sont un peu floues: selon certaines définitions, le C est un langage faiblement typé, tandis que d'autres le considèrent comme fortement typé. La dactylographie n'est pas vraiment un moyen utile de regrouper les langues, de toute façon.
- Assemblage
- procédurale
- De base
- C
- orienté objet
- C #
- Java
- déclaratif
- Prolog
- SQL
- Fonctionnel
- ZÉZAYER
- Haskell
Ce sont les principaux, mais il y a beaucoup d'autres paradigmes et il y a beaucoup de chevauchements entre eux.
Pour les types de langages de programmation (Paradigms), regardez ici:
http://en.wikipedia.org/wiki/Programming_paradigm
Pour d'autres caractéristiques des langages de programmation (par exemple Type Systems), regardez ici: http://en.wikipedia.org/wiki/Programming_language
Cliquez sur l'image pour voir le PDF.
Vous devriez regarder Paradigmes de programmation pour les nuls: ce que chaque programmeur devrait savoir par Peter Van Roy. Cela vous donnera un aperçu de la façon dont cela se passe à l'extérieur.
Si vous voulez aller plus loin, vous pouvez lire Concepts, techniques et modèles de programmation informatique . Vous n'apprendrez pas une multitude de langues de cette façon, mais vous apprendrez des paradigmes qui se cachent derrière différents types de langues. Ainsi, l'apprentissage d'une nouvelle langue vous sera plus facile.
Procédure: assemblage, Java, C #, F #, LISP, Fortran.
Ensemble basé: SQL.
Basé sur des modèles: Perl, Regex, Snobol.
Basé sur l'arbre: XSLT.
Basé sur la baie: APL.
Il existe différentes façons de répondre à cette question, mais en termes ils peuvent être classés comme:
Langage machine: Le langage machine est un langage de programmation de bas niveau. Il est facilement compris par les ordinateurs mais difficile à lire par les gens. C'est pourquoi les gens utilisent des langages de programmation de niveau supérieur. Les programmes écrits dans des langages de haut niveau sont également soit compilés et/ou interprétés en langage machine afin que les ordinateurs puissent les exécuter.
Langage d'assemblage: Le langage d'assemblage est une représentation du langage machine. En d'autres termes, chaque instruction de langage d'assemblage se traduit par une instruction de langage machine. Bien que les instructions en langage d'assemblage soient lisibles, les instructions sont toujours de bas niveau. Un inconvénient du langage d'assemblage est qu'il n'est pas portable, car chaque plate-forme est livrée avec un langage d'assemblage particulier.
Langage de haut niveau: Les langages de haut niveau sont ce que la plupart des programmeurs utilisent de nos jours. Les langages tels que C, C++ et Java sont tous des langages de haut niveau. Les avantages des langages de haut niveau sont qu'ils sont très lisibles et portables. Un inconvénient des langages de haut niveau est qu'ils sont moins puissant que les langages d'assemblage, car une seule instruction dans un langage de haut niveau est traduite en plusieurs instructions en langage machine.
Les langues de haut niveau peuvent en outre être classées comme:
Langages fonctionnels: Dans le langage fonctionnel, un programme est divisé en définitions de fonctions. Les langages fonctionnels sont une sorte de langage déclaratif. Ils sont principalement basés sur le lambda-calcul typé avec des constantes. Certains des langages de fonctions célèbres sont Scala, F #, Clojure et LISP.
Langages procéduraux: Dans Langages procéduraux, un programme est écrit dans une séquence d'étapes qui doivent être suivies pour produire un résultat. COBOL, FORTRAN et C sont quelques langages procéduraux.
Langages de programmation orientés objet: Dans les langages OOP), un programme est divisé en objets qui contiennent des données ainsi que des méthodes qui Java, C # et C++ sont des langages OOP.
Langages de programmation logique: Les langages logiques sont utilisés pour créer des programmes qui permettent à l'ordinateur de raisonner logiquement. ex: langage logique
Pour une étude approfondie, consultez:
J'ai tendance à penser en termes de fonctionnalités:
Syntaxe:
Basé sur C ou quoi d'autre. Java a une syntaxe basée sur C. Je recommande fortement d'essayer quelque chose comme Python ou Ruby pour sortir la tête) de la syntaxe et de penser davantage en termes de principes de fonctionnement d'un langage donné. Je suis d'avis qu'aucune syntaxe n'a besoin d'être plus volumineuse que celle basée sur C et n'a aucun problème à construire des blocs autour de l'espace blanc.
Compilé vs interprété avec Build-Process vs Interprétée/Console:
Je connais très peu les problèmes d'environnement de compilation par rapport à l'environnement d'exécution, mais je comprends qu'il y a tout un tas de problèmes auxquels je pense rarement.
De même, il existe de nombreux langages interprétés qui ont encore quelque chose d'un processus de compilation pour s'exécuter à l'intérieur d'une machine virtuelle comme Java le fait. Vous devez encore reconstruire pour voir les modifications des choses.
Et puis il y a JavaScript et Python que vous pouvez exécuter à la volée, commande par commande dans une console dans un environnement en direct. Les trois peuvent conduire à des manières très différentes d'écrire du code.
Typage dynamique vs strict:
J'ai tendance à voir les deux comme des compromis de conception. Lorsque vous êtes à un niveau beaucoup plus bas et que les performances sont essentielles, la saisie statique a beaucoup de sens. Je n'ai jamais compris cette notion d'un être "plus sûr" qu'un autre, mais je suis venu dans un langage très plastique/dynamique où vous venez d'apprendre comment fonctionne le système de frappe et à quoi s'attendre, en gros. Les manigances de type sont rarement une préoccupation pour moi dans JS. À certains égards, la flexibilité peut rendre les choses plus robustes, bien qu'il soit certes un peu plus mystérieux pour un développeur de niveau plus junior si vous ne connaissez pas certains des nids-de-poule dans la langue.
Portée au niveau bloc vs Portée fonction vs?:
Le niveau de bloc est le plus courant (n'importe quoi entre {} dans la plupart des langages de syntaxe basés sur c). La portée JavaScript est construite autour de fonctions (qui sont également utilisées pour construire des objets aussi efficacement). Il existe également une grande variation dans le type d'accès dont vous disposez d'une portée interne à une portée externe. Je ne connais pas les autres schémas de délimitation mais je suis sûr qu'ils existent.
Classique OOP vs Prototypal OOP vs Almost-OOP (structs en C?) Vs Non-OOP:
Même en classe OOP il y a beaucoup de place pour la variation. Que vous puissiez faire un héritage multiple (ew, bien en excès, ew), définir des interfaces, etc ...
En JavaScript, nous avons une sorte de prototype hybride rabougri OOP où les objets sont considérablement plus simples, hautement mutables, mais nous avons toujours la possibilité de séparer l'interface des préoccupations internes, ce qui, à mon avis, est l'aspect le plus important) d'encapsulation.
La chose à propos de OOP est qu'il y a vraiment beaucoup de choses que vous pouvez retirer qui sont essentiellement orientées OOP sans être techniquement OOP. Il y a des puristes bien sûr mais à la fin de la journée, Les modèles de conception consistent à réaliser certaines abstractions qui fonctionnent bien dans certaines situations. Ne soyez pas trop rapide pour supposer que les idées d'un langage basé sur la POO n'ont aucune utilité dans quelque chose qui est plus orienté vers la procédure. pas du tout limité par sa version maladroite d'un prototype basé sur le paradigme OOP.
Fonctions de première classe:
Ne pas les avoir dans une langue est une chose difficile à abandonner. Vous pouvez transmettre des fonctions comme s'il s'agissait de données à utiliser dans d'autres contextes. Cela rend les schémas de gestion des événements en particulier très faciles à implémenter, mais il est également très facile d'adapter le langage pour qu'il fonctionne comme vous le souhaitez. C'est, plus que tout ce que je soupçonne, ce qui a fait de JavaScript le succès qu'il a ultimement été malgré sa conception en deux semaines et la mise en place d'une syntaxe Java approximative en tant que schéma marketing.
Fermetures:
Je ne sais pas où en est le débat pour Java, mais je sais que beaucoup de développeurs Java réclamaient cette fonctionnalité il y a un an ou deux. Dans un langage sans clôture, quand un La fonction se ferme, tout ce qui est en mesure de faire référence à des éléments de l'intérieur de cette fonction ne pourra pas y accéder car elle a été récupérée. Dans une fermeture, le contexte d'exécution est lié de telle sorte que si vous pouvez référencer des éléments à l'intérieur de cette fonction fermée fonction d'une autre portée comme dans un objet ou une fonction retourné, vous obtenez essentiellement ces vars tels qu'ils étaient lorsque la fonction est fermée. C'est comme un coincement du pied dans la porte de la collecte des ordures, bien que je soupçonne qu'il est plus implémenté que des copies de ces vars vars locaux de l'entité référente.
Rigide/Strict/Sûr vs vous donnant toute la corde que vous voulez:
Les développeurs JS et Java ont tendance à ne pas se comprendre du tout et je pense que cela a beaucoup à voir avec les deux langages tombant sur des côtés presque opposés de ce spectre de conception particulier. Je ne ' Je ne veux pas que vous me protégiez de moi-même ou des autres développeurs de mon équipe. Je veux faire beaucoup plus avec beaucoup moins de code et tout faire de manière très différente (mais cohérente pour un domaine donné) selon la situation Il y a absolument des compromis entre les deux et beaucoup de langues ont tendance à se situer davantage au milieu.
Je pense qu'un raccourci pour tout cela est d'apprendre suffisamment de LISP pour faire des choses semi-utiles. La plupart de ces paradigmes ont commencé comme des moyens d'utiliser LISP, c'est donc un moyen simple d'essayer les choses.
Il existe un certain nombre de "types" de langues, mais de nouvelles peuvent toujours apparaître. Fondamentalement, le but d'un langage est de permettre le codage d'idées, de concepts ou d'exigences, aussi directement que possible. À cette fin, il peut y avoir des situations où les paradigmes existants font défaut, et un nouveau pourrait être nécessaire.
Une façon de voir est en termes de structure de surface. Comment cela vous permet-il d'encoder des idées de manière concise, de sorte que si vous changez d'avis sur ce que vous voulez, la modification correspondante du code est également facile, avec peu de chance d'introduire des bogues.
Une autre façon de voir les choses est en termes de structure de contrôle. Quand le langage est exécuté (s'il l'est) quel est l'ordre dans lequel les choses se produisent, pour accomplir ce que vous voulez? Exemples: exécution directe simple, récursivité, retour en arrière, parallélisme. Un I (toux modeste) découvert était exécution différentielle .
Un autre point de vue utile est que chaque fois qu'une structure de données est conçue, un langage naît. Les données sont "exécutées" par les programmes d'application qui les parcourent et font des choses, tout comme un programme n'est qu'un tas de données (comme des codes d'octets) qui sont utilisées par un interprète pour faire des choses.
Je dois ajouter qu'il existe des langages de programmation pour des applications spécifiques. Celui qui me vient à l'esprit est APT (Automatic Programmed Tool) un langage utilisé dans la fabrication de machines-outils.