Although I had a company issued Blackberry (7100t) several years ago, I've never owned a smart phone of my own. I've certainly watched the technology progress over the years, but for the last several of those years I've been content to own a generic 3g slider phone (Samsung A737) and just tethering it to my Nokia N800.

Recently, smartphones have seemingly gotten a lot more powerful and I decided it was time for me to get one. Having loved my N800, I certainly had my eyes on the N900, not only because it adds a phone feature, but maemo 5 looks fscking awesome. However, I did my due dilligence and researched the other options available, and here are my thoughts on what's out there right now:

• iPhone 3Gs: I've played with it several times at the Apple store, and held several owned by friends. It runs on fantastic hardware and even better core software. The iPhone is seriously stable and runs smoothly as far as I can tell. It only has one problem: Apple designed the software to be completely locked down. As a software developer (who wants to program for whatever phone he gets) I can't bring myself to become a slave to Apple, not being able to develop on anything but a mac, using a language that seemingly is only used to build Apple software, having to pay a large license fee to put applications on the only available method of distributing applications (THE app store), and to top all that off, I have absolutely no guarantee whatsoever that Apple will even accept my application, let alone in a timely fashion. No thanks.

• Nokia N900: Oh, this phone has everything I want. Everything the N800 had and more. Completely open-source, completely unlocked device, surrounded by a (small by comparison) community that wants me to hack this device. Yea, this is my kind of phone. The idealist in me knows that this is the best phone on the market right now, and if adopted en masse, would shake the telecom industry to its core. A powerful phone like this, giving me as much freedom as it does, has the potential to force the telecom providers to compete solely on terms of network quality as opposed to competing over who has the coolest (locked down) phone. However, like with Betamax, there's more to winning than just superior technology. Nokia just doesn't have that something. This phone will serve geeks and enthusiasts well, but it just doesn't have the character to be adopted widely, and as a developer, I'd like to see the programs I write, as well as the skills that I will develop, still have relevance several years from now.

• Android: Android is this happy medium between the two. The Android platform is open source. The phones... well, not so much. While they all run more or less the same open source android OS, they are still chained to the whims and pleasure of the manufacturer and telecom carrier, not the consumer. The recent Motorola Cliq is a perfect example of this. This is a new phone, having only been released since last November. But already the OS is quite outdated, running android 1.5, it's now three versions behind the latest that the Nexus One is running (2.1). I certainly understand that there are complications in upgrading the device, but it's the fact that Motorola/Tmobile has delivered a device that although is running an open source OS, is completely locked down disallowing the user to upgrade the phone himself. Ingenious hackers have rooted the device (without motorola's help mind you) but there is still trouble in installing new OS images. The Motorola Cliq is NOT an open source friendly phone and is defeinitly not the phone for me.

So a few weeks ago I was reading Android developer docs and was becoming really impressed with the platform. Even though it's all Java based, and not my beloved Python, at least it wasn't Objective C. And even though there are some closed source google APIs included, the great majority of android is open source. I was starting to the get feeling that this was a platform I could roll with. But the most modern phone available on a carrier I can afford (have you seen the prices for family plans on Verizon, sheesh) was the Motorola Cliq, and that phone deeply depresses me. So, did I want one of the older Android phones, the MyTouch or the G1? Hell no, I wanted something at least as powerful as the droid, if not as powerful as the N900 itself. Ah, but then all the rumors of the Nexus One starting cropping up all over the web.

• Nexus One: A brand new, modern android phone, more powerful than the droid, hell more powerful than the N900 (at least on paper), not running any proprietary Motorola firmware, made by google who has an interest in making this the flagship android offering and playing nicely with developers, they made it easy to unlock the bootlader (literally just reboot holding down the trackball and entering a special command).. the list goes on. This phone is still no N900, but this just might be the first mainstream, truley open-source phone, that has the gumption to compete directly with the iPhone.

So I bought one :)

Here's my initial impressions:

• Fedex is soo good at what they do. I set firefox to continuously reload http://www.google.com/phone during the Nexus One press launch, and as soon as the page went live I purchased the phone. Google paid the shipping and HTC sent it Fedex overnight. Less than 24 hours later, it was in my mailbox. Nice!

