planet.jabber.org

So Psi moves along sluggishly as usual.  0.13 was not released by Christmas.  There were reasonable explanations for that.  Despite this, I think 2009 will be a good year for Psi, and possibly its best year yet.

I suppose I can’t put words in anyone else’s mouth, but I have high hopes we’ll see Kev and Remko return to regular development after their XMPP book, and that Misha will finally be contributing Yandex stuff back.  As for myself, these past few months stand as a record for the longest time Barracuda let me focus on Psi issues (which, being all Jingle stuff targetting Psi 0.14 or later, is easy to miss).

So, post-book and post-0.13, I predict a sudden surge of visible development, and more attention to submitted patches.

Despite the perception that Psi lags “behind” other client projects, keep in mind we have a number of significant features that have already been started (with major progress) and just need to be finished:

• Jingle audio and video
• Whiteboarding
• WebKit chat windows
• Revamped message history interface
• Revamped roster
• Plugins
• Bonjour chat
• Automatic updates
• Certificate/SmartCard authentication
• SSO
• XMPP URIs

Feel free to add more to this list.  I often forget what’s on the back burner.

Do note that the above is not a list of priority features, just a list of features that are partially complete for one reason or another.  The priorities going forward are a topic of a different message.  I just wanted to show that when you count all of this unfinished stuff, Psi is farther along than it appears to be.  The project has been around for so many years, and yet there is still so much to do.

Here’s to Psi in 2009!  I look forward to a great year with all of you.

Our apologies for the late notice, but the XSF will hold its sixth XMPP Summit in Brussels the same weekend as FOSDEM 2009. The basic schedule is as follows:

• Friday, February 6: Jingle hackfest for developers who are working on voice and video applications
• Saturday, February 7: XMPP devroom at FOSDEM featuring tutorials, presentations, demos, and lightning talks
• Sunday, February 8: A “free day” at FOSDEM to attend non-XMPP sessions
• Monday, February 9: The XMPP Summit itself, with in-depth technical discussions for active technical contributors to the XMPP community

For all the details, visit http://xmpp.org/summit/summit6.shtml and join the summit@xmpp.org discussion list.

See you in Brussels!

–Peter Saint-Andre

My Emacs talk has been rubbing off on Dustin; he has been experimenting with his own Emacs setup for the last few days. He sent me this screenshot of the Emacs XMPP client, and I just had to share it. It's a little crude looking, but I had no idea that the Emacs client would have avatar support.

Over the holidays I have been doing a technical review of the upcoming XMPP book "XMPP: The Definitive Guide". It's currently available as a rough cut from O'Reilly and I expect the final version is getting near. I still have a bit to go, but so far I think it is fantastic.

This will be a great introduction and reference to a lot of the most useful bits of the XMPP protocol stack. It becomes clear when reading the book just how much care and thought has gone into the design of these protocols.

Specifically the chapters on instant messaging and XMPP pubsub have stood out to me.

The downside of all this is that no one warned me how much work a book review is, or perhaps I just want to be thorough. My ratio of lines of comment to pages is currently hovering around 3 to 1. It is mostly small stuff because the text is already in great shape.

Peter, Kevin, and Remko have done a wonderful job, and their hard work really shows.

It has happened recently that we have tried very hard to fix a few annoying problems on one of the Tigase installations. Whatever we did, however the problems still existed after uploading a new version and the server restart. It worked fine in our development environment and it just didn't on the target system.

It turned out that due to a specific environment settings on the target system an old version of the Tigase server was always started regardless updates we were uploading. When I finally started looking at the installation the first indication that something is wrong was lack of any log files in place where I expected them.

The best way to check all the environment settings used to start the Tigase server is to use..... check command line parameter:

