Journal opa-watch: compilation et lancement automatique à l'édition

Posté par .
3
21
sept.
2012

Éditer, Compiler, Lancer… c'est une boucle que vous ne connaissez que trop. Vous avez la flemme de réécrire un n-ième script bash à base de inotify-wait et notify-send (ou quelque chose de plus exotique).

opa-watch vous permet de vous concentrer sur la boucle Editer, Editer, Editer…

Le but d'opa-watch est de faciliter la vie des développeurs Opa mais il est également conçus pour être utilisable pour d'autres langages (voir pour d'autres activités que le développement).

Par exemple ce journal est édité avec en fond de tâche la commande suivante:

 opa-watch.exe --srcdir opa-watch/ --command "pandoc opa-watch/journal.md -o opa-watch/journal.html" --command "firefox opa-watch/journal.html"

A chaque fois que j'enregistre ce journal (fichier journal.md dans le répertoire opa-watch/), ce dernier est convertit vers un fichier journal.html avec pandoc, sa prévisualisation est lancée sous firefox, et je suis notifié de la tournure des événements (p. ex. en cas d'erreur de conversion).

Plus d'information sur le blog Opa.

  • # Un peu dans le même esprit...

    Posté par . Évalué à 2.

    Personnellement, j'ai un petit script que je préfère ne pas donner parce qu'il est en chantier et n'a pas bougé depuis le jour de son écriture, mais qui fait quelque chose d'assez similaire.

    Je travaille sur une application serveur en python que je redémarre à chaque changement dans le code.

    La logique derrière le script est assez simple :

    • je lance le serveur dans une boucle infinie
        while [ 1 ]; do SERVER_COMMAND_HERE; done
    
    

    Puis le script en question, contenant simplement un boucle qui

    • demande à inotify de monitorer les changements
        inotifywait -r -e modify --excludei "\.(pyc)" .
    
    
    • à chaque fois qu'ils sont détectés, kill le processus serveur
        pid=`ps aux | grep $PROG_NAME | cut -f 3-4 -d\ | sed -n 1p `
        kill $pid
    
    

    … et je sais, awk, sed et cie, c'est pas mon dada. Je n'ai jamais cherché à faire mieux. Mais je suis preneur de conseils :)

  • # IDE

    Posté par . Évalué à 10.

    Bravo d'ici 15 ans vous aurez un IDE ;)

    • [^] # Re: IDE

      Posté par . Évalué à 3.

      Mais ça fait 12 ans que j'ai un IDE, il s'appelle GNU/Linux ou Unix (je sais plus lequel) ;)

      La compilation automatique j'avais eu un hook sur emacs a chaque sauvegarde de fichier, mais maintenant y a un fly-make, même plus besoin de sauver.

      La doc et tout le reste était bien intégré.

      Alors oui fallait configurer à la main, c'était pas 1 appli, mais 50, mais globalement ça fait tout ce que permet les IDE moderne d'aujourd'hui sans consommer 500Mo de ram. Mais aujourd'hui sur les projets sur lequel je suis, régulièrement j'ai un collègue qui me fait; ouais faudrait que je configure les package (par déplier les boite.machin.truc.bidule.appli.serveur.interface avant d'arriver au ficher voulu, on a vu plus efficace.

      Et puis maintenant y emacs ;)

      Il ne faut pas décorner les boeufs avant d'avoir semé le vent

      • [^] # Re: IDE

        Posté par . Évalué à 3. Dernière modification le 21/09/12 à 18:02.

        La compilation automatique j'avais eu un hook sur emacs a chaque sauvegarde de fichier, mais maintenant y a un fly-make, même plus besoin de sauver.

        Mais maintenant ? Ca doit faire plus de 10 ans que ca existe.

        Maintenant si tu penses qu'un IDE se limite à ca, tu as encore beaucoup de chose à découvrir. Si tu as eu le temps de prendre la peine d'apprendre à configurer correctement un emacs ou un VIM pour être réellement productif (notion très différente selon les environnements) ne fait pas comme ton collègue aux bras cassés, apprend à t'en servir correctement. Que des mecs soient content d'avoir une pauvre boucle qui compile automatiquement en 2012 je trouve ca un peu triste.

        Maintenant tu choisis ce que tu veux. Mais juger objectivement les outils ne fait pas de mal. Si je donne 1 journée à quelqu'un pour tester emacs il dira que c'est de la merde…

        • [^] # Re: IDE

          Posté par . Évalué à 2.

          Maintenant si tu penses qu'un IDE se limite à ca, tu as encore beaucoup de chose à découvrir.

          Peux tu préciser (c'est une question sincère pas rhétorique)?

          • [^] # Re: IDE

            Posté par . Évalué à 6.

            Les IDE les plus avancés vont être capables d'analyser ton code en même temps que tu l'écris. L'idée c'est pas simplement de te sortir la doxygen de la méthode que tu es entrain d'utiliser, mais aussi vérifier que le type des arguments que tu lui donne correspondent à ce qui est attendu par celle-ci (sans attendre la sauvegarde du fichier), ils sont capable de faire du refactoring (renommer intelligemment des méthodes et des variables, par intelligemment j'entends plus qu'un sed : renommer une variable toto en tata, ne va pas renommer la méthode toto), évidement tu peut voir tout les usages d'une méthode ou d'une variable (intéressant quand tu doit reprendre du code pour être sûr que tu as vu tout les usages de la méthode que tu va modifier) et sauter à la définition de celle-ci rapidement. Là où certains vont encore plus loin c'est quand ils analyse la base de données que tu es entrain d'utiliser en même temps que tu écris les requêtes. Ça permet de voir que la table foo n'existe pas où qu'il n'y a pas de champ bar dedans.

            Alors les puristes expliqueront que tout cela, eux, ils le remplacent par leur cerveau, qu'ils réfléchissent avant d'écrire leur code et que c'est X fois plus puissant, mais force est de constater que si tout cela était vraiment pris en compte les bugs seraient bien moins répandu et qu'ils utilisent déjà un tas de chose pour parer aux faiblesses de leur réflexion (tests, compilation, outil d'analyse statique ou dynamique, etc).

            Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

            • [^] # Re: IDE

              Posté par . Évalué à -4.

              Tes fonctionnalités ne sont rendues possible que par la pauvreté du langage, parce que dès que tu à un peu de duck-typing, pouf, tout tes avantages disparaissent, et on ne dépasse même pas le stade de trouver un bon compléteur de code pour des langages qui ont du duck-typing comme Python et C++. Alors vérifier le type des arguments tu oublie (c'est plutôt vérifier l'usage des arguments qui compte), refactorer le code se fait mieux avec sed qu'avec n'importe quoi d'autre de soit-disant intelligent, Voir les usages des méthodes est soit incalculable, soit non-pertinent ou soit aussi pertinent qu'un grep. Quand à sauter aux définitions …

              Alors ça, oui je le remplace par mon cerveau, mais je suis ouvert à toute proposition qui soit réaliste. Parce que oui, compléter du code en utilisant un interpréteur/compilateur, c'est bien joli, mais généralement le code ne compile ni s'interprète correctement quand je suis en train de l'écrire.

              Avoir un IDE pour Java est juste obligatoire (tu ne pourrai pas supporter de devoir renommer le nom de la classe + renommer le fichier à la main), mais si beaucoup de personnes s'accommodent très bien de ne pas avoir d'IDE pour coder du C, C++ et Python, c'est peut-être qu'il y a une raison.

              • [^] # Re: IDE

                Posté par . Évalué à 4.

                Tu as essayer un peu sérieusement les IDE de Jetbrains ? Pour les utiliser en ce moment fréquemment sur du JS et du Python franchement y'a pas mal de trucs qui sont assez bluffant (vu la tronche des langages) et pratiques.

                Après y'a pas de miracle non plus. Mais utiliser un outil qui te facilite la plupart des tâches ne t'empêche ni d'utiliser ton cerveau, ni d'utiliser d'autres outils quand ils sont plus appropriés.

              • [^] # Re: IDE

                Posté par . Évalué à 5.

                pour des langages qui ont du duck-typing comme Python et C++

                T'es vraiment en train de dire que le C++ a du duck-typing ? T'es sérieux ?

                le type des arguments tu oublie (c'est plutôt vérifier l'usage des arguments qui compte)

                Donc tu vois qu'il y a des vérifications à faire (même si t'a pas du beaucoup utiliser C++ dans ta vie…)

                refactorer le code se fait mieux avec sed qu'avec n'importe quoi d'autre de soit-disant intelligent

                Comment tu fais avec sed pour vérifier que tu n'es pas entrain de renommer une autre méthode d'une autre classe, mais qui a le même nom ?

                Voir les usages des méthodes est soit incalculable, soit non-pertinent ou soit aussi pertinent qu'un grep. Quand à sauter aux définitions …

                Je n'es pas parlé de faire un calcul de tout les chemins (je vois pas pourquoi tu parle de ça). Je vois pas en quoi c'est non-pertinent (mais c'est bien reste avec tes aprioris et ton assurance que toi tu sais contrairement aux autres). grep va te ressortir un tas de faux-positif (si ça te conviens tant mieux, il m'arrive d'utiliser ack).

                Alors ça, oui je le remplace par mon cerveau, mais je suis ouvert à toute proposition qui soit réaliste.

                Ça n'a rien de compliqué de mettre en place ce genre de truc. En Python Tu dois pouvoir faire un truc qui marche pas superbien mais qui dépanne avec un grep sur le def (c'est plus technique en C, C++ et java qui n'ont pas de mot clef pour ça).

                Parce que oui, compléter du code en utilisant un interpréteur/compilateur, c'est bien joli, mais généralement le code ne compile ni s'interprète correctement quand je suis en train de l'écrire.

                Je présume que tu n'édite pas tout les modules de ton projet en même temps (si c'est le cas tu a peut être un problème d'architecture) de plus je présume que tu ne modifie pas les bibliothèques que tu utilise.

                Avoir un IDE pour Java est juste obligatoire

                Non je me sert régulièrement et des fois sur de longues périodes de vim pour éditer du Java.

                tu ne pourrai pas supporter de devoir renommer le nom de la classe + renommer le fichier à la main

                C'est une bonne pratique en C++ et en python. Quand tu renomme une classe ce qui prend le plus de temps c'est de le faire partout où elle est utilisée. Si ce n'était qu'un problème de renommage de fichier il suffirait d'ajouter un mv très simple devant la commande sed qui te permet de renommer en masse. Rien de très technique. La modification des import se fait elle très bien car les import utilisent le nom complet de la classe qui est unique.

                mais si beaucoup de personnes s'accommodent très bien de ne pas avoir d'IDE pour coder du C, C++ et Python, c'est peut-être qu'il y a une raison.

                C'est des langages où il est plus compliqué de créer des IDE aussi poussé que ce que l'on trouve ailleurs. Le C++ a une syntaxe très compliquée (y compris pour écrire un compilateur), python a le typage dynamique et le C est très laxiste. On trouve pourtant des IDE pour le C++ (qdevelop) qui font pas mal de choses déjà). Pour les deux autres je ne sais pas.

                C'est l'un des points qui fait le succès de Java d'avoir permis la création d'outil autour du langage. C'est quelque chose de recherché et non pas un effet de bord (ça simplifie la compilation, l'analyse statique (pour détecter d'éventuelle erreur et failles), etc).

                Par contre je ne comprends toujours pas t'a vraiment voulu dire que le C++ fais du duck-typing ???

                Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

                • [^] # Re: IDE

                  Posté par . Évalué à 4.

                  Donc tu vois qu'il y a des vérifications à faire (même si t'a pas du beaucoup utiliser C++ dans ta vie…)

                  On va faire simple :

                  template<typename T>
                  void faire_quelquechose(T t) {
                       t.
                  
                  

                  Montre moi comment tu autocomplête à cet endroit. Tu pourrais regarder les usages de faire_quelquechose(), même si là plupart du temps, ils ne sont même pas encore écrits. Tu pourrais me sortir l'intersection de tout les membres des T utilisés, ce qui n'est pas toujours pertinent, puisque tu ne sait peut-être pas que j'ai envie de spécialiser faire_quelquechose juste après. Et pourtant, ça n'est qu'une bête fonction template, alors imagine ce que c'est avec du vrai code qui fait de l'injection de dépendance (chouette, un buzzword) avec des templates

                  Oui, il faudrait pouvoir vérifier les usages. Quand on à du vrai code ou il y a des templates qui appellent d'autres templates, tu ne peux vérifier l'usage que lorsque du code non-template commencera à utiliser ta chaîne d'appel. Et si jamais il y a une erreur d'instantiation, tu ne sais jamais la faute de qui c'est. Autrement dit, ton IDE n'est pas plus avancé que ton compilateur, et un bête :make sous vim fait très bien la même chose que ton IDE.

                  Comment tu fais avec sed pour vérifier que tu n'es pas entrain de renommer une autre méthode d'une autre classe, mais qui a le même nom ?

                  La question ce n'est pas de savoir comment ne pas renommer une autre méthode d'une autre classe, mais de savoir si c'est pertinent.

                  class A {
                      void faire_quelquechose();
                  };
                  
                  class B {
                      void faire_quelquechose();
                      void faire_autre_chose();
                  }
                  
                  // peut être utilisé avec A et B.
                  template <typename T>
                  class User1 {
                      void f(T& t) {
                          t.faire_quelquechose();
                      }
                  };
                  
                  // peut être utilisé avec A et B
                  template <typename T>
                  class User2 {
                      void f(T& t) {
                          for (unsigned i = 0; i < 5; ++i)
                              t.faire_quelquechose();
                      }
                  };
                  
                  void usage_actuel() {
                      User1<A> user1;
                      User2<B> user2;
                      A a;
                      B b;
                      user1.f(a);
                      user2.f(b);
                  }
                  
                  

                  Je veut renommer A::faire_quelquechose() en A::do_something() avec un outil automatique. Est ce que je modifie que son usage dans C, ou est ce que je modifie tout, comme sed ? Dans les deux cas, le code compile quand même. Mais les commentaires donnent plutôt raison à sed.

                  Et encore, on est dans un cas simple, vu qu'on peut faire la même chose en C avec des macros. Si j'ajoute un petit utilisateur un peu plus compliqué (version C++11, je vous épargne la version C++03):

                  template <typename T>
                  auto faire_la_meilleure_chose(T* t, T* bidon) -> decltype(t->faire_quelquechose()) {
                      t->faire_quelquechose();
                  }
                  template <typename T>
                  void faire_la_meilleure_chose(T* t, void* bidon) {
                      t->faire_autre_chose();
                  }
                  // peut être utilisé avec A, B, et aussi C que j'ai la flemme de définir.
                  template <typename T>
                  void user3(T& t) {
                      faire_la_meilleure_chose(&t, &t);
                      // et autre chose au passage.
                  }
                  void usage_actuel() {
                      B b;
                      user3(b);
                  }
                  
                  

                  Pour ceux qui ne connaissent pas le C++ autant que nous deux (parce que tu le comprend ce code, hein ?), la version python est plus courte :

                  def user3(a):
                     if hasattr(a, "faire_quelquechose") and callable(a.faire_quelquechose):
                         a.faire_quelquechose()
                     else:
                         a.faire_autre_chose()
                     # et autre chose au passage.
                  
                  

                  (et qu'on vienne pas me dire que C++ ne fait pas de duck-typing)

                  Sachant que B à aussi faire_autre_chose(), ne pas renommer l'usage par user3 va aussi produire un code qui compile. On est même pas dans un programme complet, mais on à déjà deux choix à faire, et donc 4 cas possibles. Seul le programmeur pourrai choisir ce qu'il faut faire pour ne pas se retrouver avec du code qui foire à l'exécution, et un simple sed amélioré qui demande si il faut remplacer ou pas est ce qu'il y a de mieux, un peu comme :%s/faire_quelquechose/faire_autrechose/gc dans un vim, quoi.

                  Et là ton programme il compilait et il connaissait les utilisateurs. Imagine si c'était une bibliothèque et que ce seront les utilisateurs de la bibliothèque qui écriront usage_actuel(). Tu ne peux pas vérifier tout les cas dans un vrai programme, parce qu'il y en a plusieurs milliers (si le nombre est fini), et avec tes tests, tu n'en couvrira qu'une toute petite partie.

                  Je n'es pas parlé de faire un calcul de tout les chemins (je vois pas pourquoi tu parle de ça). Je vois pas en quoi c'est non-pertinent (mais c'est bien reste avec tes aprioris et ton assurance que toi tu sais contrairement aux autres). grep va te ressortir un tas de faux-positif (si ça te conviens tant mieux, il m'arrive d'utiliser ack).

                  Simple : Parce que tout les chemins pertinents, tu ne les connais pas, pourtant tu en à besoin, rien que pour simplement renommer une méthode, et ce, même si ces chemins ne sont pas utilisés (ou alors pas encore). grep va sortir plein de faux positifs, tout comme Visual C++ 2010. Moi, personnellement, je préfère les faux positifs aux faux négatifs.

                  Ça n'a rien de compliqué de mettre en place ce genre de truc. En Python Tu dois pouvoir faire un truc qui marche pas superbien mais qui dépanne avec un grep sur le def (c'est plus technique en C, C++ et java qui n'ont pas de mot clef pour ça).

                  Ça n'a rien de très compliqué de rechercher les vrais usages dans un code qui compile, le compilo le fait très bien. Le problème, c'est que d'un point de vue du programmeur, du code peut être lié à d'autre code, même si le chemin n'est pas utilisé.

                  Aller, un exemple en C pour la route :

                  #ifdef ACTIVE_LE_DEBUG_STEPLAIT
                  void debug(int severity, const char* format, ...); // avec définition ailleurs.
                  #else
                  static inline void debug(int severity, const char* format, ...) { }
                  #endif
                  
                  

                  Si le debug est activé, la version sans debug n'est jamais utilisée. pourtant elle est importante, et doit suivre les évolutions de la fonction réellement utilisée. Cela peut rendre la fonction "sauter à la définition" non-pertinente, puisqu'il y a deux définitions.

                  Et ce cas là est facile, puisque si on ignore les macros, on peut voir deux déclarations.

                  Je présume que tu n'édite pas tout les modules de ton projet en même temps (si c'est le cas tu a peut être un problème d'architecture) de plus je présume que tu ne modifie pas les bibliothèques que tu utilise.

                  Une des bibliothèques que j'utilise, est boost. Je ne la modifie pas, mais je crée des chaînes de templates dedans qui peuvent potentiellement appeler mon code pas-fini (ou même pas écrit) en retour.

                  C'est une bonne pratique en C++ et en python. Quand tu renomme une classe ce qui prend le plus de temps c'est de le faire partout où elle est utilisée.

                  Lorsque ta classe est déjà utilisée, oui, c'est ce qui est le plus long, mais généralement, je modifie plus souvent les noms des classes que je n'ai pas fini de l'écrire qu'autre chose, surtout quand je me rend compte au dernier moment que la classe que j'écris devrai être coupée en deux.

                  Quand à faire du une classe = un fichier en C++, non merci, mes classes sont bien trop petites pour ça. Et j'ai trop de mauvaises expériences avec de gros projets java de 10000 fichiers de 100 lignes qui sont impossibles à naviguer, même avec un IDE.

                  C'est des langages où il est plus compliqué de créer des IDE aussi poussé que ce que l'on trouve ailleurs. Le C++ a une syntaxe très compliquée (y compris pour écrire un compilateur), python a le typage dynamique et le C est très laxiste.
                  C'est l'un des points qui fait le succès de Java d'avoir permis la création d'outil autour du langage. C'est quelque chose de recherché et non pas un effet de bord (ça simplifie la compilation, l'analyse statique (pour détecter d'éventuelle erreur et failles), etc).

                  Peut-être, mais tout le monde ne code pas en Java, et Java n'est pas la solution à tout. Les autres langages sont peut-être moins parsables, mais ils ne sont pas inintéressants pour autant. Certains font des choses que Java ne pourra jamais faire.

                  On trouve pourtant des IDE pour le C++ (qdevelop) qui font pas mal de choses déjà).

                  Si tu regarde qdevelop, c'est plutôt un IDE pour ceux qui font du C++ avec Qt, c'est à dire avec un framework orienté objet avec presque pas de templates. Mais pour le reste, il est rapidement perdu.

                  Par contre je ne comprends toujours pas t'a vraiment voulu dire que le C++ fais du duck-typing ???

                  On peut faire du mal aux mouches pour définir ce qu'est le duck-typing, mais de mon point de vue, c'est tout comme. Tu définit des fonctions qui prennent n'importe quoi en paramètre sur lequel tu peux utiliser n'importe quelle opérations du moment qu'elle éxiste. Tu peux aussi tester si une opération est possible et faire autre chose si elle ne l'est pas. Si ce n'est pas du "si ça cancane, ça nage et que ça marche comme un canard, alors c'est un canard", alors je ne vois pas ce que c'est.

                  • [^] # Re: IDE

                    Posté par . Évalué à 3.

                    Je veut renommer A::faire_quelquechose() en A::do_something() avec un outil automatique. Est ce que je modifie que son usage dans C, ou est ce que je modifie tout, comme sed ? Dans les deux cas, le code compile quand même. Mais les commentaires donnent plutôt raison à sed.

                    Je ne suis pas sûr que la question soit pertinente. Tu ne nome pas une fonction en fonction de comment elle est utilisée mais en fonction de ce qu'elle fait (c'est au reste du code d'évoluer). Alors oui pour les gros projets ça peut poser problème, mais le risque de le faire dans le sens inverse est à mon avis trop grand et on se simplifie la vie aujourd'hui pour la complexifier plus tard. Si vraiment on a besoin d'un ensemble donné de méthode, je pense que passer par une classe abstraite que l'on dérive pour chacun des usage est plus pertinent (tu regroupe à un endroit le protocole d'utilisation de la classe). Ça crée plus de classe mais je n'ai pas observer de perte notable de performance là dessus une fois compilé.

                    Pour ceux qui ne connaissent pas le C++ autant que nous deux (parce que tu le comprend ce code, hein ?), la version python est plus courte :

                    Honte sur moi de ne pas avoir penser à ce genre de cas. Tu a tout à fais raison.

                    Je ne continue pas plus parce que tu as tout à fais raison. C'est très compliqué d'avoir une annalyse de code statique performante en C++, principalement du fait des templates qui vont générer du code à la compilation (quand on voit la galère que les compilateurs on pour gérer la métaprogrammation par template…).

                    Peut-être, mais tout le monde ne code pas en Java, et Java n'est pas la solution à tout. Les autres langages sont peut-être moins parsables, mais ils ne sont pas inintéressants pour autant. Certains font des choses que Java ne pourra jamais faire.

                    J'ai mal présenté ma thèse (mais c'est aussi la manière dont tu as tourné ton propos qui m'a aider à ça), je ne cherche absolument pas à ce que tout le monde pour tout langage utilisent des IDE. Je voulais juste signifier que les IDE peuvent avoir un intérêt. Ils se sont démocratisé par le langage qui est le plus propice à en développer (Java) mais ils peuvent apporter un vrai plus que l'on a pas forcément avec les binutils. Surtout utiliser l'un n'interdit en rien d'utiliser l'autre. Je ne vois pas pourquoi les opposer comme cela (un comble quand on voit mon second commentaire… bref), pour certains langages et pour certains usages les IDE sont très pratiques alors que dès que l'on change de langage ou d'usage ça peut ne plus l'être du tout.

                    Il faut éviter d'avoir une position dogmatique, ça ne reste que des outils c'est notre usage (et notre connaissance de ceux-ci) qu'il leur (ou non) un intérêt.

                    Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

            • [^] # Re: IDE

              Posté par . Évalué à 0.

              On est d'accord, les développeurs n'ont pas à avoir tout en tête, surtout sur des projets gros avec pleins de contributeurs. Pour moi l'ensemble des vérifications (statiques) sur le code, c'est le boulot du compilateur (typage et interface, y compris les schémas BD).

              Je suis pas expert IDE mais je suppose qu'il y a potentiellement beaucoup de code redondant avec le compilateur pour faire pleins de vérification directement au niveau IDE (parsing, typage …).

              Après sur toutes les tâches de d'accélération du codage (complétion …), de refactoring, et d'exploration du code c'est clair que l'IDE peut beaucoup aider.

              • [^] # Re: IDE

                Posté par . Évalué à 2.

                Je suis pas expert IDE mais je suppose qu'il y a potentiellement beaucoup de code redondant avec le compilateur pour faire pleins de vérification directement au niveau IDE (parsing, typage…).

                Oui mais c'est aussi le cas des analyseurs statiques de code. Je crois que llvm permet d'être utilsé dans ce genre de condition, mais c'est pas le cas de gcc…

                Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

        • [^] # Re: IDE

          Posté par . Évalué à 2.

          Mais maintenant ? Ca doit faire plus de 10 ans que ca existe.

          J'ai commencé emacs y a plus de 10 ans ;)

          Mais, non avec emacs j'utilise ebrowse, plus un paquet de truc plus ou moins maison adapté au projets sur lesquels je bosse.

          Mais emacs est loin d'être seul dans mon environnement, le bash fait beaucoup. Par exemple quand je vois à quel points les autres font des trucs compliqués pour créer un patch pour l'appliquer à la branche (et je ne compte pas les fois où ils se plantent…) Alors qu'une fonction shell à moi le fait à ma place et me propose de gérer les conflit quand y'en a.

          Alors oui c'est un petit truc, mais des petits trucs comme ça y'en a plein mon .alias et .function et .emacs.

          Il ne faut pas décorner les boeufs avant d'avoir semé le vent

          • [^] # Re: IDE

            Posté par . Évalué à 1. Dernière modification le 22/09/12 à 10:01.

            Mais emacs est loin d'être seul dans mon environnement, le bash fait beaucoup. Par exemple quand je vois à quel points les autres font des trucs compliqués pour créer un patch pour l'appliquer à la branche (et je ne compte pas les fois où ils se plantent…) Alors qu'une fonction shell à moi le fait à ma place et me propose de gérer les conflit quand y'en a.

            Perso je préfère utiliser les SCM en console, en partie par fainéantise de changer mes habitudes. Mais certains IDE offrent aussi de très bonnes fonctionnalités et intégration. Notamment en terme de merge de conflits mais aussi de pour par exemple choisir uniquement certaines lignes à commiter. Ce qui est très pratique quand tu as finis par mélanger deux changements dans un fichier. Aucun soucis pour créer des patchs, les appliquer etc. C'est franchement très très bon, les produits de Jetbrains assurent là dessus; Netbeans est pas mauvais non plus et comme d'hab Eclipse est le plus merdique.

            Donc oui pour des besoins particuliers des outils fait maison et adaptés sont souvent plus efficace. Par contre quand on peut éviter de réinventer la roue c'est pas mal. Par ce que c'est ultra-couteux de développer les dit outils. Comme toujours il n'y a pas un outil qui répond à tout les besoins, il faut choisir le plus adapté et savoir les combiner.

          • [^] # Re: IDE

            Posté par . Évalué à 2.

            Mais emacs est loin d'être seul dans mon environnement, le bash fait beaucoup. Par exemple quand je vois à quel points les autres font des trucs compliqués pour créer un patch pour l'appliquer à la branche (et je ne compte pas les fois où ils se plantent…) Alors qu'une fonction shell à moi le fait à ma place et me propose de gérer les conflit quand y'en a.

            Tu as une fonction shell pour faire un git diff ?

            Le problème de tes collègues c'est qu'ils ne connaissent pas leur outil. Tu as passé combien de temps à apprendre et configurer emacs, bash et les binutils ? Combien de temps eux pour leur IDE ?

            perso je ne vois pas l'intéret d'opposer les deux moi j'utilise les deux en même temps. Par exemple, mon IDE Java me permet de renommer une classe en gérant tout les usages de celle-ci, son intégration avec git lui permet d'indiquer à git que c'est un renommage, puis moi je commit en shell par simplicité.

            Tous les contenus que j'écris ici sont sous licence CC0 (j'abandonne autant que possible mes droits d'auteur sur mes écrits)

            • [^] # Re: IDE

              Posté par . Évalué à 2.

              on utilise svn :P

              Il ne faut pas décorner les boeufs avant d'avoir semé le vent

              • [^] # Re: IDE

                Posté par . Évalué à 3.

                Dans ce cas git-svn sera plus efficace que n'importe laquelle de tes fonctions dans un .sh

                • [^] # Re: IDE

                  Posté par . Évalué à 2.

                  la fonction en question date d'il y pas mal de temps, (avant git), et a la base c'est juste du spatch 54781 pour propager une modif d'une branche à l'autre (le variable d'environnements font la sélection des branche à ma place); j'ai donc jamais cherché mieux.

                  Par contre pouvoir utiliser la puissance de git me semble pas mal ;) Dès que le projet ne sera plus en feu je regarderai.

                  Il ne faut pas décorner les boeufs avant d'avoir semé le vent

  • # watchdog

    Posté par (page perso) . Évalué à 0.

    une autre possibilité, watchdog (en python), il y a un truc équivalent en ruby aussi.
    https://github.com/gorakhargosh/watchdog

    watchmedo shell-command --patterns="*.rst" --ignore-patterns=".*;#*;*~" --command="make html" .
    
    
    • [^] # Re: watchdog

      Posté par . Évalué à 1.

      En Python aussi, la plupart des bibliothèques web (eg Pylons ou CherryPy) proposent un rechargement automatique en cas de modification d’un des fichiers. Utile lors du développement. Par contre ça ne recharge pas automatiquement la page dans le navigateur, mais pour ça il y a MultiDeskOS 2.

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.