hocwp a écrit 325 commentaires

Il y a énormement de choses qui ont changé depuis l'annonce sur linuxfr.
En particulier les cadres peuvent contenir des fenêtres avec des positionnements aux choix (les unes derrière les autres comme dans ion, tiled, ...) mais aussi d'autres cadres.
Bon je ne m'étale pas plus puisqu'une nouvelle version est prévue dans peu de temps et ce sera plus l'endroit pour les détails.

Je vais voir pour le paquet debian :)

<pub>À tout hasard, jette un coup d'oeil sur clfswm.</pub>
http://common-lisp.net/project/clfswm/

Merci à vous tous, depuis quelque temps la navigation sur linuxfr avec la toolbar était devenue assez pénible.
<ma_vie>Par contre je dois être un peu déviant vu que j'ai trouvé la méthode de dawar plus simple que de chercher sur google comment installer l'extension...</ma_vie>

pas de différence.
Ben pourquoi n'est-elle pas restée sous windows alors ?
Aïe /o\ ~~~~> [ ]

L'époque ou on optimisait la RAM, c'etais sous MSDOS
Ben fallait bien pour tout faire tenir dans moins de 640 Ko pour faire plaisir à Bill :)

Ah, merci, je me doutais bien qu'il sortirait quelque chose de positif de ce journal :)

Je me demande même si openoffice n'est pas plus rapide qu'emacs ...
Sur ma machine quand même pas. Mais de toute façon on ne boot emacs qu'en début de session (s'il n'est pas déjà démarré) et la session se termine quand on le ferme. Donc le temps de démarrage n'est pas trop gênant.

Arf, je ne l'avais pas vu. Ce doit être comme les phases de la lune : il faut que ce thème revienne régulièrement :)

Boh, l'acte manqué c'était peut-être "vi s*x" :)
Et oui, ma conclusion est complètement débile. Mais bon je trouvais ça marrant.