• It's going to take me a while to get used to the keyboard. I have zero experience with touchscreen keyboards without the aid of a stylus.

• Dictation works pretty well, kinda alleviates the problem above, although I probably would feel awkward using it in public.

• The software keys at the bottom of the phone are very finicky. Although having used the phone for a few hours now, I think I got the handle of them now.

• Navigation is fantastic. The GPS lockon was instantaneous, using dicatation to give the desired address worked flawlessly, the turn by turn speech is understandable, and the map displayed is updated quickly (even over EDGE) and looks great.

• Just got Sipdroid setup and I can make VoIP calls for practically nothing :) (I have only tested it on WiFi so far, don't have 3G yet)

• I can't connect to my home router that's only 8 feet away, even though it sees it, no idea why. I'm using WPA2 PSK AES, maybe it doesn't like AES? Can connect to the neighbors unprotected wifi ("linksys") no problem though ;)

• The web browser works great and is speedy even on EDGE. I think something was terribly wrong in the Edgadget browser test because when I tried the same test (on WiFi), I got the page to load up at the exact same time the iphone did in the video, and seriously, why wouldn't it? Both the iphone and the Nexus One use webkit.

I'll update this list if anything else hits me.

I want to keep track of how much gold and silver I've bought, when I bought it, and inevitably I'll still want to know how many green pieces of paper I could theoretically trade it all in for.

The easiest way to track all this information was to create a spreadsheet in OpenOffice.org's Calc. I created a sheet for gold purchases and another sheet for silver purchases. Everytime I make a purchase, I record the number of ounces, what form it is in (coins, bars, junk etc), who I bought it from, when I bought it, and the price I paid in FRNs (Federal Reserve Notes, aka green pieces of paper.) On another sheet I total the number of ounces I own and multiply it by the current spot price for the metal, which gives me the current price I could get if I sold it for FRNs. When tallying this total, I reference a special cell on the sheet, one that has the current spot price for gold, and another for silver.

But checking the spot price myself and manually updating those cells was just too tedious for my programmer's heart. I wanted OpenOffice.org to automatically retrieve this information for me. So, I started researching OpenOffice.org extensions (plugins).

Turns out, OpenOffice.org extensions can be written in my favorite programming language, Python (yea!), so I wrote the following extension a few weekends ago. It's on github and can be downloaded with git:

  git clone git://github.com/EnigmaCurry/SpotMetal.git

If you just want the pre-compiled extension, it can be downloaded here locally:

SpotMetal-0.1.oxt

You install it inside OpenOffice.org by going to Tools -> Extension Manager and clicking on Add and browsing to the SpotMetal-0.1.oxt file you downloaded or built yourself.

Once you have it installed, you now have a new Calc function available called SPOTMETAL which takes two arguments:

• metal - Which metal you want to look up. Can be one of "gold", "silver", "platinum", or "palladium"
• bidAsk - Whether you want the bid or the ask price. Can be either "bid" or "ask".

The price will automatically be refreshed every 5 minutes by default, but you can also force a refresh with the Calc function called SPOTMETALREFRESH.

Here's an example OpenOffice.org spreadhseet that shows how you might track your own precious metal investment portfolio. The big button labeled "Refresh Spot Price" does what it says it does, but requires a bit more boiler-plate code in order for it to actually display on screen. In OpenOffice.org, you can see another macro called doReCalculate:

• Tools->Macros->Organize Macros->OpenOffice.org Basic
• MetalTrackerExample.ods->Standard->SpotMetal->doReCalculate.

This extra macro is necessary to actually force the spreadsheet to request new data from the extension when you click the "Refresh Spot Price" button.

While this extension might be of use to you if you also invest in precious metals, I guess the main reason I posted this is because it took a good deal of time researching how to write a Python extension for OpenOffice.org. Check out the source code on github if you're looking to write your own extension, it's got it's own Makefile and hopefully it's documented well enough for it be useful for someone in the future.

