hocwp a écrit 331 commentaires

tu tapes :

M-x pc-selection-mode

=> Control - Inser : copier
Shift - inser : coller

"Ne dit on pas du..." ne devrais tu pas te faire une opinion par toi même plutôt que d'écouter se que trollent disent les autres ?

Essaye M-x viper-mode alors :)

http://www.sunsite.ualberta.ca/Documentation/Gnu/emacs-20.7/(...)

Y'en a qui traivaillent dessus :

http://hurd.rustedhalo.net/about.php

Oui exactement, je crois que s'ils ne poussaient pas à la consomation, avec un systeme plus souple, je me servirai encore de mon portable et donc je leur rapporterai encore quelque chose alors que pour l'instant c'est niet !

J'ai eu une mobi carte pendant un temps parce que je ne me servais pas regulierement de mon portable.
Au debut c'etait pas trop mal, puis les tarifs ont augmentés : 10¤ à utiliser dans les 15 jours ou 20¤ dans les deux mois.
Dans le bureau de tabac où j'ai acheté ma derniere mobi carte, ils n'avaient plus que des cartes à 20¤. J'en ai acheté une (j'avais besoin de telephoner) mais je ne me suis servis que de 2¤ dans les deux mois => 18¤ donnés à FT... Depuis mon portable est gentilment rangé dans un tiroir et il n'a plus de numero attribué : le coup de fil est _beaucoup_ trop cher et leur politique commerciale ma dégouté !

Disclamer: je ne connais pas bien OCaml, par contre je commence à accumuler les projets en lisp, alors je me permet de partager mes expériences.

Tout d'abord, le Lisp a une syntaxe extrêmement simple que l'on maîtrise en 10 minutes :

(commande argument1 argument2 argument3)

Un programme en Lisp n'étant qu'une liste d'expressions, on peu manipuler un programme en Lisp comme une donnée quelconque. Ce qui est un avantage pour faire de l'IA (voir le PAIP de Peter Norvig [1] qui est très impressionnant).

Certains critique le trop grand nombre de parenthèses. En fait, elles permettent de délimiter très clairement chaque expression. Par exemple, ce n'est pas nécessaire de connaître l'ordre d'évaluation des différents opérateurs. Comparer :
1+2+3+4+5+6 à (+ 1 2 3 4 5 6)
et 2*3+4*5 à (+ (* 2 3) (* 4 5)).
D'autre part, tout bon éditeur de texte permet de repérer les parenthèses correspondantes et d'indenter correctement le code.
Avec un peu d'habitude, on ne vois plus les parenthèses. De plus, ce qui me manque quand je recode avec d'autres langages, c'est la sélection d'expression : on sélectionne la 1ère parenthèses, on saute à la parenthèse correspondante et on manipule tout le bloc.

Ensuite, le Lisp est très expressif, on utilise en général des noms longs et signifiant ce qu'ils font.