Rho, on se rapproche dangereusement de cette nouvelle de RMS :(
http://www.gnu.org/philosophy/right-to-read.fr.html

Movitz : http://common-lisp.net/project/movitz/ (Lisp)
ForthOS : http://www.forthos.org/ (Forth)

Voila ce que j'appele une macro en Lisp :

• Définir un nouveau type de boucle :

  (defmacro while (test &body body)
    `(do ()
         ((not ,test))
       ,@body))
  
  (let ((a 1))
    (while (< a 10)
      (print a)
      (incf a)))

  Dans le même style, la macro loop est assez impressionnante.
• Le if anaphorique :

  (defmacro aif (test then &optional else)
    `(let ((it ,test)) (if it ,then ,else)))
  
  (defun un-calcul-super-long ()
    (sleep 10)
    (+ 2 2))
  
  (aif (un-calcul-super-long) (print it))
  

  La variable 'it' prend le résultat de la fonction 'un-calcul-super-long'
• Une macro de débogage :

  (defmacro dbg (&rest forms)
    `(progn
      ,@(mapcar #'(lambda (form)
  		  `(format t "~A=~S   " ',form ,form))
  	      forms)
      (format t "~%")
      (force-output)))
  
  (dbg a str (+ 2 3 4))
  A=12   STR="toto"   (+ 2 3 4)=9
  
  (macroexpand-1 '(dbg a str (+ 2 3 4)))
  (PROGN
   (FORMAT T "~A=~S   " 'A A)
   (FORMAT T "~A=~S   " 'STR STR)
   (FORMAT T "~A=~S   " '(+ 2 3 4) (+ 2 3 4))
   (FORMAT T "~%")
   (FORCE-OUTPUT))
  

Peut-on faire la même chose en C ?

Ah j'ai oublié de rajouter la compilation incrementale (c'est très pratique de pouvoir compiler chaque fonctions séparement et les tester une par une - Pas besoin de recompiler tout le programme à chaque fois).
Sinon, je parle de Common Lisp.

Simple : sa syntaxe. Une règle qui est toujours la même
(fonction arg1 arg2 arg3 ...). Un point c'est tout.
Puissant : Les _macros_. Sa gestion des flux, des paquets, des erreurs, des nombres, des valeurs multiples, les arguments optionnels ou par clé, son système objet (CLOS)... et j'en passe. Le fait que quasiment tout est déjà dans le langage et qu'il est simple de rajouter ce qui manque. Que l'ont peut modeler le langage dans un langage plus adapté à ce qu'on doit faire (DSL)...

Ce qui me fait aimer le lisp : c'est simple, souple et puissant.

Sinon un lien sur l'enseignement du Java comme premier langage :
http://www.stsc.hill.af.mil/CrossTalk/2008/01/0801DewarSchon(...)

Roh, s/non/n'ont/ y en a d'autres mais celle la quand même...

Sous clfswm ce sera la même chose à une grosse différence près c'est que le groupe que tu utilises est réellement en plein écran. Donc les barres disparaissent et l'application est en plein écran si le groupe l'est. Par contre tu peux réduire/maximiser le groupe et epiphany suit le mouvement (dans sont état maximiser (sans barres)). Rho une vidéo serait plus claire :)
Pour vlc, mplayer je n'est pas constaté de problème mais si tu testes clfswm et que tu en vois, je suis vraiment prenneur de tout retour.
Pour les icones de notification, il me semble avoir vu que ceux de thunderbird marchaient, je n'ai pas testé avec les autres programmes mais clfswm respecte les 'voeux' des fenêtres qui ne doivent pas être dans un groupe. Donc à voir.
Sinon je le prononce lettre par lettre même si je ne l'ai pas encore dit tout haut :)

Oui, moi j'utilise control+< (c'est ce que j'ai trouvé de plus rapide : faisable avec la main gauche). Par contre pour distribué clfswm j'ai eu des problèmes avec des gens qui non pas de clavier français. J'utilise aussi le twosuperior (du coup je ne peux plus le taper :) ou les touches accentuées qui ne sont pas présentes sur tous les claviers. Donc j'ai fais une répartition des touches que je n'utilise pas mais qui passe normalement sur tous les claviers.

Ah, bien moi c'est l'inverse, je sais que dans beaucoup de WM Alt+Bouton1 déplace la fenêtre et c'est plutôt pour enlevé le titre de la fenêtre que je suis obligé de lire la doc.
C'est vrai que dans ce sens clfswm n'est pas intuitif. Mais une fois la prise en main faite, on (je) n'a plus besoin des titres des fenêtres qui deviennent plus génant qu'autre chose.

J'ai aussi rencontré ce problème de conflit avec les applications dans d'autres WM. C'est pour ça que clfswm ne gère pas la souris et très peu de touches dans le mode normal. Par contre il prend intégralement le contrôle de la souris et du clavier dans le second mode.
Donc : mode normal=Application ; second mode=Gestion des fenêtres. Ce qui evite les conflits.
C'est le principe utilisé par stumpwm ou screen par exemple.
Le plus dur aura été de trouvé une touche (Alt+t) par defaut qui fait passer dans le second mode, qui est valide sur tous les claviers et qui n'a pas de conflit avec les autres applications.

> C'est un peu la philosophie de je-sais-plus-quel-outil qui installait un grand jeu de lien symbolique.

Stow ? http://www.gnu.org/software/stow/stow.html

> - un WM qui offre des fonctionnalité pour améliorer ma productivité (notion de frame, de groupe, fixé/flottant, full-screen, contrôle sans souris...)
Ok c'est ce que fait clfswm.

> - un WM qui permette d'accéder à toutes ces fonctionnalité y compris avec la souris (pour les jours où ma mémoire flanche, ou pour les actions peu courantes)
Tout est faisable à la souris dans le second mode par contre comme il n'y a pas de décoration il faut faire des alt+bouton.

> - un WM esthétique (qui s'intègre bien dans mon bureau Gnome)
Là ce n'est pas encore possible. Mais j'ai commencé à suivre les recommandations de Net WM (mais ce n'est pas une priorité).

> - un WM qui se configure "automatiquement" (il faut qu'il mémorise les groupes que je fait, qu'il se souvienne que j'aime avoir Emacs en plein écran, sans que j'ai à ouvrir un éditeur texte pour programmer dans un langage de script barbare).
Ca ce n'est pas très dur à rajouter vu que l'arbre des bureaux est connu. Il suffit de sauver la variable *workspace-list* de manière compréhensible à la fin de la session. Mais on peut déjà créer au demarrage un groupe dans tel bureau avec une géometrie donnée dans lequel on lance telle application.

Le principe de clfswm est que toutes les fenêtres sont maximisées à l'ecran (c'est le cas de la majorité des applications que j'utilise). Et si on veut des fenêtres plus petites, il suffit de les retailler pour les mettre où on veut (exemple : Le Gimp).

C'est effectivement le principe de clfswm sans le côté automatique. Les groupes peuvent être manipulés à la souris ou au clavier pour se placer sans laisser de place perdue.
Cette approche me semble plus souple qu'avec des gestionnaires comme AWESOME mais ça demande un tout petit peu plus de travail pour placer les fenêtres comme on le veut.
D'ailleurs on peut programmer le comportement que l'on veut. Je donne l'exemple d'un placement à la larswm qui est très facile à simuler.
(voir le fichier de configuration en exemple : http://common-lisp.net/cgi-bin/viewcvs.cgi/*checkout*/clfswm(...) )

Pour le placement et le redimensionnement il ne faut pas perdre de vue que le gestionnaire de fenêtre gère plusieurs fenêtres dans le même groupe. La gestion d'une fenêtre seule dans sont groupe est fluide (en tout cas je ne vois pas de différence avec dwm par exemple). Mais c'est vrai que je peut retravailler ce point en cachant les fenêtres non visibles.
Pour les couleurs j'ai fais de mon mieux, les couleurs précédentes du pager me semblant encore pires :)
Et pour la font, j'en ai mis une par défaut présente sur tous les systèmes mais ça reste configurable bien évidement (faut que je regarde se que mettent les autres par défaut).

Je ne connais pas clusterssh. Par contre il n'y a pas de notion de fenêtre flotante dans clfswm. Une fenêtre appartient à un ou plusieurs groupes et c'est le groupe qui est redimensionnable.

Pour ouvrir plusieurs fenêtres d'un coup clfswm propose une fonction qui permet d'ouvrir la prochaine fenêtre dans un nouveau bureau et les autres fenêtres dans de nouveaux groupes. On obtient un groupe par fenêtre dans un nouveau bureau. Après il ne reste plus qu'à tilé ce bureau par exemple. C'est ce que j'utilise quand j'ai besoin de suivre en même temps les logs de plusieurs programmes lancés automatiquement.

Ah, oui c'est vrai que c'est tout sauf sexy si on le compare à Compiz vu que le but est de ne pas voir le gestionnaire de fenêtre.
Comparé aux autres wm, il me semble un peut plus souple que ratpoison/stumpwm. Il reprend le principe des cadres de ion3 sans afficher les onglets. Et il gère un peu moins les fenêtres que wmii, même si se mode de fonctionnement reste faisable (d'ailleurs c'est ce qu'essai de montrer la video).
Et au niveau ergonomie il me convient, normal non ? :)

Pour appuyer tes dires on peut définir la fonction 'eval' du lisp codé en lisp à partir de seulement 7 opérateurs : http://lib.store.yahoo.net/lib/paulgraham/jmc.lisp
Ce qui est relativement simple. Par contre le Common Lisp ne sera pas qualifié de simple si on compte les 978 symbôles[*] (fonctions, macros ou variables) définis de bases et sans compter, comme tu le dis, les mots clé de la macro loop... Mais le point de départ est extremement simple.
[*] http://www.lisp.org/HyperSpec/FrontMatter/Symbol-Index.html