./scripts/tigase.sh check etc/tigase.conf Checking arguments to Tigase TIGASE_HOME = . TIGASE_JAR = ./jars/tigase-server.jar TIGASE_PARAMS = etc/tigase.conf TIGASE_CONFIG =  etc/tigase.xml TIGASE_RUN = tigase.server.XMPPServer -c etc/tigase.xml --property-file etc/init.properties TIGASE_PID = ./logs/tigase.pid TIGASE_OPTIONS = --property-file etc/init.properties JAVA_OPTIONS = -Dfile.encoding=UTF-8 -Dsun.jnu.encoding=UTF-8 \ -Djdbc.drivers=com.mysql.jdbc.Driver:org.postgresql.Driver \ -server -Xms100M -Xmx200M -XX:PermSize=32m -XX:MaxPermSize=256m JAVA =  /System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home/bin/java JAVA_CMD = CLASSPATH = ./jars/tigase-server.jar:./libs/jdbc-mysql.jar:./libs/jdbc-postgresql.jar:\ ./libs/tigase-extras.jar:./libs/tigase-muc.jar:./libs/tigase-pubsub.jar:\ ./libs/tigase-utils.jar:./libs/tigase-xmltools.jar TIGASE_CMD = /System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home/bin/java \ -Dfile.encoding=UTF-8 -Dsun.jnu.encoding=UTF-8 \ -Djdbc.drivers=com.mysql.jdbc.Driver:org.postgresql.Driver \ -server -Xms100M -Xmx200M -XX:PermSize=32m -XX:MaxPermSize=256m \ -cp ./jars/tigase-server.jar:./libs/jdbc-mysql.jar:./libs/jdbc-postgresql.jar:\ ./libs/tigase-extras.jar:./libs/tigase-muc.jar:./libs/tigase-pubsub.jar:\ ./libs/tigase-utils.jar:./libs/tigase-xmltools.jar tigase.server.XMPPServer \ -c etc/tigase.xml --property-file etc/init.properties TIGASE_CONSOLE_LOG = ./logs/tigase-console.log

In our case TIGASE_HOME was set to a fixed location pointing to an old version of the server files. The quick check command may be a real time saver.

read more

Okay, I know I’m probably just repeating what everyone else is probably saying, but consider this:

· Could the same problem happen with OMB? (Yes - but only because it’s a monoculture, there’s only Laconi.ca. It’s less likely to happen, however, because it’d involve more effort, since it’s federated at least)

· Could the same problem happen with XMPP? (No - the XMPP network contains lots of different implementations, so a security flaw in one won’t affect everyone)

That there was a serious breach of security in Twitter is indisputable. That there’ll be others is likely. It’s also pretty likely that something like this will happen to Laconi.ca - sadly, “many eyes” don’t really help security all that much - but if more OMB implementations appear, this window of opportunity will vanish. It’ll never happen on the same scale with XMPP - no single vendor has the market, there is federation without monoculture.

So, if you’re going to trust your public image to a short public broadcast messaging service (or µblogging system), which one are you going to pick?

Once upon a time I was an avid Perl hacker, but at some point I got fed up with it and switched over to Python. I've spent a lot of time with Python, and it's my standard choice for writing new code unless another tool offers a big advantage to the problem at hand. Lately I've been doing quite a bit of hacking in Erlang and playing a bit with Lisp. One thing is for sure, I sure miss the brevity of Python.

I think Perl is too terse; all the symbols so close together start to impact readability. Erlang and Lisp both seem quite verbose. Perhaps this is a direct result of both languages lack of namespaces.

Namespaces

In Erlang, code lives in a module, but there are no sub-modules. Sub-modules end up getting named like 'module_foo' and 'module_bar'. This makes for pretty long lines when you need to string together several operations from different modules.