I've just finished porting this entire site over to my new blog engine, Blogofile. Blogofile is something I've been working on for the last several months, and really it's been pretty much complete for the last two of those months; it turns out that transferring the 100+ posts that I've made on this blog since 2005, first using TikiWiki, then Wordpress (using a myriad of different plugins over the years) was a much larger task than writing Blogofile itself. Or, at least writing Blogofile was a lot more fun, which is why it probably took me so long to do the relatively mundane task of porting EnigmaCurry to the new platform.

Blogofile is best described as a Blog Compiler -- just as a programmer's compiler takes source code and spits out a running program, a blog compiler takes a special blog source code language and spits out raw HTML, the native format of all blogs everywhere. What this means is that any webserver can host the Blogofile based blog, without having to install any special software, not even Blogofile, it's just HTML. You can run Blogofile on any computer that has Python installed, upload the HTML it generates to your webserver, and your webserver remains lean and fast.

You can read more of the great features of Blogofile on it's own site.

One of the biggest motivators in my finishing up moving EnigmaCurry.com over to Blogofile is because, quite frankly, MySQL 5.x blows chunks. It consumes ridiculous amounts of RAM for my pitifully small wordpress database, and when it eventually overwhelms my VPS and forces a restart, the tables are corrupted, especially the mysql user table which requires running "mysqld --skip-grant-tables" in order to get running again just so I can get in to repair the damage. I've seen this happen on two different (but pretty much stock configured) Ubuntu 9.04 servers, so I know it's not an isolated case. I've pledged to myself to never use MySQL in future projects. Do yourself a favor:

sudo apt-get remove mysql-server-5.0

Please don't hesitate to let me know if you see something awry with the site, there's bound to still be a few things missing/corrupted from the transfer.

I'm hoping to change direction. I seem to always have a tune inside my head and it needs to get out!

I recently bought a new computer powerful enough to run some pretty amazing software synthesizers, so I've started composing some music. Here's a pretty basic one I wrote today:

It's pretty ambient. This is for two reasons:

1. I actually like ambient music, eg. Harold Budd or The Dead Texan.
2. It's got a low barrier to entry, nice long whole notes. :)

So I write them in Python :)

Jython allows me to interface with all the plethora of Java libraries that we use at work, and it lets me program in a language that not only I can tolerate, but one that I respect and love.

But even though these are one-off applications, they still need to be easy to use, and in some cases I won't even be the one running the application. I want these applications to just work damnit.

So, packaging my Jython application into a single executable jar file that contains all of the third party dependancies inside is my goal. I want to send the user the jar file, have them double click on it, and have it immediately start running. It can't get a whole lot easier than that.

The Jython wiki has a page about doing something along these lines. The recipe there called the Jar Method works quite well. The one drawback that it has is that all of the Java dependancies need to be exploded into the main jar root, which when you're dealing with dozens of jar dependancies, it can start to get tedious, messy, and in some cases will even violate the license of a particular library.

One-Jar is a special class loader that can load a jar file that is inside of another jar file, something that the regular class loader from Sun is incapable of doing. Using One-Jar lets my application reside inside of a jar file and contain all my dependancies as seperate jar files inside the main jar file.

I've created a sample project that shows how I normally create a new Jython project hosted inside a single jar file with One-Jar. You'll need the following tools to check out the project:

• A Java SDK (tested with OpenJDK 1.6)
• Apache Ant (tested with version 1.7)
• Git (to checkout the project)

Check out the project like so:

 git clone git://enigmacurry.com/single-jar-jython-example

Build the project:

cd single-jar-jython-example

ant

Run the example by double clicking it or via the command line:

 java -jar JythonExcelExample.jar

This is just a demonstration app, it doesn't do a whole lot, it outputs an excel file in the current directory listing some computer parts. The point of the application is to show how Jython can integrate with existing Java third-party libraries (in this case Apache POI.)

Instructions for basing your own application on this example are contained inside the README.txt file.

In Python, the usual way I explore a new library or mock up a new idea is to immediately start coding in Python's interactive interpreter (or REPL). This is often times more efficient than reading (let alone finding) the documentation for the library. I can quickly see if something is going to work before I code inside my larger application.

