Pouvez-vous avoir trop de « dynamique » dans les langages dynamiques?

Question

En derniers mois, j'ai fait une transition de Java vers Groovy et je peux comprendre de nombreux avantages qu'elle apporte: moins de code, les fermetures, les constructeurs, MOP à la fin rend cadre comme Grails possible, la facilité avec moqueur quand tests d'écriture, etc.

Cependant, je suis « accusé » par mes collègues que mon code ne suffit pas groovy. A savoir, je déclare encore mes types de paramètres et les champs, ont tendance à utiliser l'héritage et le polymorphisme au lieu de taper de canard, etc. Il me semble que dans ces situations, il est non seulement dynamique par rapport statique, mais aussi dynamique par rapport paradigme orienté objet genre de dilemme. Dans ces cas, je tends toujours à préférer OO. Je pense que paradigme OO a une grande valeur dans son principe de base en vous permettant de faire abstraction et relier votre code construit à des concepts particuliers dans le monde réel.

Alors, voici des questions particulières dont j'ai besoin aider à:

1. Dois-je déclarer des types pour mes paramètres, champs, etc?

2. Dois-je déclarer bloc de code comme la fermeture quand méthode simple va faire?

3. Quand dois-je utiliser le typage de canard au lieu d'expédition dynamique polymorphes. Par exemple, dans groovy que je peux faire des animaux "$ action" () ou animal def. animal.action (), au lieu d'un animal, = new Chien (); animal.action (). Je peux voir le problème avec d'abord dans le cadre du principe ouvert-fermé, mais toutes les autres raisons de préférer le polymorphisme style OO?

4. Quand dois-je utiliser des interfaces dans Groovy (si jamais)?

Je suis sûr qu'il ya d'autres dilemmes similaires, je n'ont pas réussi à écrire. Je pense aussi que ces questions sont valables non seulement pour groovy, mais pour toute autre langue dynamique. Quelle est votre opinion?

Answer 1

.1. Dois-je déclarer mes types de paramètres, champs, etc?

Je tends déclarer des types de classes qui sont utilisées dans le cadre d'une API publique, les choses que les autres développeurs consommera beaucoup, ou où je voudrais une aide supplémentaire de saisie semi-automatique IntelliJ. Sinon je déf 'des choses.

0,2. Dois-je déclarer bloc de code comme la fermeture quand méthode simple fera?

J'utilise des méthodes moins que ce soit quelque chose que je prévois de passer autour comme une variable. Même si il y a la méthode opérateur de déréférencement « foo. & Bar », la plupart des développeurs ne savent pas à ce sujet et sont désorientés par quand ils courent à travers elle. Je l'utilise aussi la fermeture quand il est un petit morceau de code qui est clair pour rester dans une méthode plus plutôt que de mettre dans sa propre méthode à des fins descriptives.

0,3. Quand dois-je utiliser le typage de canard au lieu d'expédition dynamique polymorphes. Par exemple, dans groovy que je peux faire des animaux "$ action" () ou animal def. animal.action (), au lieu d'un animal, = new Chien (); animal.action (). Je peux voir le problème avec d'abord dans le cadre du principe ouvert-fermé, mais toutes les autres raisons de préférer le polymorphisme style OO?

Je n'utilise que la forme animale. « $ Action » () quand j'ai besoin de ce niveau d'indirection parce que le nom de la méthode varie en fonction du chemin d'exécution de code (le plus souvent au cours metaprogramming lourd). J'utilise l'animal animal = nouveau chien (); animal.action () quand je veux l'aide de l'EDI avec autocomplétion, ou que le niveau de la documentation est utile pour la clarté du code (et pas mal par la verbosité supplémentaire qui pourrait être évidente ou contraignante).

0,4. Quand dois-je utiliser des interfaces dans Groovy (si jamais)?

Je les utilise très rarement. Je pouvais voir les utiliser principalement comme la documentation des champs prévus pour un appel API publique, ou peut-être comme une interface de marqueur pour aider à distinguer un ensemble de classes d'un autre point de vue du métaprogrammation. Ils sont beaucoup moins utiles dans groovy que ce qu'ils sont en java.

Answer 2

Ce n'est pas toujours une opinion populaire, mais je pense que le plus explicite et claire de votre code peut être le mieux.

Je n'aime pas les constructions qui devine tout ce qui se passe ... laissez vous

J'ai travaillé pendant un an en Ruby et n'a pas aimé du tout. Je ne dis pas qu'il n'a pas des endroits où il excelle, je dis juste que j'aime vraiment garder propre et explicite les choses et ne se sentent pas que Ruby avait que comme un objectif.

Une chose que je ne figure que pour vous - la quantité de vous taper faites n'équivaut pas à la vitesse globale de développement. Il est vrai qu'une base de code compliqué avec beaucoup de code répété fait pour le développement très lent, mais en réduisant simplement ce que vous tapez sans éliminer la duplication est inutile, et en tapant plus, plus clair, le code plus explicite va être généralement plus rapide (sur la durée du projet) que le même code écrit dans un langage laconique, moins formel.

Si vous ne croyez pas que le typage n'a aucun rapport avec la vitesse de développement, la prochaine fois que vous relâchiez un projet compter le nombre de lignes de code et diviser par les hommes-jours passés (y compris le débogage et le test). En d'autres termes, combien de code a été tapée par jour. Vous trouverez le résultat d'être un très petit nombre -. Saisie du code est en fait une très petite partie de tout projet logiciel

Answer 3

Je pense avec Groovy, vous devriez favoriser la façon la plus simple de faire quelque chose, et à l'arrière tomber sur les caractéristiques groovy que lorsque la situation l'exige. (Comme lors de l'écriture des macros ou la création Multiméthodes dans Clojure, si vous vous trouvez atteindre pour ces outils beaucoup vous devez vous remettre en question.) Votre approche prudente me semble bien à, peut-être vos collègues sont un peu en état d'ébriété avec leur nouveau pouvoir . (Ce ne serait pas la première fois.)

La bonne chose d'avoir une langue flexible comme Groovy est que vous pouvez commencer avec l'approche prudente comme vous faveur en sachant que vous avez des alternatives plus puissantes pour se replier lorsque vous en avez besoin. Vous savez, « la chose la plus simple qui pourrait fonctionner. »

Plus précisément préférant taper de canard sur les interfaces et ne se souciant pas avec les types de paramètres semble que cela pourrait être une bonne chose, il peut le rendre beaucoup plus facile de fournir des simulacres aux tests.

Answer 4

Il se résume à ce que les gens sont à l'aise avec. J'aime utiliser le type declerations et appelle la méthode parce que je suis à l'aise en Java. Le code que je vous écris doit être maintenu par des personnes avec beaucoup d'expérience sur la programmation dynamique, donc je garde proche du code Java normal sauf quand il y a une bonne raison d'utiliser une fonction groovy avancée. Il semble que votre groupe devrait créer des normes de codage qui tentent d'expliquer lorsque les caractéristiques spécifiques de Groovy doivent généralement être utilisés.

Answer 5

Il existe deux principaux types de langages orientés objet.

Les langues du Simula 67 famille, tels que C ++ et Java, les variables favorisent statiquement typés, compilateurs et linkers, et vtables méthode.

Les langues du Smalltalk famille, tels que Ruby, favoriser les variables dynamiquement typés, interprétation et transmission de messages au lieu de la fonction pointeur-tables.

Les deux sont orienté objet, mais très différents sur le concept de l'orientation objet.

Answer 6

OUI

-

NON

Est-ce que vous vous rendez compte il n'y a pas de véritable réponse à cette question?