In Lisp (or at least in Emacs Lisp which is the dialect I've been working in) there aren't any namespaces at all, which makes it quite similar to Erlang, just with no special symbols.

In Python, I can just import the sub-modules directly, and get rid of lots of namespace, resulting in a lot less typing and no real loss of clarity.

Data Structures

The other main factor contributing to code brevity is good support for data structures. Lisp and Erlang have excellent support for lists, but they are more clumsy with hash tables. (make-hash-table) (or even (makehash)) is a lot more work than {}. dict:fetch(Key, Dict) is a lot more than dict[key].

Python, Ruby, Perl, and many other languages have first class support for these data structures and that goes a lot way to making the shorter and easier to write. They feel bolted on in Erlang and Lisp.

Worth the Trade-offs

Even though they are more verbose, Lisp and Erlang are worth the trade-offs in many cases. Nothing else has a concurrency model like Erlang, and the power of code-as-data is immense.

If you're an Erlang or Lisp hacker, I'd love to hear your thoughts on these issues. I'm still a newcomer in these lands and have much to learn.

This year I think I will learn me a Haskell for great good. I've heard a lot of great things about it, but have yet to dive in.

The Tigase server is very extensible through the well defined API. You can easily attach your code to any part of the server and load it at the startup time. It is quite simple to connect the Tigase to any database, add own components, plugins, packets filters, resource monitors and so on.

There are, however at least two disadvantages of this kind of extensibility. You have to write Java code and the code can not be reloaded at run-time. So basically you have to restart the server to apply your changes.

Installing Groovy script

What about a code in a scripting language which could be reloaded/added/removed at runtime without affecting normal work of the server? Which scripting language? Ideally any, ideally your preferred language. How? Of course using ad-hoc commands.

This is possible now. You can create your scripts in almost any language and load the script at runtime to the server to do some work for you. The Tigase server supports scripting through JSR-223 API in Java6. Maybe it doesn't make sense to use some of the supported languages like AWK for example in the Tigase server. Nevertheless I have learned already that users' use cases go far beyond my expectations. Therefore there are virtually no restrictions on the language you choose. Just put all required JAR files in the Tigase libs/ directory and the language is available to you.

read more

As promised, here is a short roundup of what proved helpful to me when we wrote our own mod_roster. I think this post may develop a bit over time, but now is just a quick reference of what to look at when you try to write your own mod_roster.

But first of all, why would you ever want to write your own mod_roster for ejabberd? Here is why:
We have a massive database of users, user information and relationship status already, we store this in postgresql and are quite happy about that state. When we started to build ESL Wire around an XMPP-Server (first OpenFire, now ejabberd) we were quickly facing the problem of having two databases that need to be kept in sync, but basically hold the same data. Since syncronization of _the same data_ is generally a bad idea and most of the time leads to inconsistencies we had to think up something different. Since we already planned of “opening” our infrastructure a bit, to make it easier to scale to different countries, users and customers, we decided to have a field-test with the jabber-server. By now we are talking to the ESL database using a webservice and parsing it’s JSON responses. All data is being kept in one place and we no longer have any inconsitencies. So basically what we have now is a mod_roster_json…of course this brings other issues to the table, but hey, let’s take it step by step!

So, what is important information?

Read the Jabber RFC and escpecially focus on all it’s “exceptions from the rule”, read up on gateway-interaction and be sure you know how the subscription states in jabber work.

* RFC3921

Then, look into the hooks ejabberd provides and what the functions that handle the hook need to return, this caused me a lot of headache, since I found this quite late…after a lot of reverse engineering other “mod_rosters”.

* Events and Hooks

Relevant hooks for mod_roster are:

remove_user(User, Server) -> ok
resend_subscription_requests_hook(Acc, User, Server) -> [Packet]
roster_get(Acc, {User, Server}) -> [RosterItem]
roster_get_jid_info(Acc, User, Server, JID) -> {Subscription, Groups}
roster_get_subscription_lists(Acc, User, Server) -> {[FromSubscription], [ToSubscription]}
roster_in_subscription(Acc, User, Server, JID, SubscriptionType, Reason) -> bool()
roster_out_subscription(Acc, User, Server, JID, SubscriptionType, Reason) -> bool()
roster_process_item(RosterItem, Server) -> RosterItem

If you want to implement Nested Roster Groups, you will need this as well:

privacy_iq_get(Acc, From, To, IQ) -> {result, Packet} | {error, Error}

In this context the return values mean this (in examples):

ok = ok
Error = ?STANZA_ERROR/3
[Packet] = {xmlelement, …}
[RosterItem] = #roster
Subscription = none | from | to | both | remove
Groups = [string()]
bool() = true | false

After this, implement the functions as wanted above, set the debug level to 5 in ejabberd.cfg
and put this everywhere you may need to see the current state of data:

?DEBUG("MY_MOD_ROSTER: DATA AT THIS POINT IS: ~p~n", [Data])

Now walk through your code step-by-step and have a look at the original mod_roster and/or
mod_roster_odbc to see what the hooks are supposed to do (will describe this here later).

* mod_roster.erl
* mod_roster_odbc.erl

Comparing these two should give you a good idea of what the functions are supposed to do and how you should handle the incoming data to get to what you need to return to satisfy the hook. Once I have a bit more time, I will describe in depth what the hooks are supposed to do.

Oh, and one more thing:

If you have “slow” transactions on where you store your data (webservice, for example) be sure to play around with the queing setting of your module, since this can lead to some strange results when you just changed a rosteritem but another thread was too fast and fetched the old one again. Do this by playing around whith this line:

IQDisc = gen_mod:get_opt(iqdisc, Opts, one_queue),

See possible values here:

* no_queue: no thread is created to run the handler
* one_queue: one thread is dedicated to run the handler
* {queues, N}: N threads are created to run the handler
* parallel: one thread is created for each IQ received

Planet Erlang is fastly becoming a large index for Erlang projects resources, including ejabberd.

Since its relaunch, Planet Erlang is now indexing content from tens of Erlang related blogs. Thank to its search engine, you can now find many blog posts and articles on lots of different Erlang topic. ejabberd is one of the most covered topic there.

You should have a look and try searching for ejabberd in the search engine (search field on the right).

The list of resources is growing every day as we are adding even more older resources.

Your comments and feature requests are welcome !

Few days ago I've found on Launchpad an interesting project by Thomas Hervé, the twisted interface to OTP, which allows to connect to erlang nodes using Twisted Matrix. The idea is incredibily powerful because it allows to easily build mixed-distributed applications using both erlang and python/twisted where they are best. So I gave it a try with ejabberd which has hooks for adding callbacks to its internal components (i.e. it's possible to intercept and modify packets). Unfortunately I've discovered that the present implementation of ejabberd hooks allows to connect only callbacks from the same node of ejabberd, i.e. as an extension module, but ejabberd folks have been incredibily quick in releasing a patch which allows distributed hooks, by adding the "CallNode" atom as parameter. The patch may be not stable yet, but it works perfectly with the last release of ejabberd (2.0.2), and here is an example of a twisted node which intercepts and logs all packets sent and received by any user (here is the full code, change the node names accordingly to your setup).

