À quoi voulez-vous que les créateurs de langue s'intéressent? [fermé]

Le but de cette question n'est pas de dresser une liste exhaustive de fonctionnalités de langage de programmation sans lesquelles vous ne pourriez pas vivre ou que vous souhaitiez être dans la langue principale de votre choix. Le but de cette question est de mettre en lumière des recoins du design linguistique que la plupart des concepteurs de langage pourraient ne pas penser. Ainsi, au lieu de penser à la fonctionnalité de langage X, pensez un peu plus philosophiquement.

Un de mes partis pris, et peut-être que cela puisse être controversé, est que le côté le plus délicat de l’ingénierie - le pourquoi et le pour lequel - est plus important que le côté plus concret. Par exemple, Ruby a été conçu dans le but d'améliorer le bonheur des développeurs. Bien que vos opinions puissent être partagées sur le point de savoir si cela a été livré ou non, le fait qu’il s’agisse d’un objectif signifie que certains des choix de conception de langage ont été influencés par cette philosophie.

Merci de ne pas poster:

• Syntaxe des guerres de flammes. Regardons les choses en face, nous avons nos préférences et la syntaxe est importante en ce qui concerne la conception du langage. Je veux juste éviter les batailles épiques de la nature de emacs vs. VI (dont un grand nombre de personnes ne savent rien aujourd'hui).
• Les commentaires de type "Toute langue dépourvue de fonctionnalité X ne mérite pas d'exister". Tous les langages de programmation ont au moins une raison - bonne ou mauvaise.

S'il vous plaît faire après:

• Idées philisophiques que les concepteurs de langage semblent manquer.
• Les concepts techniques qui semblent être mal mis en œuvre le plus souvent. Veuillez donner un exemple de la douleur que cela provoque et si vous avez une idée de la façon dont vous préférez que cela fonctionne.
• Les éléments que vous souhaitez figurent dans la bibliothèque commune de la plate-forme, mais ils le sont rarement. De la même façon, les éléments qui se trouvent généralement dans une bibliothèque commune et que vous ne souhaitez pas.
• Fonctionnalités conceptuelles telles que la prise en charge intégrée du traitement des tests / assertions / contrats / erreurs que vous souhaitez que tous les langages de programmation implémentent et définissent correctement.

J'espère que ce sera un sujet amusant et stimulant.

Edit: Clarifié ce que je veux dire par la syntaxe Flame Wars. Je n'essaie pas d'éviter toute discussion sur la syntaxe, en particulier parce que la syntaxe est un élément fondamental de la conception du langage de programme.

Support Unicode par défaut

De nos jours, les programmes sont développés pour être utilisés à l’international ou dans l’hypothèse où ils pourraient être utilisés à l’international. Ils doivent fournir un soutien pour leurs jeux de caractères ou rendre des programmes écrits dans cette langue inutiles.

J'ai un couple:

• Génériques / modèles. Par exemple, les génériques Java sont puissants, mais pas nécessairement flexibles. De plus, comme ils utilisent le type effacement, j'ai rencontré des problèmes pour les implémenter de manière abstraite, en particulier dans les interfaces. Et le compilateur ne devrait pas avertir lorsqu'un générique non spécifique est utilisé (comme Hashmapau lieu de Hashmap<String, int>). Je pense qu'ils pourraient être améliorés de manière significative. De bons modèles sont très utiles, mais souvent négligés.

• Le support de Good Date dans la bibliothèque standard. Je veux dire pouvoir ajouter et soustraire des dates, des heures et des minutes et ne pas avoir à gérer le nombre de millisecondes écoulées depuis le 1er janvier 1970.

Veuillez rendre votre langue analysable / auditable pour les responsables de la sécurité informatique.

Les personnes chargées de la sécurité doivent être en mesure de détecter les vulnérabilités d'un programme avant son expédition. Idéalement, nous sommes appelés tôt et pouvons commenter la base de code au fur et à mesure de son développement, mais souvent pas.

Quand une nouvelle version du langage ou des librairies de base sortent, les choses qui étaient auparavant sûres ne sont peut-être plus:

1. les bibliothèques peuvent devenir plus puissantes: par exemple, la bibliothèque d'URL prend désormais en charge javascript:
2. il peut y avoir de nouvelles façons de convertir des chaînes ou des octets en code: par exemple, evalou des bibliothèques de désérialisation
3. les techniques de réflexion linguistique peuvent devenir plus puissantes: par exemple, exposer des variables locales

N'importe lequel de ces changements peut augmenter la quantité d'autorité abusable d'un programme, mais comme l'autorité utilisée par le programme (lorsqu'il traite avec des clients non malveillants) n'a pas changé, les responsables de la sécurité ont du mal à comprendre cela sans une utilisation intensive. ré-audit.

Alors, pensez à nous lors de la conception et de la gestion de la langue. Voici quelques conseils:

Définissez quelques primitives dans lesquelles un programme peut être décomposé.

HTML5 est particulièrement mauvais de cette façon. Ils ont évidemment beaucoup réfléchi à la sécurité et ont des personnes très intelligentes, mais au lieu de spécifier de nouveaux éléments de programme, tels que les <video>anciens, ou de créer une abstraction commune que les nouveaux <video>et les anciens <img>puissent être spécifiés, <video>c'est encore un autre élément ponctuel du programme avec ses propres conséquences pour la sécurité.

Assurez-vous que votre langage est sujet à l'analyse statique (même s'il n'est pas typé de manière statique).

Les spécialistes de la sécurité ont souvent recours à l'analyse statique pour rechercher des modèles et pour tenter d'éliminer certaines parties d'un programme afin qu'ils puissent se concentrer sur les éléments les plus difficiles.

Il devrait être évident que les identificateurs sont des variables locales et ceux qui ne le sont pas.

Par exemple, ne commettez pas la même erreur que les anciennes versions de JavaScript, il était donc impossible de savoir s'il xs'agit d'une référence de variable locale dans la liste ci-dessous (d'après une lecture littérale d'une ancienne version de la spécification):

if (Math.random() > 0.5) {
  Object.prototype.x = 0;
}

function f() {
  var x = 1;
  (function () {
    alert(x);  // Might alert 0, might alert 1.
  })();
}

Autoriser la sécurité décomposable

Un grand nombre de systèmes sécurisés sont conçus autour d'un noyau sécurisé qui préserve les propriétés de sécurité, afin que les spécialistes de la sécurité puissent concentrer leurs efforts sur l'analyse d'une petite quantité de code et évitant ainsi à la plupart des programmeurs d'avoir à traiter avec des spécialistes de la sécurité {agaçants, pédants, paranoïa} .

Il devrait être possible d'écrire un tel noyau dans votre langue. Si l'une des propriétés de sécurité de votre langue est que seul un certain sous-ensemble d'URL sera récupéré, les auteurs du noyau peuvent-ils faire quelque chose pour canaliser toutes les URL extraites à travers leur code? Ou bien les vérifications de construction statiques (telles que l’analyse des importations) remplissent la même fonction.

Certaines langues telles que Newspeak utilisent un modèle de fonctionnalités d'objet. C'est génial et un excellent moyen d'obtenir une sécurité décomposable.

Mais si vous ne pouvez pas faire cela, transformer le graphique en module en un artefact analysable statiquement peut vous procurer un avantage certain. Si je peux prouver qu'un module ne peut pas atteindre le module d'E / S de fichier (sauf en appelant du code dans un module du TCB), je peux alors exclure des classes entières de problèmes de ce module.

Limiter l'autorité des langages de script intégrés

Un grand nombre de systèmes utiles sont organisés comme un noyau statique qui lance beaucoup de code écrit dans des langages dynamiques (même fonctionnels).

Et l'intégration de langages de script peut rendre un système beaucoup plus extensible.

Mais un langage de script ne devrait pas avoir toute l'autorité de la machine virtuelle.

Si vous choisissez d'autoriser les langages de script intégrés, aidez-le à limiter ce qu'il peut faire. Un modèle de capacités d'objet (voir le commentaire sur Newspeak ci-dessus) est très approprié ici; Ainsi, lors de l'évaluation du code dans un langage de script, l'appelant doit transmettre le code à exécuter et toutes les variables globales pour ce code.

Traiter evalcomme un langage s’intégrant comme un langage de script

Si votre langage peut appeler son propre compilateur pour transformer une chaîne en code, autorisez-le à être mis en bac à sable de la même façon que vous le feriez avec un langage de script intégré.

Utilisez un modèle de concurrence simple

Nous, les responsables de la sécurité, n’aimons pas avoir à nous inquiéter des conditions de concurrence lorsque nous essayons de déterminer si une propriété de sécurité est conservée.

Veuillez envisager des alternatives au threading avant de choisir des threads comme une option par défaut presque impossible à sécuriser.

Un exemple simple est la concurrence d'accès aux boucles d'événement, similaire à celle trouvée dans E, Verilog et JavaScript.

N'encourage pas la confusion

Certaines langues sont des langues collées, et elles finissent par traiter des chaînes dans beaucoup de langues différentes.

Par exemple, JavaScript compose souvent des chaînes HTML, CSS, XML, JSON et même JavaScript. Il est très difficile pour les programmeurs de se rappeler d’encoder correctement les chaînes de texte brut lorsqu’ils les combinent pour créer des chaînes dans d’autres langues. Les programmes JS ont donc, sans surprise, toutes sortes de problèmes de confusion entre guillemets: XSS étant le pire.

Si vous souhaitez inclure des fonctionnalités de composition de chaîne, essayez de réduire la charge de sécurité du programmeur. Les DSL, les macros hygiéniques et les langages de gabarit intégrés peuvent être un excellent moyen de le faire en allégeant la tâche qui consiste à échapper correctement aux développeurs de bibliothèques ou de langages et à les éloigner du développeur final.

Certaines des meilleures langues ont été conçues par des personnes qui voulaient se créer une langue.

Je pense donc que les concepteurs de langues devraient accorder moins d’attention à leurs utilisateurs. Vous ne pouvez pas plaire à tout le monde, vous ne devriez pas non plus essayer.

Seulement 5 à 10% du temps est réellement consacré à l'écriture de code. Les concepteurs de langages doivent être attentifs aux difficultés rencontrées pour que le logiciel fonctionne, ce qui signifie corriger les erreurs et les bogues.

Cela signifie qu’il devrait y avoir dès le départ un bon débogueur. Pas un outil avec une syntaxe arcanique et des commandes clés qui n’est que légèrement meilleur que des tonnes d’instructions print.

Je pense qu'ils devraient prêter attention à Python, qui fait plus de choses que toute autre langue que j'ai rencontrée (et cela même si vous n'aimez pas certaines fonctionnalités). Cela ne signifie pas qu'ils doivent émuler Python, mais il est important de savoir ce que Python a bien fait, même si vous ne voulez pas du tout créer un langage comme celui-ci.

En ce qui concerne les idées philosophiques pertinentes ici, ce sont les plus importantes du zen de Python:

• Explicite est meilleur qu'implicite.
• La lisibilité compte.
• Les cas spéciaux ne sont pas assez spéciaux pour enfreindre les règles.
• Bien que la praticité bat la pureté.
• Il devrait y avoir une - et de préférence une seule - manière évidente de le faire.
• Si la mise en œuvre est difficile à expliquer, c'est une mauvaise idée.
• Les espaces de noms sont une idée géniale - faisons-en plus!

Je pense qu'un langage qui respecte ces règles doit nécessairement être assez correct, mais je ne connais que celui qui le fait, et c'est Python. Malgré toutes les similitudes avec Ruby, par exemple, dans sa mise en œuvre, Ruby omet des choses comme la lisibilité et vous invite à faire du golf au code, ce qui est amusant, mais inutile dans un cadre professionnel.

La seule caractéristique technique qui me manque en Python est une déclaration "jusqu'à ce que" (comme tout le temps, mais ne pas tester l'expression la première fois). Ensuite, il y a beaucoup de choses qui pourraient être améliorées dans les bibliothèques standard de Python et d'autres langages, mais ce n'est pas strictement des langages , c'est donc une question différente. :-)

La possibilité de modifier la langue selon vos besoins est un atout majeur pour moi. Pour Lisp, cela se fait avec des macros, pour Tcl avec un niveau supérieur. Dans une moindre mesure, Ruby utilise des lambdas et autres. Je veux simplement pouvoir ajouter de nouvelles structures de contrôle adaptées au problème plutôt que de formuler mes problèmes autour des structures de contrôle disponibles. À titre d’exemple simple, la construction "do .. Until" qui existe dans certaines langues mais pas d’autre est une façon plus simple de traiter des cas que "while", il est extrêmement utile de pouvoir ajouter de nouvelles structures pour répondre à d’autres cas.

De manière plus générale, il s'agit de métaprogrammation ... mais je l'utilise principalement pour la construction de nouvelles structures de contrôle.

La chose la plus importante est que votre langue doit avoir un "style". Par exemple, j'appellerais C un langage de programmation système basé sur un pointeur. J'appellerais Erlang un langage de programmation hautement concurrentiel. Certains autres langages (comme C ++ et sans doute Java) sont ce que Allan Kay a appelé les langages "agglutinatifs": les langages Frankenstein consistaient en un ensemble de fonctionnalités assemblées.

La chose la plus importante à faire est que les changements apportés à la langue elle-même ne devraient être qu’un dernier recours. Même les sons les plus bénins peuvent devenir complexes lorsqu'ils sont combinés avec les autres fonctionnalités de la langue. Je dirais que pour mettre une nouvelle fonctionnalité dans une langue, vous devez:

1. Prouvez que c'est vraiment nécessaire.
2. Prouvez que cela ne peut pas être fait dans une bibliothèque.
3. Prouver qu'il appartient à la langue.

Merci pour une bonne question. Vous obtenez de très bonnes réponses.

Pour ne pas briller sur vos yeux, je considère un programmeur comme un canal d’information. Les idées / concepts / exigences vont d'un côté et le code en sort de l'autre.

Si vous prenez un ensemble d'exigences (quelle que soit leur formulation) et l'ensemble de code sur un énorme tableau blanc, et tracez des lignes mappant chaque exigence sur le code qui l'implémente, la complexité de ce graphique dépendra de la qualité du code. exprime les exigences. Idéalement, cela devrait être assez direct et individuel, mais c'est difficile à mettre en pratique.

Je mesure la spécificité de domaine d'une langue comme la mesure dans laquelle elle simplifie ce graphique. C’est une propriété extrêmement souhaitable et elle peut être abordée de différentes manières, en définissant simplement les bonnes classes / routines (noms / verbes), les macros, en passant par votre propre analyseur et interprète / compilateur.

Laissez-moi juste donner un exemple de ce que je veux dire. Pour le problème de la création d'interfaces utilisateur de dialogue flexibles, cette technique évite d'avoir à écrire des gestionnaires d'événement, le transfert de données, la plupart des tâches généralement effectuées dans les interfaces utilisateur. Il en résulte également une réduction du code source d'environ un ordre de grandeur. Le méta-langage n'est en réalité que quelques routines et macros en C / C ++ / Lisp, et je l'ai également fait dans des langages sans macros.

Si l'implémentation d'une exigence peut être réalisée avec des modifications de code en 5 points ou avec 10, le faire avec 5 équivaut non seulement à moins de code, mais également à moins de chances de rater une étape et de poser un bogue. Ainsi, plus une langue est spécifique à un domaine, plus le code est petit, facile à gérer et sans bogues. Je pense que nous devons savoir comment nous y prendre. Cela ne signifie pas que le code est plus lisible, sauf si le lecteur a investi dans la courbe d'apprentissage pour comprendre la technique.

Types entiers bornés et distincts comme en Pascal et Ada. Honnêtement: à quelle fréquence avez-vous besoin de la plage complète d'un nombre entier? Je pense qu'il y a beaucoup à améliorer dans les types primitifs pour mieux représenter le monde réel.

Certaines fonctionnalités facilitent l'utilisation des langages de programmation une fois que vous les avez appris, et d'autres facilitent leur apprentissage. Etant donné que les utilisateurs d'une langue entretiennent idéalement une relation à long terme avec celle-ci, optimiser pour une facilité d'utilisation vaut mieux que pour optimiser pour une facilité d'apprentissage. Ne rendez pas les choses plus difficiles que nécessaire, mais ne sacrifiez pas l'expressivité (être capable d'écrire un petit code qui en fait beaucoup) pour plus de lisibilité pour ceux qui ne sont pas familiers avec le langage. D'un autre côté, le langage ne doit pas être interprété comme un bruit de ligne par les personnes qui le travaillent depuis des années. ce ne serait pas facile à utiliser ou à apprendre.

Conventions de nommage (je vous regarde PHP)

Intégration de première classe aux environnements de développement.

De nos jours, le codage est effectué dans un environnement riche. Pour HTML / CSS / JS, nous avons Firebug et d’autres outils interactifs. Pour Java, Eclipse, IDEA et d’autres véritables IDE. Et ainsi de suite. Il existe une écologie des outils, commençant par l'éditeur mais ne se terminant pas là:

• Organisation du code dans et entre les fichiers
• Mise en évidence intelligente
• Complétion intelligente / saisie prédictive
• Débogage statique (erreurs de syntaxe, de sémantique et de style)
• Création et utilisation de modèles et de macros
• Contrôle de version (versioning, fusion, branchement, ...)
• Développement distribué avec plusieurs auteurs (commentaires, doc inline, annotations, ...)
• Débogage à l'exécution (traces de pile, pas à pas, montres, ...)
• Débogage "live" interactif (comme Firebug - comportement d'édition d'un système live)
• ... Je ne sais même pas quelle est la prochaine.

Les langues doivent être construites pour fournir un soutien à ces activités. Des progrès ont été réalisés - des annotations en Java pour aider d'autres développeurs à comprendre l'intention du code, par exemple.

Mais ce sont surtout des choses piratées, comme utiliser $ Id $ dans un commentaire pour que la source contrôlée par CVS puisse contenir un numéro de version. Pourquoi ne puis-je pas faire quelque chose comme ça à partir de la langue elle-même?

Calcul distribué

Le déjeuner gratuit est terminé. Aujourd'hui, il faut des programmes qui fonctionnent sur plusieurs cœurs / plusieurs processeurs (et sur des ordinateurs particuliers dans des circonstances spéciales).

Malheureusement, conceptuellement, écrire du code multithread étant difficile, il n’est donc pas nécessaire d’ajouter la langue comme barrière.

L’ utilisation future de C ++ 0x est certainement intéressante, car elle est présentée comme une bibliothèque et ne vous libère pas des problèmes de synchronisation (vous savez, ceux qui sont si faciles à résoudre ...)

J'aime beaucoup l' approche de Go sur le problème: le multithreading est intégré et l'approche adoptée (canaux et goroutines) définit un état d'esprit beaucoup plus simple que les approches traditionnelles sémaphore / mutex / verrouillage. Il est toujours facile d'accéder simultanément à une structure non synchronisée (Go a des pointeurs) ou à un blocage (cycle d'attente sur les canaux ...)

Je pense que les langages favorisant l'immuabilité des données, comme les langages fonctionnels, peuvent en avoir le droit (j'aime bien l'expérience là-bas).

En outre, le modèle d' acteur pourrait être notre prochaine cible. Il était également destiné à l'informatique distribuée.

Appelez-moi fou, mais l'une des fonctionnalités linguistiques les plus importantes pour moi est la disponibilité d'une bonne référence en ligne, avec des exemples. Je sais que je peux trouver de bons résultats de recherche pour toutes les langues, mais j'aime beaucoup le site des API MSDN et Java. Ils facilitent beaucoup la programmation pour une personne qui n’a pas beaucoup d’expérience dans cette langue.

Plus de capacité pour aider le compilateur à vérifier votre code.

En tant que programmeur de systèmes embarqués, j’utilise toujours le C. Mais j’aimerais toujours avoir plus / de meilleures façons de dire au compilateur ce que j’attends de mon code pour qu’il puisse le vérifier.

Par exemple, je peux avoir une fonction

f(int x)

mais je préférerais

f(int range[-5..25] x)

EG J'aimerais pouvoir écrire des assertions sur des fonctions en utilisant un langage fonctionnel de niveau supérieur comme Lisp ou Haskell. Celles-ci ne seraient pas compilées en code, mais pourraient être utilisées pour des analyses statiques ou dynamiques.

Petite syntaxe avec aussi peu de mots-clés que possible car la syntaxe détaillée est difficile à apprendre et ne facilite pas la lisibilité.

Le pire exemple est Ada:

procedure Hello is
begin
  Put_Line("Hello World!");
end Hello;

Les mots de remplissage tels que est, comme, .. n'ont pas de sens pour les langages de programmation.

J'aimerais voir plus de langues d'apprentissage . Non seulement les langues pour les débutants absolus avec des restrictions plus holistiques que le nôtre, comme celles qui requièrent un espace entre chaque jeton , mais les langues pour les personnes qui connaissent déjà la programmation et veulent apprendre de nouveaux concepts ou améliorer leur programmation en général.

Pour moi, Haskell est un excellent exemple de ce que je veux dire par "langue d'apprentissage" (bien que sa popularité et son utilité générale se soient également développées au fil des ans). En abandonnant la syntaxe C bien connue et en ayant des opérateurs de composition de fonctions en arrière (par exemple, (+2) . (*3)une fonction qui multiplie par 3, puis ajoute 2), Haskell m'a appris à écrire des fonctions plus courtes. Son vérificateur de caractères impitoyable m'a aidé à apprendre la langue plus rapidement et à améliorer ma capacité à penser logiquement au code. Ces deux avantages se sont étendus à d'autres langues, même à l'assemblage.

L’apprentissage des langues et les objectifs généraux sont souvent contradictoires. Une langue d'apprentissage doit être difficile et enrichissante, et doit imposer un style particulier, même si ce style n'est pas le meilleur pour de nombreuses applications. Un langage généraliste devrait être utile pour faire avancer les choses, et l'utilisation d'abstractions doit être soigneusement mesurée et "avoir un sens". Par exemple, lors de la réparation d’un site Web, l’apprentissage des monades serait la dernière chose à laquelle pense le programmeur. De l'autre côté de la médaille, quand quelqu'un apprend à programmer, il ne devrait pas être obligé de se perdre dans un non-sens "vide public statique" s'il n'a même pas encore entendu parler des fonctions.

Si vous êtes un concepteur de langue, déterminez si votre langue est une langue d’apprentissage ou une langue appliquée. Cela déterminera dans quelle mesure vous voulez utiliser la pureté dans votre conception.

Depuis que nous sommes en 2011,

• une spécification absolument complète. pas de trous dépendants de l'architecture comme en C

• support multithreading; non seulement les fonctionnalités de synchronisation (verrous), mais également les fonctionnalités de langage qui rendent le multithreading aussi simple que d'écrire une boucle:

  all (o dans myCollection) {o.someMethod ()}

• multi-paradigme; Permettez-moi, le programmeur, de décider si je veux la sécurité d'un langage statique lors de la compilation ou la concision d'un langage dynamique, au cas par cas; donnez-moi des fonctionnalités orientées objet, des fonctionnalités, etc.

• cohérence (je sais que cela demande un peu trop de cohérence et de paradigme multiple ...)

Procédés légers

Je voudrais avoir des processus légers comme à Erlang. C'est principalement un problème pour le runtime. Cela manque dans JVM et .NET CLR. LWP aide à la création de logiciels massivement concurrents. Idéalement, il ne devrait pas être plus coûteux de créer un processus car il s'agit de créer un objet dans un langage. Je souhaite créer des millions de processus dans mes applications.

Il est implémenté comme un pool de threads avec une planification préalable, de sorte qu'une seule tâche ne bloque pas l'autre tâche, et les tâches peuvent être planifiées sur n'importe quel cpu-core disponible.

Prise en charge de la récursion de la queue

Je voudrais avoir un support pour la récursion de la queue. Cela peut également être un problème pour l'environnement d'exécution. Par exemple, JVM ne prend pas en charge la récursion de la queue.

Programmation distribuée facile

Je voudrais avoir un support pour send ( ! ) Et recevoir des primitives à des parties de l'application s'exécutant sur d'autres machines sur le même réseau que dans Erlang. Cela facilite la création d'applications évolutives, par exemple des banques de données distribuées. Ajouté à cette sérialisation intégrée dans le langage est également très utile comme en erlang. Et pas comme en Java même je dois le faire manuellement.

Faciliter la métaprogrammation.

limiter les formulaires spéciaux

En Python, il n'y a pas de bonne raison pour laquelle imprimer ce n'est pas une fonction intégrée. Il ressemble et agit comme une fonction, sauf que vous ne voulez rien avoir à faire avec les parens.

Avons-nous vraiment besoin for, foreach, whileet comme chacun leur propre forme spéciale. Que diriez-vous d’une construction en boucle et de quelques macros par défaut pour fournir le sucre syntaxique des formes en boucle variantes?

méta-programmation pour formes spéciales

form['if'](test-fn, body-fn)

Capacités du réseau

Une langue livrée sans support réseau est assez boiteuse dans le monde d'aujourd'hui.

La plupart des applications du monde réel doivent communiquer sur un réseau quelconque:

• mise à jour automatique
• accès à la base de données
• services Web

C'est également une pierre angulaire de la prise en charge de l'informatique distribuée / en nuage.

J'aime un langage de programmation facile à apprendre et à combiner pour créer de nouvelles choses.

Par exemple, bien qu’il soit intéressant d’avoir beaucoup de façons d’écrire quelque chose, je pense qu’il est préférable d’avoir seulement une ou deux façons de l’écrire. De cette façon, le programme est plus facile à maintenir.

Un langage dont les concepts peuvent s'appliquer à tous les éléments est très utile (je pense que cela s'appelle orthogonalité). Ainsi, la prochaine fois que vous rencontrerez une nouvelle fonctionnalité de langage, vous pourrez en déduire comment l'utiliser.

Je comprends parfois que la syntaxe de la langue doit entraver la performance lors de la phase de compilation / interprétation, mais parfois, je pense que le concepteur de la langue confie ce travail au développeur. Par exemple, des chaînes multilignes en Java ou en Javascript.

Enfin, la syntaxe du langage correspond à son interface utilisateur. Elle doit donc être claire, concise, intuitive, facile à utiliser et respecter vos habitudes.

• Lisibilité : Le moins / le plus petit des symboles utilisés dans la grammaire, le plus propre et le meilleur.
• Types orientés objet : Méthodes, pas fonctions.
• Compréhensibilité : Interfaces fluides intégrées, noms complet et abrégé pour les classes / interfaces de bibliothèque et les tris.

Ajouter une fonctionnalité à un langage de programmation existant. Ainsi, le nouveau langage B est l'ancien langage A, plus doté de X.

Exemples existants:

1. C ajout de classes => C ++
2. Java ajoutant des trucs => C #

Quand il s’agit de technologie / plate-forme / langage / base de données, etc., la plupart du temps, c’est la performance. À l'avenir, de nombreux logiciels actuels pourront être conçus à l'aide d'un langage graphique, car nous disposons de plus de capacités de calcul.

J'espère que le jour où nous disposerons d'une puissance de calcul et d'un langage dans lesquels vous concevez votre application, sans avoir à vous soucier des détails de langage .

Mise à jour: j'envoie un lien vers un tel langage LabView

Mise à jour: Je devrais expliquer davantage ce que je veux dire par «puissant calculateur». Les performances des logiciels compilés peuvent ne pas être aussi puissantes que celles des logiciels compilés basés sur un langage de syntaxe. Je pense à la programmation graphique en tant que niveau de programmation supérieur et il peut y avoir plus de temps système. Les ordinateurs actuels peuvent et exécutent facilement des langages de programmation graphiques.