Quels sont les inconvénients des taquets élastiques? [fermé]

Regardez ici: une guerre sainte typique entre onglets et espaces .

Maintenant, regardez ici: tabstops élastiques . Tous les problèmes ont été résolus et de nombreux nouveaux comportements très utiles ont été ajoutés.

Des tabstops élastiques sont-ils même mentionnés dans cette discussion tabs vs espaces? Pourquoi pas? Y at-il des inconvénients à l’idée d’éléments de tabulation élastiques si sérieux que personne ne les a jamais mis en œuvre dans un éditeur populaire?

EDIT : Je m'excuse d'avoir mis trop d'emphase sur "pourquoi ne sont-ils pas mentionnés". Ce n'était pas vraiment ce que je voulais. cette question est peut-être même hors sujet. Ce que je veux vraiment dire, c’est quels sont les plus gros inconvénients qui empêchent l’adoption plus large d’une idée évidemment bénéfique? (dans un monde idéal où tout le supporte déjà)

(Il s'avère qu'il existe déjà une demande sur Microsoft Connect pour une implémentation Visual Studio de tabstops élastiques , ainsi qu'une demande dans Eclipse . De plus, une question concerne les autres éditeurs qui implémentent des tabstops élastiques. )

Les guerres saintes sont subjectives

Les taquets élastiques de Nick sont un concept étonnant qui pourrait aider beaucoup de gens à s’entendre sur une solution viable, même si je doute fort que cette guerre sainte s’achèverait complètement: c’est aussi une question de goût et beaucoup de programmeurs ne voudront pas bouger. pouce de leur position sur cette question, même au prix d'un compromis. Ce serait donc une première raison.

Par exemple, de nombreuses personnes du côté des "espaces" ne l'aimeront toujours pas, car cela nécessite une logique supplémentaire dans votre logiciel pour un rendu correct (par exemple, la simple visualisation d'un jeu de modifications dans la vue Web de votre GDS).

Problèmes d'implémentation

Mais la raison la plus évidente est simplement son obstacle technique à l'entrée : il s'agit d'un concept fondamentalement différent de celui mis en œuvre depuis plusieurs années (voire des décennies) dans les IDE et les éditeurs de texte. Il faudrait en réécrire certaines pour traiter les lignes de manière assez différente, ce qui complique la tâche des systèmes plus anciens et plus grands, qui risquent davantage de subir un couplage étroit et profond dans leur code de traitement de ligne. Il est, cependant, beaucoup plus facile à faire lorsque vous commencez à partir de zéro (pensez à la démo de Nick ou de Go de tabwriter package).

Pour une anecdote personnelle, je me souviens d’avoir approché l’auteur il y a quelque temps pour lui demander s’il y avait un quelconque soutien à emacs, et dans ce cas particulier, il a mentionné cela comme la raison pour laquelle ce n’était pas anodin. Il a également demandé l'aide de la communauté pour aider à mettre en œuvre cette fonctionnalité et l'amener aux masses.

Est-ce que nous nous en soucions assez?

Une troisième raison est que certains développeurs ne sont pas si pressés par la question et ne se soucient pas vraiment de faire un effort supplémentaire pour soutenir leurs efforts. Dans la plupart des cas, le conflit espaces-vs-tabs n’est pas un bloqueur d’affaires. Il n’ya donc pas beaucoup de motivation derrière le problème.

Si vous le voulez, vous devrez vous battre pour cela. Ce qui est faisable dans un logiciel open-source. Et si vous en modifiez suffisamment, les sources fermées devront suivre au risque de perdre une partie de leur base d'utilisateurs, si infime soit-elle.

Alors, si tu le veux, donne un coup de main à Nick.

Plusieurs fois, j'ai dû me battre avec un traitement de texte pour que le document ait l'apparence que je veux sans règle automatique cachée contrôlant le placement de mes mots. Je ne veux pas passer une seconde à essayer de comprendre pourquoi l'éditeur insiste pour y placer ces mots.

C'est la première fois que j'en entends parler. Je ne sais pas si c'est une bonne idée, mais cela semble peu utile, car nous avons des outils (tels que l'indentation) qui déjà formatent automatiquement le code.

Que se passe-t-il lorsque j'ouvre vos vilaines tabulations élastiques dans vim et les modifie? Est-ce que l'onglet se nettoie automatiquement ou vous laisse-t-il un gâchis?

Les principaux inconvénients, tels que je les vois, sont peut-être les différences, le contrôle de version et la compatibilité avec les éditeurs qui ne les prennent pas en charge. Cela prend peut-être beaucoup de modifications de code pour les prendre en charge et il y a des choses plus importantes que la fonctionnalité "encore un onglet pour formater le code". Après tout, nous pouvons tous utiliser indentce qui fait tout ce qui précède si la mémoire est bonne.

Pour être honnête, je ne les trouve pas très utiles une fois que vous avez surmonté l'excitation initiale. Par exemple, je n'aime pas les commentaires à la fin d'une ligne de toute façon - je place toujours mes commentaires sur une ligne séparée. Avec cela, les onglets élastiques perdent leur utilisation principale.