It works very simply. The hooks are written as methods of a regular python class with the "remote_" prefix:

class UserMonitor(object):
    
    def remote_receive_packet(self, jid, frm, to, packet):
        print ">>",  to_domish(packet).toXml()
    
    def remote_send_packet(self, frm, to, packet):
        print "<<",  to_domish(packet).toXml()

which is published by using a PersistentPortMapper:

nodeName = buildNodeName("uccaro@olindo.bluendo.priv")
epmd = PersistentPortMapperFactory(nodeName, cookie, "olindo.bluendo.priv")
epmd.publish(proxy = UserMonitor())

After this it's possible to call the methods proxy:receive_packtes and proxy:send_packet from any erlang node.

Then we register with ejabberd using a second node which calls the register methods, using the ejabberd api:

@defer.inlineCallbacks
def register_hook(epmd):
    # connect to the ejabberd node
    inst = yield epmd.connectToNode("ejabberd")
   
    # register hooks
    r = yield inst.factory.callRemote(
            inst,
            "ejabberd_hooks",
            "add_dist",
            Atom("user_receive_packet"), # hook name
            "olindo.bluendo.priv", # virtual host
            Atom("uccaro@olindo.bluendo.priv"), # hook node
            Atom("proxy"), # hook module
            Atom("receive_packet"), # hook method
            10
    )

And bingo, after this ejabberd happily starts calling our hooks!

As bonus in the code you find also a function which translates from the ejabberd xml representation to twisted domish nodes, which is far more usable.

XMPP Open Day is starting to shape up, but it still needs you help. We currently have 5 presenters, 6 talks, and 2 volunteer moderators. This is a great start, but we definitely need some more people to give talks or lead panels.

Please sign up at the wiki page or e-mail me if you're thinking you might want to participate.

During the holiday downtime, I decided to spend a little time improving my most some tools, specifically Emacs. While I was experimenting and tuning I realized that I really love Emacs, and I thought I'd share some of my favorite things about it.

Awesome daemon support

Once you start having a bunch of extra modules and customizations, Emacs beings to take a while to boot up. Fortunately we can just fire up an Emacs server inside a running session, and then connect to it via emacsclient.

