Pourquoi n'est-ce pas Java utilisé comme langue de construction?
Si Java est une langue générale et la construction d'un programme est quelque chose qui peut être décrit à l'aide de Java Langue, pourquoi n'est-ce pas le meilleur moyen de Écrivez des fichiers de construction et nous utilisons des outils comme ANT, Maven et OriTle? Ne seriez-vous pas plus simple, et supprimez également la nécessité d'apprendre un autre langage de programmation? (BTW - Cette question peut également être appliquée à d'autres langues, comme C #)
Outil spécifique pour un objectif spécifique
verbosité
Les langues générales sont souvent trop verbeuses. Si je devais gérer une construction en Java, je serais très déprimé très rapidement par la taille de la bête. Cependant, cela pourrait facilement être gérable à l'aide d'un DSL écrit en Java. Et dans une certaine mesure, c'est comme ça que vous pouvez voir la gradle (pour Groovy) et Buildr (pour Ruby).
difficulté
Les langues générales sont difficiles. Eh bien, je ne pense pas que la programmation est difficile et ne peut être prise en charge par personne, mais le but est: votre ingénieur de construction n'est pas nécessairement votre programmeur!
but
C'est plus ou moins à l'intersection de difficulté et verbosité. Une langue est conçue dans un but et nous parlons de quelque chose de très spécifique. Alors, pourquoi auriez-vous besoin ou souhaitez-vous utiliser un général Langue des objectifs? Pour les constructions, vous avez besoin:
- branches et conditionnels Pour gérer des configurations séparées, des environnements, etc.
- un ensemble d'instructions pour extraire des données de votre environnement,
- un ensemble d'instructions pour produire des produits livrables.
Vous n'avez pas vraiment besoin de beaucoup plus.
Bien sûr, il est ennuyeux lorsque votre système de construction semble être suffisamment flexible pour qu'un cas d'utilisation spécial vous après, mais c'est probablement bien meilleur que l'alternative pour la plupart des gens.
C'est probablement pourquoi il y a une polarité entre les personnes qui préfèrent les systèmes de construction déclaratifs sur la plupart des onces programmables: je suppose qu'un développeur pourrait avoir une tendance naturelle à rechercher des moyens de sortir de la boîte.
Attendez, avons-nous vraiment besoin d'un outil?
Une autre question connexe serait la suivante: avons-nous vraiment besoin d'un outil de construction? N'est-ce pas le fait qu'ils existent dans toutes les langues le signe qu'ils remplissent un écart qui ne devrait même pas être là en premier lieu?
Certaines langues ne nécessitent pas nécessairement un outil de construction. Par exemple, la plupart des langages de script n'ont pas besoin d'un et de résolution au moment de la charge. Ou prenez-vous, dont le compilateur gérera tout pour vous, ce qui est un joli contrepoint: que se passe-t-il si un compilateur comme GCC n'avait soudainement pas besoin d'une bouquet de drapeaux, d'un lien de liaison et d'un maquillage pour tout mourir ensemble? Ou si Javac n'avait pas besoin d'une build.xml ou de pom.xml pour lui dire quoi faire? La gestion de la dépendance ne devrait-elle pas faire partie de l'outillage de la langue, car les dépendances font partie du programme final?
Il semble sûrement une approche beaucoup plus simple pour l'utilisateur (le constructeur). Bien que l'on puisse discuter, ils font simplement sous le capot et enlevez votre choix et votre choix d'influencer ce processus de construction (mais vous espérez alors qu'un tel outil permet aux extensions du compilateur et à des choses similaires). De plus, nous avions l'habitude de voir les outils et la langue comme deux choses distinctes, il peut donc sembler peu sûr de les avoir soudainement si étroitement couplés.
Je ne pense pas que la langue que vous utilisez pour construire vos programmes est la question. C'est la langue que vous utilisez pour programmer et sa plate-forme centrale et son outillage qui devrait importer, et nous faisons toujours la phaasse à ce sujet.
Personnellement, j'ai utilisé faire/gmake/gmake/autotools/pmk et je suis heureux avec eux pour C, et j'ai commencé avec Java quand tout ce que nous avions était fait, puis la fourmi, et maintenant je suis Généralement préférant maven sur toutes ces alternatives. Bien que je puisse voir la valeur dans les grades, la construction et d'autres, mais j'aime la prévalence de Maven jusqu'à présent, jusqu'à ce qu'un changement plus important se produise. Plus I comme c'est rigide , mais vous laisse toujours la capacité de contourner cela si nécessaire. Que ce n'est pas facile est une bonne chose.
C'est un outil de construction. Apprenez simplement à l'embrasser et ne le combattez pas. C'est une bataille perdue. Ou au moins un très très long.
Java est un impératif Langue, Ant, Maven, etc. sont déclaratif Langues:
Nous pourrions définir la différence comme suit:
- Programmation impérative: raconter la "machine" comment Pour faire quelque chose, ce que vous voulez arriver, cela se produira.
- Programmation déclarative: raconter la "machine" quoi Vous voudriez arriver, et laissez l'ordinateur de déterminer comment le faire.1
Construire des langages indiquez au constructeur quoi devrait être fait, de Où Il doit être pris, etc. Le moteur qui exécute La construction (qui est écrite dans une langue impérative, comme @elliottfrisch a noté), lit ces instructions et les remplit.
Les langues déclaratives peuvent sembler plus appropriées dans les scénarios de construction, car les tâches de construction sont généralement identiques partout et sont considérées comme plus maintenues et lisibles sous la forme de formulaire de code à part entière.
Si vous regardez les caractéristiques d'un système de construction typique que vous trouvez:
- Beaucoup de données: noms, commutateurs, paramètres, éléments de configuration, chaînes, etc.
- Beaucoup d'interaction avec l'environnement: commandes, variables d'environnement
- Un "moteur de construction" relativement simple, des dépendances, une filetage, une journalisation, etc.
Si vous avez décidé d'écrire une série de fichiers de construction en utilisant une langue (Java/C #/Python/etc.), sur la troisième ou la quatrième itération, vous vous installeriez sur (a) conservant la plupart des données et des commandes externes comme des données dans quelque chose Comme XML (B) écrivant le "moteur de construction" dans votre langue préférée.
Vous trouverez également utile de traiter certaines des données de votre XML comme langue interprétée pour déclencher diverses fonctionnalités du moteur de construction. Vous pouvez également interpréter certaines macros ou effectuer des substitutions de chaîne, dans les données.
En d'autres termes, vous finiriez de faire, ou une fourmi, ou un râteau ou msbuild. Une langue impérative pour les choses qu'il fait bien et des structures de données pour décrire ce que vous voulez faire, maintenant généralement dans XML.
Un certain nombre de facteurs comptent contre l'utilisation de Java/C++/C # dans ces cas.
Premièrement, vous devez compiler votre script de construction avant de pouvoir l'exécuter pour construire votre application. Comment spécifieriez-vous des packages, des drapeaux, des versions de compilateur, des chemins d'outils nécessaires pour créer votre script de construction? Certainement, vous pourriez avoir un moyen de contourner, mais il est beaucoup plus simple d'avoir soit une langue qui n'a pas besoin de cette étape de construction (par exemple python) ou d'une langue que votre outil de construction comprend nativement.
Deuxièmement, les fichiers de construction sont lourds de données, tandis que Java/C++/C # sont beaucoup plus orientés vers un code d'écriture et des algorithmes. Java et amis n'ont pas une représentation très succincte de toutes les données que vous voudriez stocker.
Troisièmement, Java et amis Besoin besoin de beaucoup de chaudière pour être valide. Le fichier de construction devrait être à l'intérieur d'une méthode dans une classe avec toutes ses importations. Lors de l'utilisation d'une langue de script ou d'une langue personnalisée. Vous pouvez éviter tout ce chaudière et avoir les détails de construction eux-mêmes.
En effet! Pourquoi ne pas utiliser un puissant et expressif langue pour un problème qui est plus complexe que les gens souvent (initialement) pensent? Surtout quand les personnes confrontées au problème sont déjà compétentes avec une telle langue. (Le bâtiment est le problème propre des programmeurs et le mieux résolu par les programmeurs.)
Je me suis également demandé cette question il y a des années et j'ai décidé que Java est une bonne langue pour la définition des constructions, en particulier pour Java projets. Et, par conséquent, je a commencé à faire quelque chose à ce sujet.
[~ # ~] Disclaimer [~ # ~ ~] : Dans cette réponse, je promouve iwant , un système de construction que je suis développement. Mais comme ceci est une discussion d'opinion de toute façon, je suis sûr que ça va.
Je ne vais pas élaborer sur les avantages de Java (pouvoir et expressivité) ou iwant spécifiquement. Si vous êtes intéressé, vous pouvez lire plus sur la page iwant .
Au lieu de cela, je vais considérer pourquoi Java (et d'autres GPLS) est aussi facilement renvoyé comme inapproprié pour la construction. De nombreuses réponses et commentaires ici sont de bons exemples de cette pensée. Considérons certaines des arguments typiques:
"Java est impératif, mais les constructions sont mieux définies de manière déclarative", ils pourraient dire.
Vrai. Mais lors de l'utilisation d'une langue comme métalliquage pour une DSL interne , ce qui compte vraiment est son syntaxe. Même une langue impérative comme Java peut être trompée Pour être déclaratif. Si cela ressemble et se sent déclaratif, il est (à des fins pratiques) déclaratif. Par exemple:
JacocoTargetsOfJavaModules.with()
.jacocoWithDeps(jacoco(), modules.asmAll.mainArtifact())
.antJars(TestedIwantDependencies.antJar(),
TestedIwantDependencies.antLauncherJar())
.modules(interestingModules).end().jacocoReport(name)
C'est un vrai exemple du Projet de démonstration de Iwant .
En fait, comparez cela à certains systèmes de construction déclarés déclarants qui exposent leurs utilisateurs à de tels verbes impératifs en tant que "test" ou "compiler". La déclaration ci-dessus contient uniquement des noms, aucun verbe. La compilation et les tests sont des tâches implicitement traitées par Iwant afin d'accorder à l'utilisateur les noms qu'il veut. Ce n'est pas la langue. C'est comme ça que vous l'utilisez.
"Java est verbose"
Oui, beaucoup de Java code il y a Verbose. Mais encore une fois, ce n'est pas la langue, c'est comme ça que vous l'utilisez. Si une implémentation est verbeuse, encapsulez-la derrière une belle abstraction. Beaucoup Les GPLS fournissent des mécanismes adéquats pour cela.
Imaginez juste le ci-dessus Java Snippet écrit en XML. Remplacez des parenthèses par des supports d'angle et déplacez-les. Puis dupliquer chaque Mot-clé comme étiquette de fermeture! Java en tant que Syntaxe est non Verbose.
(Je sais, comparer à XML, c'est comme prendre des bonbons d'un bébé, mais de nombreuses constructions deviennent simplement définies dans XML.)
"Vous devriez compiler votre script de construction"
Ceci est un point valide. Néanmoins, c'est juste un problème technique mineur à résoudre. J'aurais pu résoudre celui-ci en utilisant Beanshell ou un autre interprète. Au lieu de cela, je l'ai résolu en le traitant d'un autre problème de construction et de bottes d'iwant avec une coque simple ou un script ANT simple qui compile et exécute un simple Java bootstrapper.
"Java a la chaudière"
Vrai. Vous devez importer des cours, vous devez mentionner "public", "classe" et ainsi de suite. Et ici simple DSL externe score une première victoire facile.
Et si votre projet est si trivial que ce plaque chauffant est significatif, félicitations. Votre problème n'est pas difficile et cela n'a pas vraiment d'importance de la façon dont vous le résolvez.
Mais de nombreux projets nécessitent beaucoup plus que la compilation, le rapport de couverture et l'emballage. Si la chaudière de Java est acceptable pour les problèmes des clients, pourquoi ne pas créer de problèmes? Pourquoi faire des chaussures uniquement pour les enfants des autres?
Une chose que je ne pense pas que les autres réponses ont été abordées est que les limitations et la transparence de ces langues de construction constituent une partie énorme de ce qui les rend utiles. Prenons Maven, par exemple. Oui, il exécute des constructions mais il définit également des dépendances. Cela permet une construction maven pour tirer ces dépendances et regarder leurs dépendances et ainsi de suite.
Considérez si cela a été fait avec Java directement. L'outil de construction verrait qu'il ya une dépendance. Il aurait alors besoin de s'abaisser ainsi d'autre Java Application et exécutez-le pour déterminer ce que les dépendances sont. Mais pour Maven, il regarde simplement les déclarations de dépendance. Le fichier de construction Maven est transparent. Une langue complète Turing est intrinsèquement non transparente . tels que celui-ci.