Après cela, vous pouvez bien sûr toujours les utiliser pour aligner les arguments de la fonction (et les paramètres) et les longues listes d’assignations.

Mais pour les premiers, j'ai tendance à simplement indenter tous les arguments d'un niveau supplémentaire, ce qui me convient parfaitement:

void foo(
    int x,
    int y,
    string z
)

Et je ne vois pas la nécessité de changer cela.

Et en ce qui concerne l’alignement des tâches, je ne le fais pas. Je mets des espaces simples autour des affectations, c'est tout. J'ai aussi tendance à ne pas regrouper beaucoup d'assignations, de sorte qu'il y a rarement un problème de lisibilité.

En résumé, les onglets élastiques n'ont absolument aucune utilité pour moi. C’est bien sûr une préférence très personnelle qui peut varier, mais j’estime que cela fonctionne bien et que l’absence de prise en charge des onglets élastiques tient au fait que d’autres pensent de la même façon.

Si un éditeur les implémentait, je ne les utiliserais toujours pas.

Un inconvénient est que cela ne fonctionne pas si vous souhaitez aligner sur un groupe de lignes puis indenter sur le suivant, car il regroupe les taquets de tabulation des lignes adjacentes.

def foo( bar,
         xyzzy ):
         wibble() # Too much indentation

Ce que je voulais:

def foo( bar,
         xyzzy ):
    wibble()