In Emacs 23 (not yet released, but very usable) the emacsclient can even create new graphical (X or Cocoa) or text frames. This means that with EDITOR set to emacsclient -t it works just like a normal console Emacs would, except that it starts instantly and has access to all my already open buffers.

I used to use Vim at the command line because it loaded much faster than Emacs, but now I can finally drop that habit.

Interactively Do Things

ido brings Quicksilver and Spotlight type search to Emacs. It shows me possible fuzzy completions for what I'm looking for whenever I look for files or want to change buffers. Using ido has really increased my ability to get around in all my projects quickly.

nxml Mode

The nxml mode is an amazing thing. It validates the XML document live and tells you exactly whats wrong. Just like a spell checker from a modern word processor, it underlines the offending characters in red. Moving the cursor over them tells you exactly what's wrong.

I use it for HTML, XSLT, and any other XML markup I'm working on, and I never have to worry if it's correct.

Yet Another Snippet

yasnippet bring TextMate style snippets to Emacs. Now, snippets are nothing new for Emacs; we've had skeleton mode and similar things for a long time. yasnippet is just a lot easier.

My main use of yasnippet is to insert things like doctypes and other long strings that have some information that I must complete.

dabbrev

dabbrev is on by default in all the Emacs that I've run into, and it allows you to dynamically auto-complete anything based on the words it finds in your open buffers. Invoking it multiple times will complete longer and longer parts.

Just like everything with Emacs, it takes a good idea (text completion) and makes it extremely general. It works great on code, blog posts, and anything else I happen to be writing.

Find Tag (M-.)

Shortly after I started working with Monty on the Xiph.org codecs (Ogg, Vorbis, Theora) I noticed that he was using his editor a level far beyond what I was used to. The best thing I saw him do was find-tag which jumps to the function definition of the function name under your cursor. Using that, Monty could surf around the code base at blinding speed.

find-tag uses information in special tag files to implement this. Emacs can also do many other things with tags like project lists and auto-completion.

Flyspell

Flyspell brings word processor style spell checking into Emacs. Just like nxml mode's validation, Flyspell checks the spelling of words live, and gives visual indications where things have gone wrong.

Flyspell is also well supported in other modes, so that it knows which parts to check and which parts to skip. It's not perfect, but it is extremely useful.

Theming

A lot of people complain that Emacs is ugly, and the default configuration is certainly not going to win any awards. I will say though that Emacs is extremely well though out from a usability standpoint, and it mostly stays out of the way as much as possible. It is nice to get color syntax highlighting though, and color-theme does just that.

My personal favorite is color-theme-dark-laptop, which is somewhat similar to TextMate's Twilight theme.

Help In All Forms

Last, but absolutely not least, is the help system. Emacs has the best help system I have ever seen.

First, you can get help in any number of ways:

• Use the interactive tutorial (C-h t)
• Read the manual (C-h r)
• Read various other manuals (usually I'm after the Emacs Lisp manual and tutorial) (C-h i)
• Look up what keys do what in the current buffer (C-h b)
• Look up what some key does by pressing the key (C-h k)
• Look up the name of a function (C-h f)
• Look up the name of a variable (C-h v)
• Look up functions about some topic (C-h a)

Not only can you find all this information easily, but if you have the source code package installed, it will link you directly to the implementation. This means if I am looking up information about a particular Emacs function, within a few key presses I'm staring at the actual function.

Emacs is probably the only system for which I don't use Google as the first place for answers to my questions. Nearly everything is a few key presses away, even if you have no idea what you are looking for.

Emacs Rocks

I still have tons to learn about Emacs, but it already fits like a glove. Did I mention that it works the same whether I'm on OS X or Linux or in a terminal or the windowing system?

For those of you who also use Emacs, I'd love to hear about your favorite things.

Welcome to the fourth roundup of XMPP activity worldwide. This report is authored by Nicolas Vérité, Laurent Lathieyre and Jack Moffitt. This is a very long article since we had a lot of activity these weeks.

Your contributions are welcome for future roundups.

Software Releases

In this edition of the XMPP Roundup, we have a lot of software releases: clients, servers, and tools.

Gajim 0.12

Astérix aka Yann Leboulanger has announced on his blog the release of Gajim 0.12. The full changelog since 0.11.4 is loaded with new features: mood, activity, nickname and tunes, encrypted sessions, Kerberos, file transfer over multi-user chat, lots of UI improvements (chat and preference windows, drag’n drop, single window mode, etc.), LaTeX support, and many more.

Tigase Server 4.1

Tigase Server version 4.1 has been released.  New features include virtual hosting, server monitoring, and virtual components.

BuddyMob

Laurent Lathieyre of Ubikod, pointed to BuddyMob, an Android application in private beta now, designed and developed by Ubikod for Kiboo.net, a Belgian company. BuddyMob is offering IM, social networking, feeds and geolocation… and it is all based on XMPP.

Ya Online Mobile

Yandex, the giant Russian search engine and web portal, has launched the mobile version (Symbian S60) of its Ya Online client, based on its Jabber/XMPP service.

Buddycloud

Buddycloud is a mobile application for Symbian S60, built on XMPP, offering status and location tracking services as well as chat.

Lampiro

Lampiro, is a mobile open source (GPL licensed) XMPP client developed by Bluendo. It is written in J2ME, and supports compression, TLS, group chats, gateways, data forms and touch screens.

Prosody

Matthew Wild announced on JDev mailing-list Prosody 0.1.0 (and 0.2.0 followed in less than a month), a new XMPP server, written in Lua, under the GPL license. It aims to be simple, light, and flexible.

Sleek Migrate

Sleek Migrate is a server migration tool announced by Kevin Smith, released under GPL license, based on the SleekXMPP library written in Python by Nathan Fritz.

Web-Based JavaScript XMPP Clients

We have a bunch of Web-based JavaScript XMPP clients:

• Nounours is based on ExtJS and JSJaC using BOSH, released under the GPL license
• iJab is using GWT and JSJaC, released under the GPL license
• TrophyIM is based on the Strophe library, released under the MIT license

Lime Wire 5.0 alpha

Lime Wire, the open source P2P software based on the Gnutella network, integrates Jabber in its 5.0 alpha version.

Web-based Services

Fire Eagle

Seth Fitzsimmons announced an XMPP pubsub interface to Yahoo’s FireEagle.

Remindr

Remindr sends you reminders via mail, phone or Jabber.

Chatterous

Chatterous lets you join multi user chats via your web browser, IM client, phone, or e-mail.

Other News

Outside of the software releases scope, we have other news:

Tigase Server virtual hosting

Above we mentioned the new virtual hosting support in Tigase Server. Artur has also made it configurable though the Psi XMPP client, with the help of ad-hoc commands.

Psi

With 1,500 downloads per day and 2.4 million downloads overall, the open source Psi XMPP client has made a long road since its beginning.

SAPO Codebits

Jack Moffitt’s talk (51 minutes) at SAPO Codebits is online, both the video and the slides.

FLOSS Weekly

Peter Saint-Andre gave an interview to FLOSS Weekly:, the audio is available or as an mp3 for download (33 MB, 1h12).

On the Specifications Front

The Jingle XEPs for multimedia sessions like voice and video, have entered a LAST CALL:

• XEP-0166: Jingle
• XEP-0167: Jingle RTP Sessions
• XEP-0176: Jingle ICE-UDP Transport Method
• XEP-0177: Jingle Raw UDP Transport Method

As with all Last Calls, please consider the following questions and send your feedback to the standards@xmpp.org discussion list:

1. Is this specification needed to fill gaps in the XMPP protocol stack or to clarify an existing protocol?
2. Does the specification solve the problem stated in the introduction and requirements?
3. Do you plan to implement this specification in your code? If not, why not?
4. Do you have any security concerns related to this specification?
5. Is the specification accurate and clearly written?

Your feedback is appreciated!

Some extensions aka ProtoXEPs have come in:

• Message Mine-ing: In servers that deliver messages sent to the bare JID to all resources, the resource that claims a conversation notifies all of the user’s other resources of that claim.

A few XEPs have entered Final status:

• XEP-0174: Serverless Messaging: Communicate over local or wide-area networks using the principles of zero-configuration networking and without the need for servers.
• XEP-0085: Chat State Notifications: Communicate the status of a user in a chat session - enaged, composing, gone, etc.
• XEP-0012: Last Activity: Communicate information about the last activity of someone.

XMPP: The Definitive Guide - Rough Cuts edition

Peter Saint-Andre, Remko Tronçon and Kevin Smith are writing a book on XMPP, for O’Reilly. The rough cuts are available online.

Conclusion

The XSF and XMPP community have been quite busy during the final weeks of 2008.  We wish to thank everyone for their efforts, advice, and participation in 2008, and we wish all a happy 2009 filled with similar successes.

I recently switched this blog over to Jekyll. Jekyll is a static blog generator that can be used to manage a blog from source control instead of from a silly Web app. In my case, this blog lives in Git and whenever I push new commits it regenerates the site.

Today I spent a little time automating some common actions in Emacs for working with Jekyll blogs. You can find jekyll.el in my Jekyll branch on GitHub.

Here's what it does:

• C-c b n - Create a new draft post.
• C-c b P - Publish a draft.
• C-c b d - List all drafts.
• C-c b p - List all posts.

I'm quite happy with it, and it has been fun exploring Emacs Lisp.

I like to keep a daily journal of what I'm working on so that I can look back and see what I was up to yesterday or a week ago. I sometimes shift context so often during a day that I completely forget what I was previously doing. I used to do this manually in a plain text file, but now I've automated it using Emacs OrgMode.

From anywhere in Emacs, I just hit C-c j and it opens up my journal, creates a new entry if today's entry doesn't already exist, and let's me start typing. It also narrows the buffer in Emacs so that I only see today's entry when I'm journaling.

It might be nice to extend this similarly to my Emacs GTD capture system. I could bind a system wide hot key to open a new frame with the current journal entry; then I could get to my journal easily from anywhere.

Here's the code for those who are interested.

(defvar org-journal-file "~/Documents/org/journal.org" "Path to OrgMode journal file.") (defvar org-journal-date-format "%Y-%m-%d" "Date format string for journal headings.") (defun org-journal-entry () "Create a new diary entry for today or append to an existing one." (interactive) (switch-to-buffer (find-file org-journal-file)) (widen) (let ((today (format-time-string org-journal-date-format))) (beginning-of-buffer) (unless (org-goto-local-search-forward-headings today nil t) ((lambda () (org-insert-heading) (insert today) (insert "\n\n \n")))) (beginning-of-buffer) (org-show-entry) (org-narrow-to-subtree) (end-of-buffer) (backward-char 2) (unless (= (current-column) 2) (insert "\n\n "))))

It's the last day of 2008, and I have been thinking about what I have done this year.

• Chesspark added many new features, fixed many bugs, and tried several huge experiments. We explored the freemium model as opposed to straight subscriptions, we launched WuChess as a branded site in cooperation with RZA, and we've spun it off under new management as we pursue a new project.

• Stanziq was born from a combination of our vision of the new real time Web and many ideas we had at Chesspark. The world needs a real time search engine.

• My team and I created and then released the code for Speeqe, a Web 2.0 style group chat application based on XMPP. It's time for IRC to die.

• I learned some new languages. I have spent quite a bit of time with Erlang this year, and I'm looking forward to solving more problems with it in 2009. I've also hacked some Ruby for the first time. I've been picking up a bit of Emacs Lisp and learning about Haskell.

• I experimented with both Bazaar and Git heavily to replace my use of Subversion. I ended up picking Git and have been extremely happy.

• I renewed my commitment to XMPP by joining both the XSF board of directors and council.

• I finally achieved a long time goal of blogging more, which I hope to continue.

• Most important (to me at least), I gained a new family member - my son, Jasper. He puts a smile on my face every day, and something about constraints he imposes has increased my productivity.

I'm sure there is stuff I have forgotten. I find it remarkable difficult to remember how much time has passed since various events. The last four years with Chesspark seem like they all happened in the last year.

OneTeam for iPhone 1.2.0 is scheduled for submission on Apple Appstore.

OneTeam for iPhone is a Jabber / XMPP for iPhone that supports a large subset of the XMPP protocol. It is clean, easy to use and to not rely on third party server (it connects directly to your XMPP server).

I think we have reached a point in development where we are really happy with this client. It supports a really large number of XMPP server and authentication method. One of our biggest surprise has been with iChat server that require very unusual authentication methods. OneTeam for iPhone is probably one of the few XMPP clients that now supports it.

We have been quite far today in supporting XMPP features. For example we support gateways discovery and configuration directly from the phone (and gateway contact addition as well). The next big feature is probably be going to be groupchat support.

We are listening to your comments to help us improve this mobile XMPP client. Currently we think it is one of the most usable mobile client, but we are expecting to make it even better. Your feedback is welcome :)