Java doesn't have an interactive interpreter.. but Jython does! However, setting up Jython, especially interfacing with an already large Java application, can be difficult. One such difficult situation I deal with at work is in Weblogic. With Weblogic, I deploy my application directly to a running Weblogic server, and I never get to see a console in this process, so how am I ever going to run a Jython interactive interpreter?

This morning I got bored and wrote up a quick solution: JythonShellServer. JythonShellServer embeds into any Java application and starts a Telnet server that serves up Jython interactive shells. You can push any Java object that you want to manipulate into Jython's local environment. Run "telnet localhost 7000" and you can use Python code to explore your entire application's running environment.

JythonShellServer works, but I only just wrote it this morning, so consider it alpha quality at the moment. Check out the project page on github.

A friend of mine and I like to show off to each other little Emacs tips and tricks we learn. Today, he introduced to me the very cool AutoComplete.el package. AutoComplete.el is intriguing to me because, unlike ropemacs mode which I've blogged about before, the completions AutoComplete.el provides are inline with your code in a dropdown box instead of in a seperate window (windows in Emacs are what most people call frames). However, AutoComplete is only a completion framework, it doesn't know anything about Python. Instead, it allows the user to plug into it, feeding it whatever sorts of intelligent completion you want, including Rope.

Setup

The two most important completions I want to integrate into it are Rope and yasnippet. AutoComplete can handle both of them nicely. You'll need to install the very latest development version (as of December '08) of Rope, Ropemacs and Ropemode:

sudo apt-get install mercurial
mkdir /tmp/rope && cd /tmp/rope
hg clone http://bitbucket.org/agr/rope
hg clone http://bitbucket.org/agr/ropemacs
hg clone http://bitbucket.org/agr/ropemode
sudo easy_install rope
ln -s ../ropemode/ropemode ropemacs/
sudo easy_install ropemacs

You'll also need to install Pymacs and Yasnippet if you haven't already:

mkdir -p ~/.emacs.d/vendor && cd ~/.emacs.d/vendor
wget http://pymacs.progiciels-bpi.ca/archives/Pymacs-0.23.tar.gz
tar xfv Pymacs-0.23.tar.gz
cd Pymacs-0.23
make
sudo easy_install .
cd ~/.emacs.d/vendor
wget http://yasnippet.googlecode.com/files/yasnippet-0.5.9.tar.bz2
tar xfv yasnippet-0.5.9.tar.bz2
cd ~/.emacs.d
ln -s vendor/yasnippet-0.5.9/snippets/ .

Make sure Pymacs and Yasnippet get into your load path, in your .emacs:

(add-to-list 'load-path "~/.emacs.d/vendor")
(progn (cd "~/.emacs.d/vendor")
       (normal-top-level-add-subdirs-to-load-path))

Install AutoComplete.el 0.1.0 (0.2.0 is now out, and is not compatible with this post, I'll try and update later):

cd ~/.emacs.d/vendor
wget http://www.emacswiki.org/emacs/?action=browse;id=auto-complete.el;raw=1;revision=5

Now to add some more elisp to your .emacs somewhere:

(require 'python)
(require 'auto-complete)
(require 'yasnippet)

(autoload 'python-mode "python-mode" "Python Mode." t)
(add-to-list 'auto-mode-alist '("\\.py\\'" . python-mode))
(add-to-list 'interpreter-mode-alist '("python" . python-mode))

;; Initialize Pymacs                                                                                           
(autoload 'pymacs-apply "pymacs")
(autoload 'pymacs-call "pymacs")
(autoload 'pymacs-eval "pymacs" nil t)
(autoload 'pymacs-exec "pymacs" nil t)
(autoload 'pymacs-load "pymacs" nil t)
;; Initialize Rope                                                                                             
(pymacs-load "ropemacs" "rope-")
(setq ropemacs-enable-autoimport t)

;; Initialize Yasnippet                                                                                        
;Don't map TAB to yasnippet                                                                                    
;In fact, set it to something we'll never use because                                                          
;we'll only ever trigger it indirectly.                                                                        
(setq yas/trigger-key (kbd "C-c <kp-multiply>"))
(yas/initialize)
(yas/load-directory "~/.emacs.d/snippets")



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                                         
;;; Auto-completion                                                                                            
;;;  Integrates:                                                                                               
;;;   1) Rope                                                                                                  
;;;   2) Yasnippet                                                                                             
;;;   all with AutoComplete.el                                                                                 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                                         
(defun prefix-list-elements (list prefix)
  (let (value)
    (nreverse
     (dolist (element list value)
      (setq value (cons (format "%s%s" prefix element) value))))))
(defvar ac-source-rope
  '((candidates
     . (lambda ()
         (prefix-list-elements (rope-completions) ac-target))))
  "Source for Rope")
(defun ac-python-find ()
  "Python `ac-find-function'."
  (require 'thingatpt)
  (let ((symbol (car-safe (bounds-of-thing-at-point 'symbol))))
    (if (null symbol)
        (if (string= "." (buffer-substring (- (point) 1) (point)))
            (point)
          nil)
      symbol)))
(defun ac-python-candidate ()
  "Python `ac-candidates-function'"
  (let (candidates)
    (dolist (source ac-sources)
      (if (symbolp source)
          (setq source (symbol-value source)))
      (let* ((ac-limit (or (cdr-safe (assq 'limit source)) ac-limit))
             (requires (cdr-safe (assq 'requires source)))
             cand)
        (if (or (null requires)
                (>= (length ac-target) requires))
            (setq cand
                  (delq nil
                        (mapcar (lambda (candidate)
                                  (propertize candidate 'source source))
                                (funcall (cdr (assq 'candidates source)))))))
        (if (and (> ac-limit 1)
                 (> (length cand) ac-limit))
            (setcdr (nthcdr (1- ac-limit) cand) nil))
        (setq candidates (append candidates cand))))
    (delete-dups candidates)))
(add-hook 'python-mode-hook
          (lambda ()
                 (auto-complete-mode 1)
                 (set (make-local-variable 'ac-sources)
                      (append ac-sources '(ac-source-rope) '(ac-source-yasnippet)))
                 (set (make-local-variable 'ac-find-function) 'ac-python-find)
                 (set (make-local-variable 'ac-candidate-function) 'ac-python-candidate)
                 (set (make-local-variable 'ac-auto-start) nil)))

;;Ryan's python specific tab completion                                                                        
(defun ryan-python-tab ()
  ; Try the following:                                                                                         
  ; 1) Do a yasnippet expansion                                                                                
  ; 2) Do a Rope code completion                                                                               
  ; 3) Do an indent                                                                                            
  (interactive)
  (if (eql (ac-start) 0)
      (indent-for-tab-command)))

(defadvice ac-start (before advice-turn-on-auto-start activate)
  (set (make-local-variable 'ac-auto-start) t))
(defadvice ac-cleanup (after advice-turn-off-auto-start activate)
  (set (make-local-variable 'ac-auto-start) nil))

(define-key python-mode-map "\t" 'ryan-python-tab)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                                         
;;; End Auto Completion                                                                                        
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Github

These changes are also applied to my Emacs environment on Github. I'm continuously trying to improve my emacs setup, so if you're reading this a few months/years after this post was made, you may want to check there for improvements.

Update Jan 30 2009: I made some modifications to the tab complete order, a regular indent is applied first before autocompletion. Autocompletion is also not applied unless you are at the end of a word. This is useful when you press Tab at the beginning of a line to indent/outdent.

Usage

Once you got everything setup, usage is real easy:

1. Open up a python (.py) file
2. Press TAB when you want to use code completion or to insert a snippet.

The first time you attempt to use code completion you'll be prompted to enter the root of your project directory.

Future

It wasn't too long ago when Python code completion inside Emacs was just a pipedream. So now that we have it, let's make some more pipedreams: I'd like to popup some nice contextual help for method arguments as well as python documentation for the current method/class being completed.

The possibilities are pretty much endless. I love Emacs.

On your linux desktop, open up your favorite terminal emulator. Enter this command:

tput colors

What number do you see? 8?

8 stinking colors. That's what my terminal is capable of displaying. It's 2009 folks, and my terminal can only display 8 stinking colors.

Load up emacs in the terminal (emacs -nw) and see for yourselves, M-x list-colors-display shows you all of the different colors your terminal can display.

Pitiful.

Ok, so how to improve this? On ubuntu:

sudo apt-get install ncurses-term

and stick the following in your ~/.bashrc and/or ~/.bash_profile:

export TERM=xterm-256color

Ahhhhh...

I've been learning and playing around with git recently, so I've decided to post my entire .emacs config on github.

Here are the latest instructions for emulating my Emacs environment on Ubuntu 8.10:

• Enable the universe repository
• sudo apt-get update
• sudo apt-get install emacs-snapshot git-core automake libgconf2-dev texinfo python-setuptools
• cd ~
• git clone git://github.com/EnigmaCurry/emacs .emacs.d
• cd ~/.emacs.d
• git submodule init
• git submodule update
• cd ~/.emacs.d/vendor
• ./vendor-compile.sh
• sudo easy_install "http://downloads.sourceforge.net/rope/rope-0.9.1.tar.gz?modtime=1225268769&big_mirror=0"
• sudo easy_install "http://downloads.sourceforge.net/rope/ropemacs-0.6.tar.gz?modtime=1223039342&big_mirror=0"

I've done some reorganization of the directory structure:

1. There actually is no ~/.emacs file anymore, having realized that Emacs looks for ~/.emacs.d/init.el. Convenient!
2. All third party packages are now installed in ~/.emacs.d/vendor. This was a great tip I saw in the Emacs Peepcode screencast. (it's $9, but worth it).
3. I've taken the suggestion that greg made in the comments to use submodules for some of the vendor packages. The vendor-compile.sh script does the compiling of those packages.
4. All private code goes in ~/.emacs.private. This lets me keep passwords and such outside of the main git repository and allows me to publish my config more easily. Before I did this I had to spend time sanitizing the code before each release.

I have appreciated your many encouraging Emails and comments. :)

There are several different strategies to extend Emacs. I'll list a few of them in order of hardest to easiest (and arguably from worst to best):

• Write your own major or minor mode from scratch.
• Edit someone else's mode (and hopefully submit a patch.)
• Write an Advice function.
• Write a Mode Hook.

Where Advice fits in

(Don't worry, I get into the meat of it in the next section. For the impatient, skip down.)

Mode hooks are almost always the easiest and best way to extend a particular mode, but they are also limited in scope. The author of the mode created these hooks specifically to allow you to extend his mode, and are therefore the best maintainable way to extend a mode (the author is unlikely to remove those hooks in future versions). However, if the author didn't anticipate certain functionality and there is no appropriate hook provided, you'll have to come up with a different solution.

At this point, obviously, you could just write your own mode -- but what a pain that would be if you already have something that's close to what you want. So why not just edit that particular mode to suit your needs (perhaps creating that missing mode hook yourself?) This approach is probably the best one especially if the feature you want is something other people would benefit from. You can submit your changes as a patch to the original author and (if he accepts them) your changes go into the next release.

But what if for some reason your changes are not acceptable to the author? You can still use your changes on your local machine, but every time a new version of the original mode comes out you'll have to merge your changes back into that new version. At this point you've successfully "forked" the project, but that's usually a bad thing in the long run.

One other option exists to Emacs developers: advice. Advice allows you to wrap existing functions with your own functions. This allows some types of behavior to be modified without even having to change the original file at all. You can keep your changes completely separated in your own customized files. This gives you the benefit of inheriting new versions of the mode by simply downloading the new version and putting it in your load path. In most cases your advice function will continue to work on the new version and you didn't have to merge any changes at all. If significant changes have been made you may need to modify your advice function, or create a new one, but you still won't need to merge any changes.

Continue reading and I'll give you a real-world example of how I've used advice, but I want to first re-iterate the proper use cases of advice:

• If you can use the mode hooks provided by the author, use them instead.
• If there is a bug in the original mode, just fix it in the original code and submit a patch.
• If there is a new feature you want, add it to the original mode and submit a patch. Talk to the author, work with him, and it will most likely end up in the next release.
• If you are an Emacs developer, working on Emacs itself, or one of the modes shipped with Emacs, never use advice. It's the least maintainable method of extending Emacs with the exception of a pure fork, and since you're working on Emacs itself, it's not a fork.
• If your patch is not accepted, or you know that what you want is fringe enough or hackish enough to not warrant submitting a patch, only then should you use advice or fork the project.

Using Advice

Alright, onward to the example I promised. I really liked the tip over at Minor Emacs Wizardry on combining EasyPG with Org mode -- it's an awesome way to keep a lot of things in an organized and encrypted way -- I use it all the time now.

My main machine is running Ubuntu and it's default GnuPG agent is Seahorse. It's actually a pretty nice manager for encryption (SSH and PGP) and is completely integrated with the Gnome desktop. The one problem I have with it is that I use Multi-TTY Emacs and when I'm using a terminal on a remote connection and I try and open an encrypted file, Seahorse pops up on the desktop instead of prompting me for the passphrase on my remote connection. In the past I've had to fire up VNC to my desktop just so that I could enter the password; damn inconvenient.

I could setup something like keychain, it's a real nice GPG agent that works equally well on the desktop as on the console. I've used it in the past and liked it. Seahorse requires no setup though, it comes with Ubuntu by default, and like I said, I really quite like it.

So, when I'm on my remote connection and Seahorse doesn't have my password cached, I'd like to be able to bypass the GPG agent entirely and just enter my password. EasyPG doesn't appear to have this functionality so I added it with advice:

(defadvice epg--start (around advice-epg-disable-agent disable)
  "Make epg--start not able to find a gpg-agent"
  (let ((agent (getenv "GPG_AGENT_INFO")))
    (setenv "GPG_AGENT_INFO" nil)
    ad-do-it
    (setenv "GPG_AGENT_INFO" agent)))

That little bit of code wraps the main EasyPG function that will ask for a password. It temporarily removes the environment variable that EasyPG looks for to connect to the GPG agent, and therefore EasyPG asks the user for the password as if there were no agent running.

Let's analyze the different parts of that advice function:

• All advice starts with a "defadvice" definition.
• "epg--start" is the name of the original function I'm wrapping.
• "around" is indicating that I'm specifying code to run both before and after the function I'm wrapping (other options would include "before" and "after")
• The word "disable" means that the advice is initially turned off (you could say "activate" to have it immediately turned on, read the manual for more options here)
• Starting with the "let" function is the body of my custom function
• The "ad-do-it" line in the middle is the point in the function where the original function gets executed. (This would not be used in a "before" or "after" style function.)

One more important thing to understand about advising a function is that you aren't creating a new function with a new name. You are adding data to the existing function definition. Wherever the original function gets called, your advice will be called along with it. However, advice does offer the convenience of turning on or off your changes. For the above example I added two user commands to turn on and off the GPG agent (bound to M-x epg-disable-agent and M-x epg-enable-agent):

(defun epg-disable-agent ()
  "Make EasyPG bypass any gpg-agent"
  (interactive)
  (ad-enable-advice 'epg--start 'around 'advice-epg-disable-agent)
  (ad-activate 'epg--start)
  (message "EasyPG gpg-agent bypassed"))

(defun epg-enable-agent ()
  "Make EasyPG use a gpg-agent after having been disabled with epg-disable-agent"
  (interactive)
  (ad-disable-advice 'epg--start 'around 'advice-epg-disable-agent)
  (ad-activate 'epg--start)
  (message "EasyPG gpg-agent re-enabled"))

These functions use the (ad-enable-advice) and (ad-disable-advice) functions respectively. Whenever advice is switched on or off, a call to (ad-activate) must also be made on the function to update it.

The manual goes into more depth about how to advice functions. Hopefully you got something useful out of this, I sure learned a lot in writing it.