Par exemple: (first '(toto titi plop)) renvoie toto.

Ou pour la gestion des fichiers :

(with-open-file (stream "my-file.txt" :direction :output :if-exists :supersede)
  (format stream "j'écris ça dans my-file.txt~%"))


Les macros sont un des gros point fort du Lisp : on peut étendre le langage pour le modeler à ce que l'on veut faire.

Par exemple, je retrouve assez souvent la forme suivante pour la gestion de personnages dans un MUD qui envoi un message à tout les personnages sauf au personnage qui envoi le message :

(dolist (cible (contenu (trouve-contenant perso *monde*)))
  (when (and (perso-p cible)
             (not (eql cible perso)))
    (send-to-perso cible "bla bla bla")
    bla bla bla))

plutôt que de répéter (à l'infini et par copier/coller) ce code, j'ai juste écrit la macro suivante :

(defmacro do-for-all-perso ((perso cible) &body body)
  `(dolist (,cible (contenu (trouve-contenant ,perso *monde*)))
     (when (and (perso-p ,cible)
                (not (eql ,cible ,perso)))
       ,@body)))

maintenant, pour envoyer un message à tout les autres personnages, j'ai juste à écrire :

(do-for-all-perso (cible perso)
  (send-to-perso cible "bla bla bla")
  bla bla bla)

Les macros sont extrêmement puissantes et permettent d'adapter le langage. Certains les utilisent pour créer des langages spécifiques à leurs domaines d'applications, d'autre par exemple pour avoir la notation infix [2] dans leur programme.
Pour plus de détails sur les macros, la lecture de OnLisp [3] de Paul Graham est un bon point de départ.

Un autre reproche que l'on peut faire au Lisp est qu'il n'a pas de typage statique. Personnellement je trouve que le typage dynamique procure une souplesse très appréciable. Toujours pour l'exemple du MUD, un personnage pourra commencer une partie en tant que simple paysan (la classe paysan) et au cours du jeu acquérir de l'expérience et devenir un magicien (on le change de classe et sa classe devient magicien).
Un autre usage qui revient assez couramment est que l'on peut faire des fonctions qui agirons différemment suivant le type de ces arguments. Exemple :

(defun ma-fonction-add (x y)
  (typecase x
     (integer (+ x y))
     (string (concatenate 'string x y))))

et on l'appelle de la manière suivante :
(ma-fonction-add 2 3) renvoie 5
(ma-fonction-add "Toto" "Titi") renvoie "TotoTiti"

De plus, le Lisp est un langage typé (pour ceux qui en doute). on peut soit attendre un type particulier grâce aux asserts ou aider le compilateur grâce à des directives du type

(defun toto (x y)
  (declare (type fixnum x y))
  bla bla)

Les grands nombres (bignums) sont un autre avantage du Lisp.

Essaye de calculer factoriel 1000 (exemple bateau...) :

(defun fact (n)
  (if (= n 1)
      1
      (* n (fact (1- n)))))

(fact 1000) renvoie un nombre de 2569 chiffres. La seule limite pour n étant la taille de la mémoire.

Bon, je m'arrête là, mais on pourrait aussi parler du système d'exception (thow / catch) ou de CLOS le système objet du Lisp, ou de pleins d'autres notions (memoisation[4]) qui sont tout aussi magnifiques !

Et pour finir, je trouve que le Lisp me permet de faire des programmes de manière simple et rapide tels que je les pense : le langage ne se met pas dans mes pattes et ne m'impose aucune restriction ou obligation sur ce que je devrais faire...

Enfin, un lien pour démarrer : http://www.algo.be/clr.html

Et une petite citation pour alimenter le troll :

"Greenspun's Tenth Rule of Programming: any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp." - Philip Greenspun

[1] http://www.norvig.com/paip.html
[2] http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/lang/l(...)
[3] http://www.paulgraham.com/onlisp.html
[4] http://en.wikipedia.org/wiki/Memoisation

Peut-être qu'il fera l'affaire ?

http://www.klografx.net/qiv/

M-x column-number-mode fait apparaitre le numero des lignes dans la modeline.

Pour avoir le même resultats que sous VI, il faut plutôt utiliser :

* LineNumbers ( http://www.emacswiki.org/cgi-bin/wiki?LineNumbers )

(load "/chemin/vers/setnu.el") dans le fichier ~/.emacs,

puis M-x setnu-mode

ou

* wb-line-number ( http://homepage1.nifty.com/blankspace/emacs/elisp.html )

(load "/chemin/vers/wb-line-number.el") dans le fichier .emacs,

puis M-x wb-line-number-toggle

(Et si vous avez un doute, vous pouvez utiliser les 2 en parallèle :) )


Pour répondre au poste au dessus :

Le format des lignes peut-être changé avec la variable 'setnu-line-number-format' avec setnu.el et 'wb-line-number-format-string' pour wb-line-number-toggle : rien n'est hardcoded tout est configurable... ;-)

Avec emacs :

C-espace au debut de la première ligne à commenter
on va au debut de la dernière ligne à commenter
puis C-x r t # <entrée>

(ce qui appel la fonction string-rectangle qui remplace le contenu d'un rectangle par une chaine de caractères).

> Même en console, tu as le choix de ne pas sauvegarder ton fichier de conf.

ou de mettre en commentaires les differents essais que tu as fait pour y revenir plus tard s'ils convenaient mieux...

Larswm est un gestionnaire de fenêtres minimaliste qui gère tout seul les fenêtres :

http://home.earthlink.net/~lab1701/larswm//larswm_ss.png
http://hocwp.free.fr/sA.gif
http://home.earthlink.net/~lab1701/larswm/ (site officel)
http://hocwp.free.fr/larswm.html (page française (pub :) ))

Mon IP : 192.168.0.6 sur cette machine (mais je suis pas sur que ça te serve à grand chose) et sinon le mot de passe c'est pas «test» mais «toto1234». Oups...

Il suffit peut-être juste de créer un utilisateur "test" pour l'occasion ? (le nombre de fois où j'ai écrasé son repertoire home à celui là... :)

[Je profite de cette revue de presse]

<ma vie>Le client mail du GLMF 75 n'ayant pas supporté les ~2000 mails de retour de vacances. Pauvre Canvas 2000*(2*boutons+3*labels) c'était trop pour lui.</ma vie>
Donc, j'ai légèrement modifier l'interface pour qu'elle supporte un nombre quelconque de mails (le nombre de boutons est fixe).
Et au passage, j'ai rajouté une interface en ligne de commande (REPL du Lisp) accessible depuis le terminal ou par telnet ou par un navigateur internet (ce qui permet de faire tourner clmail sur une machine peu puissante sans écran et d'avoir quand même une interface graphique pour accéder à ses mails depuis n'importe quelle machine d'un réseau (mais attention aux problèmes de sécurité et à bien régler sont firewall)).

Enfin, voila, le tout est ici : http://hocwp.free.fr/glmf/article_clmail/clmail-v2/(...) pour ceux que ça intéresse...

Oui plus ou moins.

En vrai, ça ressemble à ça :

http://hocwp.free.fr/temp/screen.png(...) : version graphique

http://hocwp.free.fr/temp/screen-2.png(...) : version texte

Il peut exporter les documents en TSV (tab separeted values) => le contenu peut être lu avec n'importe quel tableur. On peut imprimer le buffer directement depuis Emacs. Et je me suis fait une petite moulinette pour transformer le TSV en tableau Latex.

Les macros s'ecrivent en lisp (ça peut-être rebutant pour certain mais c'est extrêmement pratique pour moi (qui suis fan de Lisp)).

Enfin, voila, j'en suis très content pour gérer mes notes.

Comme tableur en mode texte, il existe SES qui s'utilise depuis emacs :

http://home.comcast.net/~jyavner/ses/(...)

Mouais, à ce compte là, autant l'écrire en lisp comme indiqué dans le poste juste au dessus : comme ça les balises sont fermées automatiquement :)


(loop for n from 100 downto 1 do
      (format t "~A bottles of beer on the wall " n)
      (format t "~A bottles of beer " n)
      (format t "Take one down, and pass it around... ")
      (format t "~A bottles of beer on the wall~%" (- n 1)))


Ou pour faire vraiment dans le même style quand XML:

(defun my-print (&rest args)
  (format t "~{~A~}" args))

(loop for n from 100 downto 1 do
      (my-print n " bottles of beer on the wall ")
      (my-print n " bottles of beer ")
      (my-print "Take one down, and pass it around... ")
      (my-print (- n 1) " bottles of beer on the wall" #\Newline))

Le Lisp aussi ( http://fr.wikipedia.org/wiki/Common_Lisp(...) )

un nombre entier précis

Si aucun programme ne prend en charge la fenêtre racine, tu devrais voir des petites bêtes qui se planquent sous tes fenêtres.
Essaie de les ralentir :

$ xroach -speed 0.05 -squish

Sinon, évite d'utiliser la gestion du fond d'ecran par rox-filer (donc pas d'option pinboard) ou autre.

Oui, ici : ftp://metalab.unc.edu/pub/Linux/X11/demos/xroach-4.0.tar.gz(...)

C'est pas grave, il suffit de cliquer dessus et il disparaissent :)

/me compatissant.

J'ai vu passé, il y a quelques temps, une note venant du réctorat indiquant que les licences de MS Office ne serai pas renouvellées (trop chères) et qu'il fallait utiliser OpenOffice à la place.
Resultats dans mon lycée, tout le monde se met à OpenOffice et on nous a même proposé une formation.
Par contre, le chef de labo ne veut toujours pas entendre parler de (GNU/)Linux :(
Tout ceci à Beauvais (dans l'Oise).

Euh, par contre, ça fait la deuxième fois que mon firefox segfault. Je crois que ce n'est pas encore trés stable :(

Pour avoir le split, je crois qu'il faut avoir plusieurs buffers ouverts. Mais on ne peut couper qu'en deux contrairement à emacs.

Chouette trouvaille effectivement :)