More details on the product page OneTeam for iPhone.

Ubiquitous capture is the part of GTD that I am most interested in. While I am working I'll come up with random new ideas, find unrelated bugs in code I'm working on, or find something I need to remember later. I want to make a note of these things without causing much interruption to the task at hand. I've tried a number of solutions to this problem and have now got a great solution going using my favorite editor, Emacs.

Here's a small demo screencast:

Requirements

There are some basic requirements that I think any solution to the capture problem must solve.

It should be immediately accessible from any application on the computer. I want to have some key binding that immediately lets me jot down something quickly and then gets out of my way.

It needs to work everywhere I do. I currently use both OS X and Linux on different machines. I don't want to have to capture only on one machine, and I want the capture method to the be same on both.

Why Emacs

If you use Emacs, then it makes a lot of sense to use it for capture. If you don't use Emacs, then it probably doesn't, although OrgMode is good enough to convert some people.

First, Emacs is everywhere. It runs well on Linux, OS X, and Windows.

Emacs is also where I do a lot of my work already. This means I always have Emacs running, and many times when I am capturing something, it relates to things I am doing in Emacs. Notable exceptions to this include Web browsing and e-mail.

Emacs comes with a remarkably useful extension called OrgMode. OrgMode can be used like an outliner, but it also has hooks for to-do lists and calendaring. OrgMode integrates with Remember which is an Emacs capture tool.

