Recently, I showed, how Sweave could be used to generate dynamic content (e.g. pdf-letters) from a data source (in my case an Excel file). While letters are nice, personal and appear more important, emails are nicer and in my case I wanted to save some costs by sending the personalised pdf-letters via email to my ex-schoolmates that have arrived in the Internet age (no offence).

The Emacs/Gnus way

This time, Python shall be used, although I spent some thought on an Emacs macro. If you are using Gnus as mailing client, this would be an interesting alternative, that demonstrates the immense power of Emacs macros. You would need to prepare two buffers: one with the constant parts (subject and body). In another buffer all changing data (mailing address, salutation, attachment) could be present in a comma-separated table like this:

mail@bla.com,Dear Sarah,InvitationSarahJane.pdf

Then you start the macro with C-x C-(. At first open a new mail (C-x m). You change to the table buffer and copy the mail address from it. The same applies for the following columns, but it could get a bit more difficult here: you need a unique prefix, for which you can search (C-s). This way you hopefully can reach any column in a macro-generic way. When you insert the data into your mail, you will also have to navigate using the search. Do not forget to delete the line from the table buffer and set the cursor into the correct position. Finally you send the mail (C-c C-c) and terminate the macro definition (C-x )). You execute the macro with C-x e and can repeatedly execute it by just pressing e. This way, you still have a bit control of the stuff you are sending.

The Pythonian way

I have not done it that way, but instead experimented a bit with Python’s email module. Discussing the code here in the blog is not such a good idea, as wordpress.com does not allow to format your HTML adequately (without paying for it). But if you want, have a look at the package I glued together. The script provides some three convenience functions and if you customise the last region, you can send yourself a test message. Now that mailing worked, I combined that with a csv reader (simply import csv) and iterated over the rows in my address database. Here the whole thing could become extremely cool, if you have boolean columns in your file (e.g. “tellHimToBringFood”). Then you could generate real dynamic content – in my case the only variable part actually were attaching personalised invitations as pdf. I used this script here to send around 50 mails. Albeit much testing before the final call, you still get a bit nervous before sending all the mail. After all, you do not want to be the CS student that cannot send mails…

Tired of opening files with the same filename in Emacs and having that horrible <2>, <3>, <n> appended to the end of the buffer name ? I was, but luckily a friend of mine pointed me to the uniquify library that ships with Emacs.

Just put these two lines in your .emacs file and enjoy:

(require 'uniquify)
(setq uniquify-buffer-name-style 'forward)


This is extremely useful when editing django projects where each app usually has a models.py and a views.py. With this, you avoid confusion! (and save some time).

ENJOY!

Etant un utilisateur régulier d’emacs, j’ai toujours trouvé la police d’affichage de ce logiciel pas très attrayante. Puis un jour, je suis tombé sur le logiciel emacs-snapshot qui était un emacs possédant un affichage attrayant.

Bel emacs pour Ubuntu

Pour avoir ce bel emacs sous Ubuntu, il faut installer le paquet emacs-snapshot (et ses dépendances) avec la commande

sudo apt-get install emacs-snapshot

Il faut ensuite taper les commandes suivantes dans un terminal pour choisir la police d’affichage (où Sans est le nom de la police qu’on souhaite utiliser  et 8 sa taille, libre à vous de modifier la police et sa taille)

echo "Emacs.font:Sans-8" >> ~/.Xresources
xrdb -merge ~/.Xresources

On utilise ensuite cet emacs en tapant la commande suivante dans un terminal

emacs-snapshot &

On peut aussi ajouter un alias dans le fichier $HOME/.bashrc en tapant dans ce fichier la ligne suivante

alias emacs="emacs-snapshot"

Hi Planet Emacsen, and thanks Edward!

It was only in June this year that I started to write Emacs Lisp. The first extension I wrote is wpmail.el, which I published on github but didn’t announce as I wasn’t quite happy with it. Since then, I hacked some more on it and it’s in a better shape now, so here’s the obligatory blog post.

From the file header:

An Emacs extension to make posting by e-mail to the wordpress.com blog hosting service http://www.wordpress.com easier. It might work with other wordpress installations, which I have not tried. For more information about posting to wordpress by e-mail see the support page http://support.wordpress.com/post-by-email/.

Documentation is a bit lacking, but here’s the gist: start a new post, possibly from the region or the buffer, with wpmail-new-post or wpmail-new-post-here. Send it with wpmail-send-post when you are done. wpmail will prompt for title and category; it will propose some titles that you can see via M-n, and it auto-completes the categories in wpmail-categories. See the documentation of these functions for details.

You can write your posts in Markdown format http://daringfireball.net/projects/markdown/ if you have markdown-mode http://jblevins.org/projects/markdown-mode/ installed. Set wpmail-markdown-command to your Markdown converter and posts will be converted to HTML when sending them.

I have the feeling that the documentation could be clearer. This is probably due to the fact that while I was writing wpmail.el, my ideas about the best way of using it changed.

Initially, I made it so that the very start of a blog post would be calling wpmail-new-post. It would visit a new file in wpmail-posts-dir and you’d start writing. This requires wpmail to be in charge. Then I realized that it could be less intrusive and added wpmail-new-post-here. It simply turns your current buffer into a blog post by adding a title and the wordpress shortcode directives like “status draft”. Otherwise, it’s up to you what to do with the buffer.

It works pretty well for me now, so I’m not gonna change it around again for myself anytime soon. I’d be happy about suggestions, though!

In the latest version, I also managed to get around two wordpress bugs. One was that <pre><code>, Markdown’s default markup for verbatim blocks, was being garbled. WordPress.com’s support was very helpful and the problem is now fixed. The other is that I remove single line breaks before sending, because while wordpress mostly ignores them (as you should in HTML), it seems to turn some into <br/>.

I hope it’s useful for someone. Let me know if that’s the case!

haha Yah!

I have officially created my own .emacs file. I was tired of how it was opening, so I told it to open _this_ tall and _this_ wide and open over on the other side of my desktop in the corner. It behaves now. I also played with my terminal for a sec, making the background clear and changing the font color to blue. It was nice, but I switched back to default.

Also on the admin front I added clamAV to my box. Seems redundant and is most likely a leftover of my ‘dows paranoia, but I did it anyway. Speaking of ‘dows left-overs, how to restart a process in linux? process-name restart. heh, gotta love it.

Stuart Halloway’s Programming Clojure book is the only game in town for learning Clojure (at least until Luke VanderHart’s Practical Clojure is released), and Clojure Box is the easiest way to get Clojure running on Windows with a good IDE, if you don’t already have cygwin installed, but they don’t quite play nicely out of the box.

Craig McDaniel has some generally useful code for Emacs/Clojure, and that’s almost enough to get things working. With the following changes incorporated, all of the examples work for me:

(defun reset-swank ()
  "Because changing swank-clojure-extra-classpaths is not enough to force a new instance of slime to use it."
  (interactive)
  (setq slime-lisp-implementations
        (assq-delete-all 'clojure slime-lisp-implementations))
  (add-to-list 'slime-lisp-implementations
               `(clojure ,(swank-clojure-cmd) :init swank-clojure-init) t))

(defun run-slime (dir)
  (interactive "Project directory: ")
  (cd dir)
  (when (file-directory-p "~/.clojure") (directory-files "~/.clojure" t ".jar$"))
    (make-directory "classes"))
  (setq swank-clojure-extra-classpaths '("src" "classes" "lib/*" ""))
  (reset-swank)
  (slime))

I’m making a note as I forgot which function was I using after not publishing  anything  for a while

In emacs the function is contained in the package htmlize. This guy made a function to directly have the output code with the css styles inline, as that is necessary when posting in wordpress blogs.

Hmm, this one is strange and the worst thing is: you do not find much about it in the internets. When I try to C-x C-f <notExistingFile> (equals (find-file "notExistingFile")), emacs returns an error message in the minibuffer: no match. I do not remember to upgrade emacs and the last time I experimented with the configuration must be somewhere in the more distant past.

What did I do? After M-x customize-group find-file, I found Confirm Nonexistant File Or Buffer. Setting the value of this variable to "Never" solves the problem for me. But I think, the actual problem is about complementation. The meaning of the mentioned variable is, what shall be done after emacs tried to complete a file name that does not exist. I guess, I messed up something different about complementation.

Beside that, a look into the customisation of file-file, seems to be interesting. For example, there is Directory Abbrev Alist, which let’s you choose abbreviations resp. shortcuts for your find-file commands.

Although the viper mode does not provide a lot of vim’s motions e.g diw and similar. The vimpulse plugin (http://www.emacswiki.org/emacs/download/vimpulse.el) does extends viper to provide several of these.

Supported commands in include

diw, ciw, yiw, di”, da”, ci”, ca”, yi”, ya”,
di(, da(, ci(, ca(, yi(, ya(,
di’, da’, ci’, ca’, yi’, ya’,

(take that google)

I find these vim text objects fairly useful.

Maxima est un outil de calcul formel, emacs un éditeur de texte et LaTeX un langage de programmation pour obtenir de magnifiques documents. Quel est l’intérêt d’unir ces trois logiciels? Celle de profiter des calculs du logiciel Maxima puis d’obtenir ces calculs sous forme utilisable sous LaTeX.

Dans la galerie d’images suivantes sont présentées diverses photos d’écran d’emacs utilisant maxima. Pour les afficher en plein écran, cliquer sur FS. On se déplace avec les flèches sur les images ou en cliquant sur les miniatures. Le bouton i affiche le volet d’informations sur l’image en cours (son titre).

[flagallery gid=1 name="Gallery"]

Sommaire

• Installation sous Linux
• Installation sous Windows
• Utilisation

Installation sous Linux

On installe le logiciel maxima (et ses dépendances) à l’aide des dépôts Ubuntu avec la commande

sudo apt-get install maxima

On télécharge l’archive suivante imaxima.tar.gz ou une version plus récente ici.

On installe cette archive avec les commandes suivantes

tar zxvf imaxima-imath-1.0.tar.gz
cd imaxima-imath-1.0/
sudo ./configure
sudo make
sudo make install

On télécharge le fichier suivant breqn097a.zip ou une version plus récente ici.

On installe cette extension LaTeX

unzip breqn097a.zip
mkdir -p $HOME/texmf/tex/latex/breqn097a
cp -rf  breqn097a/* $HOME/texmf/tex/latex/breqn097a/.
texhash

Pour vérifier que cette extension est bien installée, on tape dans un terminal:

kpsewhich breqn.sty

Cela doit afficher

$HOME/texmf/tex/latex/breqn097a/breqn.sty

Pour finir, on ajoute les lignes suivantes au fichier .emacs situé dans le répertoire $HOME/

;;;;; imaxima
;;; add to load-path the directory where imaxima.el is installed.
(push "/usr/local/share/emacs/site-lisp" load-path)
;;; add to load-path the directory where maxima.el is installed.
;;; If you change the install directory of maxima, the first argument
;;;  of push must be changed accordingly.
(push "/usr/share/maxima/5.13.0/emacs" load-path)
;;; add autoload of imaxima and maxima.
(autoload 'imaxima "imaxima" "Frontend for maxima with Image support" t)
(autoload 'maxima "maxima" "Frontend for maxima" t)
;;; add autoload of imath.
(autoload 'imath-mode "imath" "Imath mode for math formula input" t)
;;; Make the line effective if you want to use maxima mode with imaxima.
;; (setq imaxima-use-maxima-mode-flag t)

L’installation d’Imaxima sous Linux est terminée. Passons à son utilisation dans Emacs.

Installation sous Windows

Il faut installer les logiciels MiKTeX 2.7, GPL Ghostscript et Emacs.

MiKTeX

Pour installer MiKTeX, on télécharge le fichier setup.exe sur cette page (la version basique suffit) et on double-clique sur le fichier téléchargé pour lancer l’installation. Attention à installer MiKTeX dans le répertoire proposé par défaut. Pour plus d’informations, aller sur cette page.

Ghostscript

On installe ensuite GPL Ghostscript 8.63 (ou une version plus récente). Il faut aller sur cette page et choisir la version la plus récente de Ghostscript et télécharger la version pour Windows (elle se termine par w32.exe). L’installation se fait ensuite par défaut.

Maxima

On installe ensuite le logiciel Maxima (version 5.18.1 ou plus) ici. L’installation doit se faire par défaut.

Emacs

On installe finalement Emacs pour Windows. On a le choix entre  NTEmacs ou  emacsW32. J’ai une préférence pour le second.

On ajoute finalement dans le fichier ~/.emacs, la ligne suivante (attention à modifier les numéros de versions si nécessaire)

(load "c:/Program Files/Maxima-5.18.1/share/maxima/5.18.1/emacs/setup-imaxima-imath.el")

Utilisation sous Linux et Windows

Supposons qu’on shouhaite connaître le développement du carré de (x+3).

On ouvre le logiciel Emacs et on tape la ligne suivante où expand est la commande de Maxima pour obtenir le développement (pour en savoir plus sur les commandes de Maxima disponibles et leurs syntaxes aller sur cette page ou chercher sur le net des docs plus complètes).

{maxima expand((x+3)**2) maxima}

ATTENTION, il faut que les commandes de Maxima soient entre {maxima et maxima}

On active le mode d’imaxima dans emacs (M- correspond à la touche Esc)

M-x imath-mode

On remarque en bas dans la fenêtre d’Emacs le texte M-x imath-mode enabled qui indique que le chargment du module imaxima est effectué.

Pour obtenir le résultat (développement de (x+3) au carré, on place le curseur juste après la dernière accolade et on tape la commande suivante (rappel C- correspond à la touche Ctrl)

C-c !

Pour revenir à la commande de maxima, on tape la commande

C-c &

Mais le plus intéressant reste à venir. Pour obtenir les commandes LaTeX de la solution calculée par maxima, on doit taper deux commandes: la première pour revenir à l’image tex
calculée:

C-c !

et la seconde nous affiche le code latex entre accolades:

C-u C-c &

Pour plus d’infos, voici le site du développeur de imaxima http://members3.jcom.home.ne.jp/imaxima/Site/Welcome.html

Pour changer le coding-system il faut taper sous emacs:

C-x RET c utf-8 C-x C-f

Pour convertir un fichier en DOS en UNIX, il faut taper:

C-x C-m f unix

Pour convertir un fichier en UNIX en DOS, il faut taper:

C-x C-m f DOS

I use to write everything in LaTeX.

Until April (when the Jaunty version of Ubuntu was released) I used the Kile editor, however, the new version of Kile wasn’t satisfactory (to me)… So I went back in time to an old friend, Emacs.

To install Emacs
$ sudo apt-get instal emacs

It is a really powerful editor (and much more than an editor), which allows one to compile, auto-completion, spell-check, et cetera.

For help on LaTeX environment, open a .tex file using
C-x C-f /path/to/file.tex
if you have emacs running, or launching
$ emacs /path/to/file.tex
from the terminal, then type
C-h m
and the Emacs’ LaTeX help will appear.

NOTE: C- means hold Control button while press the next letter.

For flying spell check, use
M-x flyspell-mode

If you need another language dictionary, italian for example, install it
$ sudo apt-get install iitalian
and chenge it typing in Emacs
M-x ispell-change-dictionary italiano

NOTE: M- means hold Alt button while press the next letter.

Enjoy!

Rappels: “M-” correspond à la touche Esc et “C-” correspond à la touche Crtl.

Voici un ensemble plus complet des commandes clavier pour Emacs.

[wp-pdf-view
swf="http://philippe.segalat.free.fr/swf/emacs/emacsrefcard.swf"
width="600"
height="500"
/]

Télécharger emacsrefcard.pdf

Quand on passe de Windows à Linux, il arrive, à l’ouverture de certains fichiers dans emacs, que des ^M apparaissent en fin de ligne.

Pour les supprimer, il suffit de taper la commande suivante, en notant que “M-” correspond à la touche Esc, “C-” correspond à la touche Ctrl et “Enter” correspond à la touche Enter

M-< M-% C-q C-M Enter C-q C-j Enter !

Explications

• M-< : on se place au début du document
• M-% : on active le mode de remplacement de caractères
• C-q C-M : on va remplacer les ^M
• C-q C-j : on va y mettre à la place des retours à la ligne
• ! : on applique ces modifications à toutes les occurrences rencontrées dans le fichier.

Pressing the actual escape button is far too much effort, so my brain seems to have decided to learn to us C-[ in vim in preference to escape.

To get this working in viper add the following line:

(setq viper-ESC-key “\C-[“)

To your emacs init file before you have required viper. Note that this variable cannot be set in your .viper file or changed after you have loaded viper, or rather it can but it has no effect.

This happens in the emacs viper vim emulation mode shipped with ubuntu 9.10 in November 2009.

There is a work around by setting viper-want-ctl-help-h in your emacs init file after viper has been imported.

This bug occurs because viper-set-expert-level which is called as part of loading viper tramples on various viper settings. However it does need to set those settings which have not been overwritten in your .viper file.

As a workaround in viper one could do one of the following:

i) Make viper-set-expert-level only set those settings which are not already set if dont-change… is set to true
ii) Load the .viper file twice once after calling set-expert-level (hackish but it works)
iii) Do something crazy so as to have shadowed variables, where the set-expert-level only sets the value that is shadowed.

However, I am not going to change any of this at the moment.

Update: I should have said Rails IDE – but I’m sure similar plugins are available for other languages

I fired up NetBeans at work today, tried to open a Rails project and – inexplicably, it crashed. All is well at home, so I’m blaming work machine setup issues as-yet unknown (but I suspect, involving the letters “ATI”).

It got me thinking that, as much as I like NetBeans, it is still just a memory-eating, CPU-hogging, bloated Java-based GUI. For some time I’ve wanted to convert my favourite editor, Emacs, to something more like an IDE.

It's Emacs, but not as we know it

The key plugins include ECB, textmate.el, Rinari and yasnippet, plus a bunch of modes for syntax highlighting. If you’ve only tried cursory Emacs customisation in the past the results are a little alarming at first, but you’ll be back to coding (and saying “Ooh! Aah!”) in no time at all.

i use etags to generate a TAGS file that allows me to navigate through source code of c++ projects that i work on. the default name for the file that contains the tags is TAGS so everytime i had to type make TAGS in order to generate the tags file. i hate typing capital letters therefore i have been trying to change that to lower case for some time now finally i was able to do it today

put the following in your .emacs file

(setq tags-file-name “tags”)

that’s it !!!

You can find quite a few Emacs libraries on github these days. I only have one very small project there, wpmail, which I haven’t written about yet because I want to finish the Markdown support first… anyway: something I find really neat on github is the automatic display of the README file in the repository’s root directory, if it exists. Only, as we all know, writing READMEs is tedious and we’d rather spend our time programming. But wait: in the Emacs world, we’re actually writing a README for each project: the library headers. Their content and structure are rather clearly defined, and it’s expected for all Emacs libraries. So I had the idea of generating a nice, Markdown-formatted README.md for github from these headers.

I just pushed the first version of md-readme that does just that. The README that you see on the github page is auto-generated from md-readme.el, with lists, code-block and everything.

The conversion to Markdown is of course pretty simple, but even so it’s pretty cool to see how little code I had to write. Emacs provides everything out of the box. (with-temp-file "README.md" (do-it)) is just elegant.

Now, seeing that we have code that generates a nice README from our Lisp file, it’s natural to have it run automatically so we always have an up-to-date README. Here I was struggling for a while. I had lots of ideas, but none seemed to work out. My current solution is setting a per-directory local variable for each of your ELisp projects that triggers the conversion via an after-save-hook. Code is in the README. The problem with adding the after-save-hook to all modes is that it’s evaluated all the time, for each save. Kinda annoying, even if it’s just a single condition.

Does anyone have a better idea? Do it outside Emacs in a git pre-commit hook?

But even with the current solution it works, and that’s the important part. Please try it, and enjoy your new READMEs.

“At this point we have covered what might be called the conventional core of C.” K&R pp 34.

Yes, I’ve just finished chapter 1. Well, I’ve finished the easy stuff. There are harder programs suggested which I will do, but Kernigan & Ritchie assure me I have covered the conventional core. It’s taken me a while, I know.

I must say that in this first chapter I have really grown fond of emacs. I have found a few links which will be posted regarding emacs. In specific, the emacs-fu page which shows many tips & tricks on how to tweak your emacs to suit you best, as well as Peter Salzman’s GDP tutorial.

I need to finish the hallway before Thanksgiving, but I will be working on the afore mentioned ‘harder programs’ to truely complete chapter 1. And then from what I understand I will be going over the points covered in chapter 1 in greater depth.