Que souhaitiez-vous que les concepteurs de langues ont porté une attention particulière?
Le but de cette question est de ne pas assembler une liste de blanchisserie de caractéristiques linguistiques de programmation que vous ne pouvez pas vivre sans que vous soyez dans votre langue principale de choix. Le but de cette question est de porter aux coins légers de la conception de la langue La plupart des concepteurs de langue pourrait ne pas penser. Ainsi, au lieu de penser à la fonction de langue x, pensez un peu plus philistophiquement.
L'un de mes préjugés, et peut-être que cela pourrait être controversé, est que le côté plus doux de l'ingénierie - les WHYS et sur quoi FORS - sont plusieurs fois plus importants que le côté le plus concret. Par exemple, Ruby== a été conçu avec un objectif déclaré d'améliorer le bonheur du développeur. Bien que vos opinions soient mixtes sur le fait que cela soit livré ou non, le fait que c'était un objectif signifie que certains des choix sont fournis. La conception de la langue a été influencée par cette philosophie.
S'il vous plaît ne postez pas :
- Syntaxe Flamme Wars. Voyons en face, nous avons nos préférences et la syntaxe est importante car elle concerne la conception linguistique. Je veux juste éviter les batailles épiques de la nature des Emacs contre VI (quel grand nombre de personnes ces jours-ci ne savent rien).
- "Toute langue qui ne dispose pas de la fonctionnalité X ne mérite pas d'exister" Tapez des commentaires. Il y a au moins une raison pour que toutes les langues de programmation existent - bonne ou mauvaise.
s'il vous plaît do post :
- Idées philisophiques que les concepteurs de langues semblent manquer.
- Concepts techniques qui semblent être mal mis en œuvre plus souvent que non. Veuillez fournir un exemple de douleur qu'elle cause et si vous avez des idées de la manière dont vous préféreriez cela fonctionner.
- Les choses que vous souhaitez étaient dans la bibliothèque commune de la plate-forme mais sont rarement. Un même jeton, des choses qui sont généralement dans une bibliothèque commune que vous le souhaitez n'étant pas.
- Caractéristiques conceptuelles telles que intégrées de test/assertion/contrat/erreur de traitement de la gestion des erreurs que vous souhaitez que toutes les langues de programmation implémentent correctement - et définir correctement.
J'espère que ce sera un sujet amusant et stimulant.
Edit : a clarifié ce que je veux dire par Syntax Flame Wars. Je n'essaie pas d'éviter toute discussion sur la syntaxe, en particulier parce que la syntaxe constitue une partie fondamentale de la conception de la langue du programme.
Support Unicode par défaut
Ce jour et cet âge, des programmes sont en cours de développement pour être utilisés à l'échelle internationale, ou sous l'hypothèse qu'ils pourraient être utilisés à l'échelle internationale. Ils doivent fournir un soutien à leurs ensembles de caractères ou à des programmes de rendu écrits dans cette langue inutile.
J'ai un couple:
Génériques/modèles. Par exemple, Java Generics sont puissants, mais pas nécessairement flexibles. En outre, parce qu'ils utilisent l'effacement de type, j'ai vu des problèmes de les mettre de manière abstraite, en particulier dans les interfaces. Et le compilateur ne doit pas avertir quand Un générique non spécifique est utilisé (comme
Hashmapau lieu deHashmap<String, int>). Je pense qu'ils pourraient être considérablement améliorés. Une bonne modélisation est très utile, mais souvent négligée.Bon support de date dans la bibliothèque standard. Je veux dire pouvoir ajouter et soustraire des dates, des heures et des minutes et de ne pas avoir à gérer le nombre de millisecondes depuis le 1er janvier 1970.
Veuillez faire votre langue analysable/auditable pour les personnes de sécurité informatique.
Les personnes de sécurité doivent être en mesure de trouver des vulnérabilités dans un programme avant qu'il ne soit expédié. Idéalement, nous sommes appelés tôt et pouvons commenter le codeBase telle qu'elle se développe, mais souvent non.
Lorsqu'une nouvelle version de la langue ou des bibliothèques principales sort, des choses qui étaient auparavant sans danger peuvent ne plus être:
- les bibliothèques peuvent devenir plus puissantes: par exemple. La bibliothèque d'URL soutient désormais
javascript: - il peut y avoir de nouvelles façons de convertir des chaînes ou des octets en code: par ex.
evalou bibliothèques de désérialisation - les techniques de réflexion sur la langue peuvent devenir plus puissantes: par exemple. Exposer les variables locales
L'un de ces changements peut augmenter le montant de l'autorité abusable d'un programme, mais depuis le montant de l'autorité que le programme utilise (lorsqu'il s'agisse de clients non malveillants) n'a pas changé, les folks de la sécurité sont difficiles à comprendre pour comprendre que SANS SORS réindive.
Alors, pensez-y à propos de nous lors de la conception et de la version de la langue. Vous trouverez ci-dessous quelques conseils:
Définissez quelques primitives qu'un programme peut être décomposé.
HTML5 est particulièrement mauvais de cette façon. Ils ont évidemment mis beaucoup de pensée dans la sécurité et ont des personnes très intelligentes, mais au lieu de spécifier de nouveaux éléments de programme tels que <video> en termes d'anciens ou de création d'une abstraction commune qui nouveau <video> et vieux <img> Les deux peuvent être spécifiés en termes de, <video> est un autre élément de programme unique avec ses propres conséquences de sécurité.
Faites votre langue préparée à une analyse statique (même si elle n'est pas statiquement dactylographiée).
Sécurité Folk utilise souvent une analyse statique pour trouver des modèles et pour essayer d'exclure des parties d'un programme afin de pouvoir se concentrer sur les bits vraiment difficiles.
Il devrait être évident que les identificateurs sont des variables locales et qui ne sont pas.
E.G., ne faites pas la même erreur que les anciennes versions de JavaScript, ce qui rendait impossible à dire si x est une référence de variable locale dans ci-dessous (selon 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.
})();
}
Permettre une sécurité décomposable
Beaucoup 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é, de sorte que la sécurité folklorique puisse concentrer leurs efforts sur l'analyse d'une petite quantité de code et libérer la plupart des programmeurs de devoir faire face à {gênant, pédagueur de sécurité, paranoïde} .
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 jamais récupéré, les écrivains du noyau peuvent-ils faire quelque chose pour canaliser toute l'URL récupérer à travers leur code? Ou les contrôles de construction statiques peuvent-ils servir la même fonction (comme regarder les importations).
Certaines langues comme Newspeak utilisent un modèle de capacité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, faire le graphique du module un artefact analysable statiquement peut vous procurer un peu de prestations. Si je peux prouver qu'un module ne peut pas atteindre le module d'E/S de fichier (sauf en appelant le code dans un module dans la TCB), je peux exclure des classes entières de problèmes de ce module.
Limiter l'autorité des langages de script intégrés
Beaucoup de systèmes utiles sont organisés en tant que noyau statique qui élimine beaucoup de code écrit dans des langues dynamiques (même fonctionnelles).
Et l'intégration des langues de script peut rendre un système beaucoup plus extensible.
Mais un langage de script ne devrait pas avoir l'autorité complète du VM.
Si vous choisissez d'autoriser des langages de script intégrés, facilitez l'invocateur de limiter ce qu'ils peuvent faire. Un modèle de capacités d'objet (voir le commentaire sur les journaux ci-dessus) est très approprié ici; Ainsi, lors de l'évaluation du code dans une langue de script, l'appelant doit passer dans le code pour exécuter et tout les variables globales pour ce code.
Traiter eval comme une langue s'oridant comme une langue de script
Si votre langue peut appeler son propre compilateur pour transformer une chaîne en code, laissez-la être de la même manière que vous le feriez de la langue de script intégrée.
Utilisez un modèle de concurrence simple
Nous n'aimons pas à vous soucier des conditions de course lorsque nous essayons de déterminer si une propriété de sécurité est maintenue.
Veuillez envisager des alternatives au threading avant de vous installer sur des threads comme une option par défaut presque impossible à sécuriser.
Un simple est la concurrence de la boucle d'événement comme celle trouvée dans E, Verilog et JavaScript.
N'encourage pas cibler la confusion
Certaines langues sont des langues de colle, et ils finissent par faire face à des chaînes dans de nombreuses langues différentes.
Par exemple, Javascript compose souvent des chaînes de HTML, CSS, XML, JSON et même JavaScript. Il est très difficile pour les programmeurs de se rappeler de coder correctement des chaînes de texte brut lorsque vous les combinez pour créer des chaînes dans d'autres langues, donc les programmes JS, sans surprise, ont toutes sortes de problèmes de confusion: XSS étant le pire.
Si vous souhaitez inclure Fonctions de composition de chaîne Essayez de réduire le fardeau de sécurité du programmeur. Les DSL, les macros hygiéniques et les langues de modèles embarqués peuvent être un excellent moyen de le faire en déplaçant le fardeau pour s'échapper correctement sur la bibliothèque ou les développeurs de langue et à l'éloignement du développeur final.
Certaines des meilleures langues ont été conçues par des personnes qui souhaitaient faire une langue pour eux-mêmes.
Je pense donc que les concepteurs de langue devraient accorder moins d'attention à leurs utilisateurs. Vous ne pouvez pas plaire à tout le monde, non plus, vous n'essayez pas de.
Seulement 5-10% du temps est passé en rédaction du code. Les concepteurs de langue doivent faire attention aux difficultés de travail de logiciels, ce qui signifie de résoudre des erreurs et des bugs.
Cela signifie qu'il devrait y avoir du get aller un bon débogueur. Pas un outil avec la syntaxe arcanique et les commandes de clé qui ne sont que légèrement meilleures que des tonnes de déclarations d'impression.
La capacité de modifier la langue en fonction de vos besoins est un grand pour moi. Pour Lisp qui est fait avec des macros, pour TCl avec Upvel. Dans une moindre mesure, Ruby utilise Lambdas et similaire. Je veux juste la possibilité d'ajouter de nouvelles structures de contrôle qui conviennent au problème plutôt que de moulant mes problèmes autour des structures de contrôle disponibles. Comme un exemple simple. , la construction "jusqu'à" jusqu'à ce qui existe dans certaines langues, mais pas d'autres est un moyen plus propre de gérer certains cas que "tout en", pouvant ajouter de nouvelles structures pour répondre à d'autres cas est extrêmement utile.
Dans le sens le plus général, il s'agit de métaprogramming ... mais je l'utilise surtout 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 de systèmes basé sur un pointeur. J'appellerais Erlang un langage de programmation fonctionnel hautement simultané. Quelques autres langues (comme C++ et sans doute Java) sont ce que Allan Kay a appelé "agglutinonnant" langues: Frankenstein Langues consistait en un groupe de fonctions cloutées ensemble.
Le prochain plus important est que les changements apportés à la langue elle-même devraient être un dernier recours. Même le sondage le plus bénin peut devenir complexe lorsqu'il est combiné avec les autres caractéristiques de la langue. Je dirais que pour mettre une nouvelle fonctionnalité dans une langue, vous devez:
- Prouver que c'est vraiment nécessaire.
- Prouvez que cela ne peut pas être fait dans une bibliothèque.
- Prouver qu'il appartient à la langue.
Merci pour une grande question. Vous obtenez de très bonnes réponses.
Ne pas glaçonner vos yeux, mais je regarde un programmeur en tant que canal d'information. Idées/Concepts/Exigences Allez à une extrémité et le code sort l'autre.
Si vous prenez un ensemble d'exigences (quelle que soit la manière dont elles sont indiquées) et l'ensemble de code sur un énorme tableau blanc et que des lignes de tirage en mappent chaque exigence au code qui le met en œuvre, la complexité de ce graphique dépendrait de la manière du code du code. exprime les exigences. Idéalement, il devrait être assez direct et un à un, mais c'est difficile à mettre en pratique.
Je mesure la spécificité du domaine d'une langue dans la mesure où elle simplifie ce graphique. C'est une propriété extrêmement souhaitable et elle peut être approchée de n'importe quel type de façons, de simplement définir les bonnes classes/routines (noms/verbes), aux macros, à écrire votre propre analyseur et votre propre interpréteur/compilateur.
Permettez-moi de 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 Élimine avoir à écrire des manuels d'événements, de déménagement de données, la plupart de la matière typiquement faite à l'UIS. Il entraîne également une réduction du code source d'un ordre de grandeur. La méta-langueur n'est vraiment que quelques routines et macros en C/C++/Lisp, et je l'ai également fait dans des langues sans macros.
Si la mise en œuvre d'une exigence peut être effectuée avec des modifications de 5 points au code ou avec 10, le faire avec 5 est non seulement moins de code, mais moins de chances de manquer une étape et de mettre dans un bogue. Donc, plus la langue est spécifique à un domaine, plus le code est le code plus petit, plus maintenu et plus de bugs. Je pense que nous devons savoir comment conduire à cela. Il ne signifie pas non signifie que le code est plus lisible, sauf le lecteur a investi dans la courbe d'apprentissage pour comprendre la technique.
Des types d'entiers délimités et distincts comme à Pascal et Ada. Honnêtement: À quelle fréquence avez-vous besoin de la gamme complète de tout entier? Je pense qu'il y a beaucoup à être amélioré dans des types primitifs pour mieux représenter le monde réel.
Il existe des fonctionnalités qui facilitent les langues de programmation une fois que vous les avez apprises et que vous les rendez faciles à apprendre à utiliser. Étant donné que les utilisateurs d'une langue ont une relation à long terme avec elle, optimiser la facilité d'utilisation est meilleure que l'optimisation de la facilité d'apprentissage. Ne rendez pas les choses plus difficiles que nécessaire, mais ne sacrifiez pas l'expressivité (pouvoir écrire un peu de code qui fait beaucoup) pour la destinaçabilité à ceux qui ne connaissent pas la langue. D'autre part, la langue ne devrait pas lire comme un bruit de la ligne aux personnes qui ont travaillé avec elle 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 avec les environnements de développement.
De nos jours, le codage est fait dans un environnement riche. Pour HTML/CSS/JS, nous avons Firebug et d'autres outils interactifs. Pour Java, Eclipse et IDEA et d'autres idées true. Et ainsi de suite. Il y a une écologie des outils, en commençant par l'éditeur mais qui ne se termine pas là:
- Organisation du code dans et entre les fichiers
- Smart soulignant
- Achèvement intelligent/typing prédictif
- Débogage statique (syntaxe de signalisation de signalisation, erreurs sémantiques et stylistiques)
- Création et utilisation de modèles et de macros
- Contrôle de la version (version, fusions, branchement, ...)
- Développement distribué avec plusieurs auteurs (commentaires, Doc en ligne, annotations, ...)
- Débogage du temps d'exécution (traces de pile, étage, montres, ...)
- Débogage interactif "en direct" (comme Firebug - Modification du comportement d'un système en direct)
- ... Je ne sais même pas ce qui est ensuite.
Les langues doivent être construites pour fournir un soutien à ces activités. Certains progrès ont été effectués - Annotations In Java pour aider les autres développeurs à comprendre l'intention du code, par exemple.
Mais surtout, il est piraté de choses, comme en utilisant $ id $ dans un commentaire afin que la source contrôlée par les CVS puisse contenir un numéro de version. Pourquoi ne puis-je pas faire quelque chose comme ça de la langue elle-même?
Appelez-moi fou, mais l'une des caractéristiques de langue les plus importantes pour moi est la disponibilité d'une bonne référence en ligne, ainsi que des exemples. Je sais que je peux trouver de bons résultats de recherche pour n'importe quelle langue, mais j'aime beaucoup le MSDN et Java site APIS. Ils font de la programmation beaucoup plus facile pour une personne qui n'a pas beaucoup d'expérience dans le domaine spécifique Langue.
calcul distribué
Le déjeuner gratuit est terminé. Aujourd'hui, il faut des programmes qui fonctionnent sur plusieurs cœurs/processeurs multiples (et sur des circonstances spéciales multiples ordinateurs).
Malheureusement, écrire du code multi-threadé est dure conceptuellement, il n'est donc pas nécessaire d'ajouter la langue sous forme de barrière.
C++ 0x utilisation de -futur est certainement intéressant, pour tout ce qu'il est apporté en tant que bibliothèque et ne vous libère pas des problèmes de synchronisation réels (vous savez, ceux qui sont juste si facile à résoudre ...)
J'aime beaucoup Go Approche du problème: La multithreading est intégrée et l'approche prise (canaux et gorouts) définit un état d'esprit beaucoup plus facile que les approches traditionnelles Semaphore/Mutex/Lock. Il est toujours facile d'accéder simultanément à une structure non synchronisée (Go a des pointeurs) ou de l'impasse (cycle d'attente sur les canaux ...)
Je pense que les langues favorisant l'immuabilité des données, telles que les langues fonctionnelles, peuvent en avoir le droit (j'aime bien l'expérience là-bas).
De plus, le modèle acteur peut être notre prochaine cible. Il était censé aussi avoir distribué l'informatique.
Plus de possibilité d'aider le compilateur à vérifier votre code.
Être un programmeur de systèmes intégré, j'utilise toujours C. mais je souhaite toujours avoir plus de moyens de dire au compilateur ce que j'attends de mon code afin 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)
PAR EXEMPLE. J'aimerais pouvoir écrire des assertions sur les fonctions en utilisant une sorte de langage fonctionnel de niveau supérieur comme Lisp ou Haskell. Celles-ci ne seraient pas compilées dans le code, mais pourraient être utilisées pour une analyse statique ou dynamique.
Petite syntaxe avec aussi peu de mots clés que possible car la syntaxe verbose est difficile à apprendre et n'entraîne pas la lisibilité.
Le pire exemple est ADA:
procedure Hello is
begin
Put_Line("Hello World!");
end Hello;
Des mots de remplissage comme sont, comme, .. N'ayez pas de sens pour les langages de programmation.
Depuis que nous sommes en 2011,
- une spécification absolument complète. Aucune archittitecture - Dépend de trous comme dans C
soutien multithreading; non seulement fonctionnalités de synchronisation (verrous), mais les caractéristiques de la langue qui rendent la multithreading aussi simple que d'écrire une boucle:
tout (o en mycollection) {O.Somemethod ()}
multi-paradigme; Laissez-moi, le programmeur, décidez si je veux la sécurité du temps de compilation d'une langue statique ou de la détérioration d'une langue dynamique, sur une base de cas par cas; Donnez-moi des fonctions orientées objet, des fonctionnalités fonctionnelles, etc.
cohérence (je sais que cela demande un peu beaucoup pour la cohérence et la multi-paradigme ...)
Je voudrais voir plus Langues d'apprentissage . Non seulement des langues pour les débutants absolus avec des restrictions de plus que : nécessitant un espace entre chaque jeton , mais des langues pour les personnes qui connaissent déjà la programmation et souhaitent apprendre de nouveaux concepts ou s'améliorer à la programmation en général.
Pour moi, Haskell est un excellent exemple de ce que je veux dire par un "langage d'apprentissage" (bien qu'il soit également cultivé en popularité et à l'utilité générale au fil des ans). En abandonnant la syntaxe C familière et ayant des opérateurs de composition de fonction à l'envers (par exemple, (+2) . (*3) Est une fonction qui se multiplie par 3, alors Ajoute 2), Haskell m'a appris à écrire des fonctions plus courtes. Son checker de type impitoyable m'a aidé à apprendre la langue plus rapidement et à améliorer ma capacité de réfléchir logiquement à propos du code. Ces deux avantages ont été renversés dans d'autres langues, même l'assemblage.
Les objectifs d'apprentissage des langues et de celles des langues générales sont souvent en conflit. Une langue d'apprentissage devrait être difficile et récompensante d'apprendre et devrait appliquer un style particulier, même si ce style n'est pas le meilleur pour de nombreuses applications. Une langue générale devrait être bonne pour obtenir des trucs accomplis et l'utilisation d'abstractions doit être soigneusement mesurée et "avoir du sens". Par exemple, lors de la correction d'un site Web, l'apprentissage de Monads serait la dernière chose à laquelle l'esprit d'un programmeur. De l'autre côté de la pièce, quand quelqu'un apprenne à programmer, ils ne devraient pas avoir à se balader par des non-sens "annulaires publiques statiques" s'ils n'ont même pas encore appris les fonctions.
Si vous êtes un concepteur de langue, veuillez vous décider si votre langue est une langue d'apprentissage ou une langue appliquée. Cela déterminera dans quelle mesure vous voudrez utiliser la pureté dans votre conception.
Faciliter la métaprogrammation.
limiter les formulaires spéciaux
In Python Il n'y a pas de bonne raison pour laquelle l'impression n'est pas une fonction intégrée. Il a l'air et agit comme une fonction, à l'exception de ne pas vouloir rien faire avec des parens.
Avons-nous vraiment besoin for, foreach, while et similaire à leur propre forme spéciale. Que diriez-vous d'une construction de bouclage et de certaines macros par défaut pour fournir le sucre syntaxique des formes de bouclage variantes.
méta-programmation pour formes spéciales
form['if'](test-fn, body-fn)
Processus légers
J'aimerais avoir des processus légers comme dans Erlang. C'est principalement un problème pour le temps d'exécution. Ceci manque dans JVM et .NET CLR. LWP aide à créer des logiciels massivement concurrents. Idéalement, il ne devrait pas y avoir plus cher pour créer un processus tel qu'il est de créer un objet dans une langue. Je voudrais créer des millions de processus dans mes applications.
Il est implémenté comme piscine thread-piscine avec planification présidtive, de sorte qu'une tâche unique ne bloque pas l'autre tâche et que les tâches peuvent être planifiées sur n'importe quel CPU-Core disponible.
Support pour la récursion de la queue
J'aimerais avoir un soutien pour la récursion de la queue. Cela peut également être un problème pour l'environnement d'exécution. Par exemple. JVM n'a pas de soutien pour la récursion de la queue.
Programmation facile distribuée
J'aimerais avoir une prise en charge pour envoyer (-!) et recevoir primitives à des parties de l'application exécutant sur d'autres machines sur le même mot de mot que dans Erlang. Cela facilite la création d'applications évolutives. Distributions de données distribuées. Ajouté à cette sérialisation intégrée dans la langue est également très utile comme dans Erlang. Et non comme dans Java très, je dois le faire manuellement.
capacités de résea
Une langue qui expédie sans assistance réseau est plutôt boiteuse dans le monde d'aujourd'hui.
La plupart des applications du monde réel doivent communiquer sur une sorte de réseau:
- mise à jour automatique
- accès à la base de données
- services Web
C'est aussi une pierre angulaire du support informatique distribué/nuageux bien sûr.
J'aime un langage de programmation facile à apprendre et facile à combiner pour créer de nouvelles choses.
Par exemple, tout en étant attrayant d'avoir beaucoup de façons d'écrire quelque chose, je pense qu'il vaut mieux avoir une ou deux façons de l'écrire. De cette façon, le programme est plus facile à maintenir.
Une langue dont les concepts peuvent s'appliquer à tous les éléments sont très utiles (je pense que cela s'appelle l'orthogonalité) Donc, la prochaine fois que vous faites face à une nouvelle fonctionnalité de langue, vous pouvez déduire comment l'utiliser.
Je comprends parfois que la syntaxe de langue doit se mettre en œuvre de mieux dans la phase de compilation/d'interprétation, mais parfois, je pense que le concepteur de langue en apercevoir ce travail au développeur. Par exemple, des chaînes multilignes dans Java ou JavaScript.
Enfin, la syntaxe de langue est son interface utilisateur et, en tant que telle, elle doit être claire, concise, intuitive, facile à utiliser et devrait respecter vos habitudes.
- lisibilité: moins les symboles utilisés dans la grammaire, le nettoyant et le mieux.
- types orientés objet: méthodes, pas fonctions.
- compréhension: interfaces fluides intégrées, noms complets et abrégés pour les classes/interfaces de bibliothèque et les sorties.
En ce qui concerne la technologie/la plate-forme/la langue/la base de données, etc. La plupart des temps, cela revient à la performance. À l'avenir, de nombreux logiciels d'aujourd'hui peuvent être conçus à l'aide d'une langue graphique puisque nous avons plus de puissance de calcul.
J'espère le jour où nous avons une puissance de calcul et une langue où vous Conception Votre application et vous se soucier des détails de la langue .
Mise à jour: J'envoie un lien à une telle langue LabVIEW
Mise à jour: Je devrais expliquer plus ce que je veux dire par "puissant calculal". La performance du logiciel compilé peut ne pas être aussi puissante que le logiciel compilé basé sur la langue de syntaxe. Je pense à une programmation graphique comme un niveau de programmation plus élevé et il peut y avoir plus de frais généraux. Les ordinateurs d'aujourd'hui peuvent et effectuent facilement des langages de programmation graphique.