These add up to most of a great capture solution. All we need is some glue.

Capturing From Anywhere

The first requirement is that we be able to capture from anywhere. This means we will need to globally bind some combination of key presses to invoking the Remember functionality in Emacs.

Emacs has a server mode that allows other things to communicate and control it. This is a lot like AppleScript on OS X except that it is done with Emacs Lisp. All we need to do is send Emacs a command when the global hot key is pressed. This is easily accomplished with emacsclient -e '(some-command)'.

Binding the hot key is done in the window manager preferences in Linux. Since my Ubuntu machines run compiz, I added a binding for <Control><Alt>backslash to run emacsclient -n -e '(make-remember-frame)'. On OS X I used Spark to bind the same keys to a small bit of AppleScript which runs the same command as Ubuntu.

Fine Tuning Emacs

Finally, I wanted Emacs to pop up a new, small window (what it calls a frame) and let me start typing. I also wanted Emacs to get rid of the window as soon as I was finished, either by saving my note or discarding it. This took a little digging through Emacs documentation and bits of code, but turned out not to be that hard.

Here is my make-remember-frame code, along with the hooks it needs to work.

(defadvice remember-finalize (after delete-remember-frame activate) "Advise remember-finalize to close the frame if it is the remember frame" (if (equal "remember" (frame-parameter nil 'name)) (delete-frame))) (defadvice remember-destroy (after delete-remember-frame activate) "Advise remember-destroy to close the frame if it is the rememeber frame" (if (equal "remember" (frame-parameter nil 'name)) (delete-frame))) ;; make the frame contain a single window. by default org-remember ;; splits the window. (add-hook 'remember-mode-hook 'delete-other-windows) (defun make-remember-frame () "Create a new frame and run org-remember." (interactive) (make-frame '((name . "remember") (width . 80) (height . 10))) (select-frame-by-name "remember") (org-remember))

PlanetErlang, the Erlang news and blog post aggregation site has been rewritten.

The new site should be easier to read. It includes a search engine, that allows users to search inside the history of Erlang posts among all the known blogs. The sitebar also contains latest Twitter post on Erlang.

Planet Erlang is available on the following address: http://www.planeterlang.org.

Enjoy !