Pour les langages à accolades, cela pourrait être moins un problème, car vous pouvez généralement le résoudre en plaçant l'accolade d'ouverture sur une ligne distincte (comme dans l'animation), mais pour les langages sensibles aux espaces, cela devient rapidement pénible, et vous finissez par devoir utiliser des espaces.

Pourquoi ne faisons-nous pas simplement que le caractère de tabulation verticale (VT, ASCII 11) serve à indiquer l'utilisation de tabstops élastiques? Cela ne sert à rien dans aucun langage de programmation traditionnel, et pourtant, il est analysé comme un espace valide dans chacun d'entre eux, autant que je sache.

Cela signifierait que l'utilisation de tabulations élastiques n'est plus une convention externalisée (par exemple, "ce fichier a été formaté avec des tabulations élastiques, veuillez les activer"), mais une option pour laquelle vous optez au cas par cas.

Les éditeurs de texte existants affichent généralement un glyphe ou un espace unique à la place d'un onglet vertical. Ce n’est pas idéal, mais un petit prix à payer, IMO.

Ils ne sont pas mentionnés car ils ne sont pas implémentés dans la plupart des IDE d'éditeurs de texte; ils sont une nouveauté peu utile dans un projet.

Les espaces sont utilisés pour la programmation depuis l’époque des cartes perforées. Les onglets sont arrivés et quelqu'un a évidemment pensé que c'était une bonne idée (ils se sont trompés: p).

À l'époque où la plupart des éditeurs modernes peuvent convertir automatiquement les onglets en espaces ... ils sont plutôt inutiles.

Devoir installer un autre outil pour traiter quelque chose d'aussi trivial que tabulations / espaces ne m'intéresse certainement pas, et je ne pense pas que cela plairait à la plupart de mes collègues.

Je pense qu'ils trouveraient une grande utilité si les IDE les prenaient en charge (Microsoft!). Une fois que les gens ont découvert qu'ils pouvaient frapper leurs bacs de fleurs sur le côté et les rendre bien lisibles, ils le feront. Vous pourriez peut-être ajouter soudainement plus de commentaires au code source (ce qui ne peut être que positif).

Je suppose que nous pourrions également ajouter des "info-bulles" à la liste "serait-il bien si ...", afin que vos blocs de commentaires volumineux puissent être masqués et visualisés facilement en cas de besoin? Nous pourrions peut-être aussi avoir des blocs de commentaires qui font partie de la documentation (pas des trucs de type sandcastle, des extraits de documentation lisibles par l'utilisateur qui ont été incorporés dans le code, pas seulement les en-têtes de méthode).

Inconvénients: les différences entre vos sources peuvent sembler mauvaises si plusieurs lignes semblent avoir été modifiées alors que seul 1 (vraiment) a été modifié (si l’éditeur a sauvegardé le fichier avec les tabulations converties en espaces). Ou bien, si l'onglet élastique était implémenté avec un seul caractère (ou plus vraisemblablement, 2 tabulations), alors l'affichage de votre source en dehors de l'éditeur pourrait être gênant.

Cependant, je pense que j'aime bien l'idée, "onglet" à la fin d'une ligne élastifie le bloc de commentaires et aligne tous les commentaires sur les lignes suivantes (qui ont un espacement de double tabulation) en conséquence.

Voici comment je vois les choses: si la plupart des outils populaires prenaient déjà en charge les arrêts de tabulation élastiques, beaucoup de gens les utiliseraient. La même chose s'est produite avec le mode navigation / édition de vi, avec la coloration syntaxique, et plus tard avec Intellisense. Dans chaque cas, la sagesse établie était que cela n’était ni utile ni utile, mais il a été mis en œuvre et a démarré.

Les taquets élastiques ont bien sûr un impact relativement faible. La plupart des gens sont suffisamment satisfaits du statu quo et s'en moquent. Un raisonnement similaire est appliqué à de nombreuses situations dans lesquelles certaines personnes sont simplement heureuses de ce qu'elles ont et ne voient aucune raison de passer à quelque chose de plus avancé. En d’autres termes, le plus gros problème avec les taquets élastiques est le même que pour presque toutes les autres bonnes idées: il faut qu’il gagne en traction.

Mais cela ne signifie pas que la fonctionnalité ne peut pas être adoptée progressivement. Chaque langage de programmation a été adopté progressivement, même si toute une équipe a besoin d’un nouveau compilateur et d’un nouvel IDE pour commencer à l’utiliser. Il en va de même pour chaque architecture matérielle et de nombreux autres exemples. En outre, le manque d'intégration avec les outils existants ne constitue pas un obstacle: il en va de même, par exemple, du "format unifié-diff", qui remplace progressivement un format antérieur moins lisible, mais néanmoins compris par des outils automatisés. (comme patch). Ces outils ont été améliorés au fil du temps.

J'apprécie les problèmes d'interopérabilité évoqués par d'autres, mais malgré eux, il y aura certainement des équipes (comme la mienne) qui l'adopteront sans hésitation, dans notre intégralité. Les outils externes tels que la différenciation, la fusion, etc. ne le prendront pas en charge au départ, mais nous ferions notre part pour encourager les fournisseurs à inclure cette fonctionnalité. C'est ainsi que des progrès ont toujours été accomplis. Cela nécessite quelques peines pendant une période transitoire temporaire, mais finalement, cela en vaut la peine.

Le plus gros problème que j'aurais avec cela est l'espacement incohérent dans toute la documentation. Je sais qu'en tant que programmeur, je serais ennuyé de voir une boucle ou une instruction if à l'indentation «standard», puis de remarquer des indentations différentes. Je sais personnellement que j'aime voir toutes mes accolades alignées dans la documentation, pas seulement dans le bloc de code que je regarde.

Globalement, je pense que c'est une bonne idée cependant, mais personnellement, je ne l'aimerais pas.

Je viens de tester l'implémentation par des tablettes élastiques de jEdit, qui fonctionne étonnamment bien avec les langages de programmation avec lesquels je suis familier (principalement les langages HTML / XML et les langages de type C). Avec le code Python, voici comment il a été rendu (des espaces utilisés à la place des tabulations pour illustrer l’alignement des choses):

def foo(x):
             '''<1 tab before the docstring.
No tab       <tab
No tab       <tab
             <tab  <another tab
             <tab  <another tab
             <tab'''
             if 1 or 2:    #<Tab before this comment
                           yield True

Pour un langage tel que Python reposant sur l'espacement, il s'agit d'un facteur décisif, à moins que vous ne désactiviez la fonctionnalité fournie par les tabstops élastiques. Des éditeurs tels que Vim et Emacs simplifient la désactivation de la plupart des fonctionnalités si vous connaissez le nom de l'option et son désactivation, mais cette fonctionnalité doit être désactivée pour le code comme ci-dessus.

Cela dit, c’est génial pour les systèmes ASM x86, C, C ++, Go, XML, HTML et autres qui ne dépendent pas tellement des espaces:

import (
    "fmt"    // We love formatting functions.
    "io"     // Because I/O is useful.
    "os"     // Can't open a file without os.Open!
)

type Foo struct {
    Field1              int          // This is properly aligned
    ReallyLongField2    string       // with this.
    privateField        io.Reader    // Elastic tabstops are great for Go.
}

Je dirai que les dialectes Lisp tels que Scheme ont leurs propres conventions qui feraient aussi en sorte que les tabstops élastiques rendent le code "moche". Si je modifie mes paramètres de tabulation pour qu'ils correspondent à la convention de 2 colonnes et que j'insère des tabulations à des emplacements inhabituels (entre une fonction et ses arguments):

(let loop ((n 1))
  (if  (> n 10)
        '()
        (cons  n
               (loop (+ n 1)))))

vs le plus lisible:

(let loop ((n 1))
  (if (> n 10)
      '()
      (cons n
            (loop (+ n 1)))))

Certes, celui-ci n'est pas aussi grave que l'exemple Python, mais il réduit nettement la lisibilité du code. Bien que j'apprécie beaucoup la fonctionnalité lors du codage en C # ou C ++, je déteste cette fonctionnalité dans un langage comme Python ou Scheme où les espaces sont fonctionnels et / ou visuellement utiles. Les tabstops élastiques ont été créés spécifiquement pour être utiles sans nécessiter un utilitaire d'indentation séparé, mais ils ne sont évidemment pas destinés à tous les langages de programmation.

Emacs gère déjà l'indentation en présence de parenthèses non fermées et alignera automatiquement wilma avec fred . Je ne sais pas pourquoi Eclipse ne fait pas la même chose. Ok, j'ai une idée, mais c'est peu compliqué.

Vous pouvez aussi amener Emacs à aligner le commentaire sans trop de difficulté, mais autant que je sache, personne d'autre que vous ne l'a jamais voulu.