Planet Jabber

Prosodical Thoughts: Prosody 0.9.0rc3 available for testing

The Prosody Team — 2013-06-18T23:15:53+00:00

After everyone's wonderful help at finding bugs (cheer), we've another release candidate for you from our 0.9 branch.

The primary reason for this RC is to keep compatibility with the just-released LuaSocket 3.0rc1. The new LuaSocket is now available from our package repository, and we have updated our IPv6 documentation accordingly. If you have previously installed lua-socket-prosody, it is now recommended to install the lua-socket package instead.

Summary of changes made since rc2:

Ensure select() backend acts correctly when reaching its limits.
PEP: Reflect generated id back to the client.
Pubsub: Check whether node exists, when deleting.
Add missing SSL options for Diffie-Hellman and Elliptic-Curve parameters, with the latter enabled by default
Moved function for listing local IP addresses from LuaSocket to util.net.
Add server:memory() command to view details of Prosody's memory usage in the telnet console.
A couple of input validation fixes in the telnet console.
MUC: Small variable name fix.
BOSH: Remove various unused headers.

Don't forget to keep your feedback on the release coming to us!

Download

Debian/Ubuntu

If you are using our package repository then you can simply install the prosody-0.9 package, which automatically tracks our 0.9 branch. This release is build 142.

Alternatively you can download packages manually from here.

Windows

Windows builds are coming soon!

Source

Source tarball: prosody-0.9.0rc3.tar.gz

The XMPP Standards Foundation: Hackfest in Berlin on July 27

stpeter — 2013-06-11T22:43:31+00:00

The XSF will hold a developer hackfest on July 27, 2013 in Berlin, Germany. This is the Saturday before IETF 87. Details are available at http://wiki.xmpp.org/web/Berlin_Hackfest.

Tigase Blog: Tigase Load Balancing

wojtek — 2013-06-10T14:49:12+00:00

Starting with version 5.2.0 Tigase introduces a load balancing functionality allowing users to be redirected to the most suitable cluster node. Functionality relies on a see-other-host XMPP stream error message. Basic principle behind the mechanism is that user will get redirect if the host returned by the implementaion differ from the host to which user currently tries to connect. It is required that the user JID to be known for the redirection to work correctly.

Available implementations

Tigase implementation is, as usual, extensible and allows for different, pluggable redirection strategies that implement SeeOtherHostIfc interface.

Currently there are three strategies available:

SeeOtherHost - most basic implementation returning either single host configured in init.properties file or name of the current host;
SeeOtherHostHashed (default) - default implementation for cluster environment of SeeOtherHostIfc returning redirect host based on the hash value of the user's JID; list of the available nodes from which selection would be made is by default composed and reflects all connected nodes, alternatively hosts list can be configured in the init.properties;
SeeOtherHostDB - extended implementation of SeeOtherHost using redirect information from database in the form of pairs user_id and node_id to which given user should be redirected.

Configuration options

Most basic configuration is related to the choice of actual redirection implementation:

--cm-see-other-host=

Possible values are:

tigase.server.xmppclient.SeeOtherHost
tigase.server.xmppclient.SeeOtherHostHashed
tigase.server.xmppclient.SeeOtherHostDB

All the remaining options are configured on per-connection-manager basis thus all options need to be prefixed with corresponding connection manager ID, i.e. c2s, bosh or ws; we will use c2s in the examples:

c2s/cm-see-other-host/default-host=host1;host2;host3 - a semicolon separated list of hosts to be used for redirection;
c2s/cm-see-other-host/active=OPEN;LOGIN - a semicolon separated list of phases in which redirection should be active; currently possible values are: OPEN which enables redirection during opening of the XMPP stream; LOGIN which enables redirection upon authenticating user session.

For SeeOtherHostDB implementation there are additional options:

c2s/cm-see-other-host/db-url - a JDBC connection URI which should be used to query redirect information; if not configured --user-db-uri will be used;
c2s/cm-see-other-host/get-host-query - a SQL query which should return redirection hostname;
c2s/cm-see-other-host/get-all-data-query - a SQL helper query which should return all redirection data from database;
c2s/cm-see-other-host/get-all-query-timeout - allows to set timeout for executed queries.

Movim Blog: Ubuntu Party Paris 13.04: Podcast of the conference

movim — 2013-06-09T10:11:39+00:00

Vincent has given a conference in french last week, on the 2nd June.

We are also pleased to announce that the PSES2013 (Pas Sage en Seine 2013, in Paris) has invited us to present Movim at this event!
=> You can meet us on the saturday 22th June from 6.30PM to 7.30PM

Peter Saint-Andre: Musical Parallels

2013-06-08T00:00:00+00:00

I've been listening to the Bach Cello Suites a lot lately, with the intent of applying some of their spirit to the collection of Yes transcriptions I'm working on. For instance, my transcription of "Turn of the Century" was already more measured than the Yes performance on their 1977 album Going For The One, but inspired by the sarabandes of the Cello Suites I'm experimenting with slowing it even further.

...

Peter Saint-Andre: Ninety-Proof Ink

2013-06-08T00:00:00+00:00

I have come to love short books. As evidence: both The Tao of Roark and Letters on Happiness are less than 60 pages long in the print-on-demand versions I recently produced.

...

Prosodical Thoughts: Prosody 0.9.0rc2 available for testing

The Prosody Team — 2013-06-05T10:15:11+00:00

After a very successful beta, we decided it's time for a release candidate. We have made only a few small changes since beta1:

With s2s_secure_auth enabled, we required encryption for domains listed in s2s_insecure_domains, even if s2s_require_encryption was not set.
Some minor fixes to commands in the telnet console.
Automatically disable SSL compression if luasec-prosody is installed.
Fix a traceback in mod_bosh when used in combination with some plugins.
Fix pubsub "get subscriptions" action.

As always, we depend very much on your feedback. If you give 0.9.0rc2 a try, let us know how you get on, even if it's only to tell us it's a complete success!

Download

Debian/Ubuntu

If you are using our package repository then you can simply install the prosody-0.9 package, which automatically tracks our 0.9 branch.

Alternatively you can download packages manually from here.

Windows

Source

Source tarball: prosody-0.9.0rc2.tar.gz

Alexander Gnauck: Web clients with MatriX and SignalR

gnauck — 2013-05-30T18:51:01+00:00

Persistent realtime connections for ASP.NET in code behind to the web browser were hard to implement in the past. There hasn’t been a ASP.NET component for this for a while.

With SignalR there is an asynchronous realtime signaling library for ASP.NET now that a team at Microsoft is working on. Using SignalR its pretty easy to build real-time web applications.

Using SignalR and MatriX its very easy to write scalable XMPP web applications with a very small amount of JavaScript code.

Let’s get started:

Create a new ASP.NET MVC web application project first. Then install SignalR using the NuGet Package Console with the following command:

install-package SignalR

This will add SignalR with all required references to the new project we just created.

Now we create a Hub for MatriX. Hubs are a higher level framework API to exchange different messages between server (code behind) and client (web browser) bidirectional in realtime.

We First implement the IConnected and IDisconnect interfaces to the Hub. Our Hub has a static Dictionary for all XmppClients instances. Whenever a new client connects to the bidirectional realtime channel of SignalR we create a new XmppClient instance for it, setup the event handlers and add the client to the dictionary. When a browser disconnects from SignalR we disconnect all event handlers and remove the XmppClient from the dictionary.

public class MatrixHub : Hub, IConnected, IDisconnect
{
    private static readonly Dictionary<string, XmppClient> XmppClients = new Dictionary<string, XmppClient>();

    public Task Disconnect()
    {
        if (XmppClients.ContainsKey(Context.ConnectionId))
        {
            var xmppClient = XmppClients[Context.ConnectionId];

            xmppClient.OnReceiveXml -= xmppClient_OnReceiveXml;
            xmppClient.OnSendXml -= xmppClient_OnSendXml;
            xmppClient.OnMessage -= xmppClient_OnMessage;

            XmppClients.Remove(Context.ConnectionId);
        }

        return Clients.leave(Context.ConnectionId, DateTime.Now.ToString());
    }

    public Task Connect()
    {
        if (!XmppClients.ContainsKey(Context.ConnectionId))
        {
            var xmppClient = new XmppClient();

            xmppClient.OnReceiveXml += xmppClient_OnReceiveXml;
            xmppClient.OnSendXml += xmppClient_OnSendXml;       
            xmppClient.OnMessage += xmppClient_OnMessage;
            
            XmppClients.Add(Context.ConnectionId, xmppClient);
        }

        return Clients.joined(Context.ConnectionId, DateTime.Now.ToString());
    }

    public Task Reconnect(IEnumerable<string> groups)
    {
        return Clients.rejoined(Context.ConnectionId, DateTime.Now.ToString());
    }    
}

Now we add a Open and Close function to our Hub which can be executed from the webpage via JavaScript. The JavaScript passes the username, password and XMPP domain as a string to the Open function.

Context.ConnectionId is the Id of the JavaScript client calling this Hub. We use this ids for our XmppClient dictionary and need it to lookup the correct XmppClient instance from the dictionary. After retrieving the XmppClient instance we set Username, Password and XmppDomain. Then we call Open() and MatriX starts to login to the XMPP server with the given credentials.

The same applies to the Close function. We first lookup the correct XmppClient and then call Close on it to close the XMPP stream.

public void Open(String username, String password, String xmppDomain)
{
    XmppClient xmppClient = XmppClients[Context.ConnectionId];
    xmppClient.Username = username;
    xmppClient.Password = password;
    xmppClient.XmppDomain = xmppDomain;

    xmppClient.Open();
}

public void Close()
{
    XmppClient xmppClient = XmppClients[Context.ConnectionId];
    xmppClient.Close();
}

Now we implement the OnSendXml and OnReceiveXml handlers we subscribed to in the Connect Task. This is server side C# code telling the client to call sendXml() and receiveXml() JavaScript functions.

Clients is a dynamic object of SignalR. Clients[Context.ConnectionId] gets the correct client and executes the function on this single client only.

void xmppClient_OnSendXml(object sender, Matrix.TextEventArgs e)
{
    var text = HttpUtility.HtmlEncode(String.Format("Send: {0}", e.Text));
   
    Clients[Context.ConnectionId].sendXml(text);
}

void xmppClient_OnReceiveXml(object sender, Matrix.TextEventArgs e)
{
    var text = HttpUtility.HtmlEncode(String.Format("Recv: {0}", e.Text));
   
    Clients[Context.ConnectionId].receiveXml(text);
}

The last step before we goto our JavaScript is the OnMessage function. SignalR can also send complex objects. So lets create a simple Message class to send the message properties as an object to our JavaScript. The Message class has 2 simple String properties. Body for the Text of the message and From for the full Jid of the sender.

public class Message
{
    public string Body;
    public string From;
}

Whenever MatriX receives a message in the OnMessage handler we raise the callback onMessage in our JavaScript and pass a new instance of the Message object we just created.

void xmppClient_OnMessage(object sender, MessageEventArgs e)
{
    Clients[Context.ConnectionId].onMessage(
           new Message
           {
           		From = e.Message.From,
           		Body = e.Message.Body
           }
    );       
}

The backend and code behind stuff is done now. Now we have to add JavaScript to our web page to setup the SignalR connection.

First we have to include some JavaScript files. We need jquery, the signalR script and the hubs which get created dynamically by SignalR on the server.

<script src="@Url.Content("~/Scripts/jquery-1.6.4.js")" type="text/javascript"></script>
<script src="@Url.Content("~/Scripts/jquery.signalR-0.5.2.js")" type="text/javascript"></script> 
<script src="@Url.Content("~/signalr/hubs")" type="text/javascript"></script>

The following code shows how to create our MatriX Hub in JavaScript and connect it to the SignalR server. matrixHub is defined in the dynamically created JavaScript file we added before.

<script type="text/javascript">
    $(function () {
        var matrixHub = $.connection.matrixHub;
        
		// TODO, callbacks and hub invoker
        
        $.connection.hub.start();
    });
</script>

Now we add the JavaScript code which gets executed when we press the Login and Logout buttons on our wegpage.

The Login button executes the Open function in our C# Hub and passes username, password and XmppDomain. The Logout button executes the Close function without any parameters.

This is all that has to be done to execute a Hub function from JavaScript in realtime.

$("#loginButton").click(function () {
    matrixHub.open(
        $("#txtUsername").val(),
        $("#txtPassword").val(),
        $("#txtXmppDomain").val());
});

$("#logoutButton").click(function () {
    matrixHub.close();
});

The last pieces which are missing are the JavaScript functions we execute form the Hub to send data to the webpage from the server.

The sendXml and readXml callbacks append the Xml debug to a div. The onMessage callbacks appends a incoming message to a div.

// signalR callback for outgoing xml debug
matrixHub.sendXml = function (message) {
    $("#log").append("<span class='log send'>" + message + "</span><br/>");
};

// signalR callback for incoming xml debug
matrixHub.receiveXml = function (message) {
    $("#log").append("<span class='log recv'>" + message + "</span><br/>");
};

matrixHub.onMessage = function (msg) {
    $("#messages").append(
            "<span class='from'>" + msg.From + ":</span>" +
            "<span class='message'>" + msg.Body + "</span>" +
            "</br>"
    );
};

SignalR can also send data to all connected clients or a group of clients, but we don’t need these features.

SignalR handles all the connection stuff for the client and the server automatically for us, and keeps the connection always alive. It chooses the right connection technique for your browser and scales on the server with modern async and await techniques.

Under the hood SignalR is using the same techology as BOSH. On the web server MatriX connects to the XMPP server directly over the default TCP transport. This means you can connect to any XMPP server including Google Talk, Facebook or Windows Live Messenger without using a BOSH proxy from your web page.

The complete example is included in the latest MatriX download.

This post refers to a SinalR version 0.5.x. There were many incompatible API changes in SignalR, so many stuff in this post in not compatible with the current SingalR versions.
The example included in the MatriX download should be always up to date.

Ignite Realtime Blog: Openfire 3.8.2 has been released

Ignite Realtime Blog (communityadmin@igniterealtime.org) — 2013-05-28T15:10:34+00:00

The Ignite Realtime community is happy to announce the release of version 3.8.2 of Openfire! Downloads for various platforms are available here.

Openfire is a real time collaboration (RTC) server licensed under the Open Source Apache license. It uses the only widely adopted open protocol for instant messaging, XMPP (also called Jabber). Openfire is incredibly easy to setup and administer, but offers rock-solid security and performance.

This release adds BOSH functionality for setting CORS headers and improves Pub-Sub support. There is also a new Atlassian Crowd provider! Various stability improvements were made as well. The changelog lists these and other changes in more detail.

As always, we welcome your feedback, suggestions, tips, hints, questions and other contributions in the Ignite Realtime Community pages.

Tigase Blog: --data-repo-pool-size

kobit — 2013-05-28T03:19:06+00:00

Default value:

Example:

--data-repo-pool-size = 25

Possible values:

Number of db connections as integer

Description:

DataRepository is an abstraction layer between any higher level data access repositories such as UserRepository or AuthRepository and SQL database or JDBC driver to be more specific. Many implementations use DataRepository for DB connections and in fact on many installations they also share the same DataRepository instance if they connect to the same DB. In such a case it is desired to specific a connection pool on this level to avoid excessive number of connections to the database.

It recommended to control number of DB connection using this property rather than --user-repo-pool-size or --auth-repo-pool-size.

Available since:

5.1.0

Author:

Artur Hefczyc

Product:

Tigase XMPP Server

Jack Moffitt: Servo Update: Navigation, Scrolling, GPU Rendering, Underlines, and more

Jack Moffitt (jack@metajack.im) — 2013-05-26T19:32:00+00:00

Servo is changing rapidly, and with two new interns joining the team the pace will only accelerate. The last few weeks have seen some big changes starting to land in the tree.

The Servo team welcomes and encourages new contributors and I'll note particular projects where new contributors can easily get involved below. These aren't the only places you can help, of course, but I thought it might be useful to know a few good places to start.

Navigation and Scrolling

Patrick Walton has landed the beginnings of navigation and scrolling support. The rust-alert library provides simple popup dialog support, and using this, you can now hit Ctrl-L to bring up a dialog to enter a new URL. rust-glut also got keyboard handler support. Note that this only works on Mac OS X right now due to missing support for Linux in rust-alert.

Scrolling is another important UI feature, and you can now pan the content in the window. Servo does not currently draw new parts of the content that were hidden, but that should be simple to add.

For new contributors: If you're looking to get started hacking on Servo or just want to learn more about Rust, adding popup dialogs on Linux to rust-alert would be a good project. Adding drawing of previously hidden areas to the scrolling code should also be an easy project for someone.

Underlined Text

Eric Atkinson, one of Servo's new interns, has just landed his first pull request, adding the first bits of CSS's text-decoration support for underline.

For new contributors: Eric didn't know any Rust or anything about Servo internals before he started last week. It doesn't take much to get started, and there is lots of low hanging fruit to pick on the Servo tree. For example, based on Eric's underline work, it should be fairly easy to add strike-through.

Performance metrics

Tim Kuehn, another of Servo's new interns, has also been busy his first week. He started overhauling how performance data is collected in Servo. Instead of simply timing bits of code and output the results to the console, there is now a separate task that handles performance data.

For new contributors: We're not yet doing anything with this data yet, but we should be. It should be a pretty easy project to start outputting it more systematically and doing something with the results. Another idea would just to be report numbers for different platforms and compare them to similar numbers from other browsers so we know where we should improve.

GPU Rendering

The first parts of GPU accelerated rendering have started to land in Servo, specifically updates to Skia and Azure to support framebuffer-backed draw targets. These framebuffers render to textures which are shared with the GPU-based compositor. This avoids needing to render to CPU memory and then upload textures to the GPU. There is still a bug or two to work out with tiling support, but I expect GPU rendering to land in the tree pretty soon.

Miscellaneous

Servo now has continuous integration via Bors, the wonderful CI bot that the Rust team has already been using for some time. Not only that, but Servo's Bors is now running on Mozilla's release engineering infrastructure instead of being hosted by the Rust team. This should keep the tree building cleanly from now on. If you've previously had trouble compiling Servo, now would be a good time to try again.

Patrick Walton has been heavily refactoring Servo's directory layout and many of its subsystems. util and net libraries were split out from the gfx library, and compositing was made quite a bit simpler. He has also refactored layout and is working on splitting Servo into more libraries, which make it both easier to understand and build faster. Much documentation has been added in these refactorings.

Samsung continues to work on Android support, improving the Rust compiler along the way. That work should land in the tree in the near future.

Give all these new things a try and report any issues you find. The team hangs out in #servo on irc.mozilla.org and is happy to answer questions or help you get started hacking on Servo.

Mike Taylor: Google Hangout chat and the missing XMPP

bear — 2013-05-25T00:27:17+00:00

My friend Jason Salas (who is an amazing and smart man – you should follow him in all of his endevours) asked me to comment on a post on Google+ from the Android Authority about XMPP being dropped by Hangout(s). I wanted to repost what I said here for anyone who reads my posts but is not on G+.

From Google+

it’s a good summary about the issue with XMPP – I may quibble with some of his thoughts about how Google “helped” XMPP but not enough to reject the post completely.

We in the XMPP community have seen this before and we will continue to support everyone who wants to use a stable, robust and open protocol. In some ways it may be an odd blessing as Google did not support some of the more secure features of federation and now that the largest (public) client base is out of the picture we will be able to revisit some items that were previously put on hold.

I’m also sensing that Google itself may not be completely aware of what just happened, this may be a case of the marketing/product folks driving the release of a product(s) that were not yet set in order to meet the I/O deadline – which is in-of-itself another worrying point.

But yea, there have been a number of great non-XSF folks posting concerns and questions. The XSF is ready to help when Google realizes the full impact of what has happened ;)

Peter Saint-Andre: Seventeen Years in the Making

2013-05-24T00:00:00+00:00

Today I took the final steps toward publishing The Tao of Roark as an ebook and print-on-demand title, seventeen years to the day after I first posted a germ of the idea (although I didn't start composing it in earnest until 2008). Much as I like my Letters on Happiness, The Tao of Roark is the best thing I've written to date and it holds great personal meaning for me -- not least because it was the last rung on the ladder of my intellectual encounter with Ayn Rand.

...

Peter Saint-Andre: RFC 6963

2013-05-24T00:00:00+00:00

RFC 6963, released today, is the latest document I've had published in the RFC series. This RFC provides a way for specification authors to generate documentation examples using Uniform Resource Names (URNs), similar to domain names like "example.com" (see RFC 2606). So if you've been dying to put "urn:example:foo" in your documentation or you need to generate random URNs for testing purposes, have at it!

...

Mike Taylor: XMPP features now missing from GTalk (aka Hangout Chat)

bear — 2013-05-20T00:43:20+00:00

I posted a snarky Twitter message about not wanting to spam the people following me with the features I’m now missing from GTalk, but I now really want to track them so…

Features that are now missing

Outside IM clients can no longer send messages to Google+ (aka GTalk, aka GMail) users
Outside IM clients can no longer receive messages from Google+
Presence updates to/from outside networks not allowed
Invisible status is missing
Unable to block other Google+ users from seeing my status
Contacts are now in whatever order some silly person at Google thinks is accurate/friendly/useful instead of the at-least-it’s consistent alphabetical order
The only way to remove someone from the active Contacts list is to … wait for it… block them!

ok, so it’s not the 15 that I said on Twitter but it’s still damn annoying

EDIT:
ok, so I may have been a bit harsh and in a really cranky mood when writing the above – here is a post from the G+ conversation where some of the community members correct me ;)

Buried in a conversation over on this post https://plus.google.com/u/0/107968525907303243288/posts/HFe3W7A9Dor is some comments from +Ben Eidelson about how XMPP support is still in the plans for Hangouts, just either not implemented or buggy.

So it could be that I’m just reacting poorly to some really bad coding and/or product management – don’t get me wrong, i’m still irked.

I just may be restructuring and changing my reaction over the next couple of updates.

Thanks to +Fernando Miguel for pointing that out.

and here is the conversation:

Ben Eidelson May 15, 2013

+Daniel Rose currently those settings affect who causes invites to you, not who shows up for you to send messages to. Once you start using Hangouts for a few days the list should re-order based on who you are contacting most often.

+Thomas Heinen Thanks for your report of the issue. Hangouts supports basic interop with XMPP, so you can-for the time being-continue to use 3rd party clients. It does not work the same way as Talk, and so I believe the issue you’re having with the XMPP bridge will not resolve in Hangouts.

Mike Taylor: I welcome Google as the new Borg

bear — 2013-05-19T22:12:05+00:00

yea, that’s a subtle title alright :/

I posted this earlier on Google+ and decided to cross-post it here as I realized that it was more hipster ironic than I wanted to be (to post about Google changing things on the same G+ stream they are changing things to focus on.)

So here is a cut-n-paste of what I said over there

I just found out the hard way that GTalk on Android has been silently replaced by Hangouts and the do-no-evil geniuses have removed everything dealing with XMPP from it … everything

The “hard way” is from the fact that I did not get a server alert on my phone because Hangouts no longer supports outside messages from XMPP sources (also known as Federation.)

This has me all worked up in a lot of ways:

Personally – a lot of my friends are XMPP users so now I no longer have a single client for my messaging needs and this means that GTalk will not be my primary tool, heck I may not load it at all now.

Professionally – I’m a member of the XMPP Software Foundation and we have been very proud about XMPP being the core of a lot of commercial communication products (Google, Facebook, Microsoft, Cisco and many others) and even tho each commercial entity does odd things (heck, breaks them also) the one thing that stood out was Federation.

Now Google is removing a core part of their messaging and replacing it with something that is not an Open standard and hell, to be blunt, is a horrible implementation of a messaging system. The Hangouts support forum is full of people wondering, like me, what happened to many features they depended on and also asking WTF

So even tho I know Google engineers may not ever see this, I just have to ask: when will you be changing your motto from “do no evil” to “meh, we just do what we want because we are now the new borg”

yea, I’m pissed, pissed enough that I won’t be buying Android as my next phone and I’m going to be putting my full effort behind the infrastructure behind Firefox OS

Remko Tronçon: My Favorite Vim Plugins

2013-05-17T22:00:00+00:00

After a brief affair with another editor, I’m now back to using my beloved Vim again. What’s more, I decided to invest the time I should have put in years ago when I started using it, and learned to do things more efficiently. Besides reading Practical Vim and watching some VimCasts, I went through my list of plugins I collected over the years, removed the ones I wasn’t using, learned about a couple of new ones I didn’t know, and re-learned some of the ones I forgot about. Here’s the list of my favorite plugins I ended up with.

pathogen: Easy management of Vim plugins. I put all my Vim settings in a Git repository, and this plugin allows me to add plugins as a Git submodule somewhere in my settings tree. For an extensive tutorial, have a look at the pathogen VimCast. Several other plugins with similar functionality have emerged since I started using pathogen, but I haven’t tried them since this one does the trick for me.
sensible: Have sensible, safe defaults for a modern day Vim setup. Allows me to trim down my vimrc a bit.
ctrlp: Open files anywhere below your current directory very quickly, using fuzzy search. This is similar to Sublime’s “Go to anything” (which even uses the same shortcut). I almost exclusively open files using ctrlp.
unimpaired: Easy to remember extra ] and [ shortcuts for a handful of useful tasks: cycling through files, buffers, arguments, SCM conflict markers, spelling errors; exchange lines, switch options, insert empty lines, … Also comes with shortcuts to toggle options, such as col (toggle invisible characters), con (toggle number column), cos (toggle spell correction), …
detectindent: Automatically detects whether tabs are expanded or not. Handy for working on multiple codebases with different tab preferences.
a: Switch between corresponding .h and .(c|cpp|mm) headers easily
ack: Lightning fast greps across a project. I actually use ag as backend.
clang_complete: C/C++ code completion that works. Requires clang to be on your system (which it is by default on MacOS X)
endwise: Automatically adds end when you write a begin, but does it conservatively so it never inserts anything unwanted.
fugitive. An extremely powerful Git integration for Vim. Apart from providing an interface for doing all kinds of (interactive) Git tasks from within Vim, also provides a status line entry for showing your current branch etc. There are a couple of VimCast episodes about how to use this plugin.
abolish: A set of search/replace/conversion commands that support plurals, case (MixedCase, camelCase, snake_case, …), … Can be used to rename variables easily, change case of avariable, … There are also some VimCasts about this plugin.
gundo: Graphical overview of Vim’s undo tree. If you undid a couple of changes, did some other stuff, and decided that your initial version was actually better, you can easily revert back. This has saved me and my undecisive mind a couple of times already. Also has a VimCast.
matchit: Match more than just braces with %. Cycles through if/else, matches HTML/XML tags, …
surround: change/delete/add surrounding quotes, parentheses, tags, …
syntastic: Checks the syntax of your current file on save, and displays errors using markers in the sidebar. Saves you a round trip to your terminal when trying to compile/run the file.
taglist: A navigation window with an overview of all functions/variables in your current file. Uses ctags behind the screens, but doesn’t require you to run ctags yourself on the codebase. It can also put an entry with the current function in your status bar (which is useful when editing files with large functions).
tcomment: Quickly comment out lines and code blocks. I used NERDCommenter for a while, but tcomment came with more natural Vim shortcuts (and is also supported by Vrapper). I also tried commentary (mostly because it’s by Tim Pope, and because it supports repeat), which uses the same shortcuts, but this one doesn’t comment indented code blocks the way I want it to (i.e. put the indentation after the comment string instead of in front).
easymotion: Makes it easy to jump to any word in your buffer, by assigning a single letter to each word, highlighting it, and drilling down with each keystroke. Although this plugin is probably as fast and intuitive as it gets, in a GUI mode, it may be a tad faster to simply reach for the mouse and click in the document. However, when editing remote files without mouse support, this plugin is great!
snipmate: An engine for inserting snippets of code. There’s also a standard repository of standard snippets, but I mostly only use my own snippets for larger snippets (e.g. create a new class, insert copyright headers, …). Downsides: it no longer works with clang_complete (although it used to), and it seems hard to override already existing snippets (which is why I don’t use the default repository).
mru: Easily access recently opened files through the MRU list.
dispatch: Asynchronous version of :make, so you can still edit your code while your project is building. The downside is that it requires iTerm on MacOS X or fires off a separate command shell on Linux and Windows, so it’s still not as nice as a native window running a build in its own thread, but it gets the job done.
NERDtree: A better file system explorer than the default one. I don’t really use it that often (since I use ctrlp to open files), but it’s handy for when you need to look around your project tree.
repeat: ‘.’ support for some of the plugins I use.
speeddating: Increment dates using Ctrl-A/Ctrl-X. Not that I often do this, but since it just adds extra support to Ctrl-A/Ctrl-X, I just load it.
molokai: A beautiful dark gray color scheme, based on the Monokai scheme from TextMate, and popular in other modern editors as well.
Vrapper: Not really a Vim plugin, but worth the mention: this Eclipse plugin provides a wide variety of Vim bindings to use inside Eclipse, so you can stay efficient when working on Java/Eclipse projects.

Remko Tronçon: My Favorite Vim Plugins

2013-05-17T22:00:00+00:00

pathogen: Easy management of Vim plugins. I put all my Vim settings in a Git repository, and this plugin allows me to add plugins as a Git submodule somewhere in my settings tree. For an extensive tutorial, have a look at the pathogen VimCast. Several other plugin managers (such as VAM and Vundle) have emerged since I started using pathogen, but I haven’t tried them since this one does the trick for me.
sensible: Have sensible, safe defaults for a modern day Vim setup. Allows me to trim down my vimrc a bit.
ctrlp: Open files anywhere below your current directory very quickly, using fuzzy search. This is similar to Sublime’s “Go to anything” (which even uses the same shortcut). I almost exclusively open files using ctrlp.
unimpaired: Easy to remember extra ] and [ shortcuts for a handful of useful tasks: cycling through files, buffers, arguments, SCM conflict markers, spelling errors; exchange lines, switch options, insert empty lines, … Also comes with shortcuts to toggle options, such as col (toggle invisible characters), con (toggle number column), cos (toggle spell correction), …
detectindent: Automatically detects whether tabs are expanded or not. Handy for working on multiple codebases with different tab preferences.
a: Switch between corresponding .h and .(c|cpp|mm) headers easily
ack: Lightning fast greps across a project. I actually use ag as backend.
clang_complete: C/C++ code completion that works. Requires clang to be on your system (which it is by default on MacOS X)
endwise: Automatically adds end when you write a begin, but does it conservatively so it never inserts anything unwanted.
fugitive. An extremely powerful Git integration for Vim. Apart from providing an interface for doing all kinds of (interactive) Git tasks from within Vim, also provides a status line entry for showing your current branch etc. There are a couple of VimCast episodes about how to use this plugin.
abolish: A set of search/replace/conversion commands that support plurals, case (MixedCase, camelCase, snake_case, …), … Can be used to rename variables easily, change case of avariable, … There are also some VimCasts about this plugin.
gundo: Graphical overview of Vim’s undo tree. If you undid a couple of changes, did some other stuff, and decided that your initial version was actually better, you can easily revert back. This has saved me and my undecisive mind a couple of times already. Also has a VimCast.
matchit: Match more than just braces with %. Cycles through if/else, matches HTML/XML tags, …
surround: change/delete/add surrounding quotes, parentheses, tags, …
syntastic: Checks the syntax of your current file on save, and displays errors using markers in the sidebar. Saves you a round trip to your terminal when trying to compile/run the file.
taglist: A navigation window with an overview of all functions/variables in your current file. Uses ctags behind the screens, but doesn’t require you to run ctags yourself on the codebase. It can also put an entry with the current function in your status bar (which is useful when editing files with large functions).
tcomment: Quickly comment out lines and code blocks. I used NERDCommenter for a while, but tcomment came with more natural Vim shortcuts (and is also supported by Vrapper). I also tried commentary (mostly because it’s by Tim Pope, and because it supports repeat), which uses the same shortcuts, but this one doesn’t comment indented code blocks the way I want it to (i.e. put the indentation after the comment string instead of in front).
easymotion: Makes it easy to jump to any word in your buffer, by assigning a single letter to each word, highlighting it, and drilling down with each keystroke. Although this plugin is probably as fast and intuitive as it gets, in a GUI mode, it may be a tad faster to simply reach for the mouse and click in the document. However, when editing remote files without mouse support, this plugin is great!
snipmate: An engine for inserting snippets of code. There’s also a standard repository of standard snippets, but I mostly only use my own snippets for larger snippets (e.g. create a new class, insert copyright headers, …). Downsides: it no longer works with clang_complete (although it used to), and it seems hard to override already existing snippets (which is why I don’t use the default repository).
mru: Easily access recently opened files through the MRU list.
dispatch: Asynchronous version of :make, so you can still edit your code while your project is building. The downside is that it requires iTerm on MacOS X or fires off a separate command shell on Linux and Windows, so it’s still not as nice as a native window running a build in its own thread, but it gets the job done.
NERDtree: A better file system explorer than the default one. I don’t really use it that often (since I use ctrlp to open files), but it’s handy for when you need to look around your project tree.
repeat: ‘.’ support for some of the plugins I use.
speeddating: Increment dates using Ctrl-A/Ctrl-X. Not that I often do this, but since it just adds extra support to Ctrl-A/Ctrl-X, I just load it.
molokai: A beautiful dark gray color scheme, based on the Monokai scheme from TextMate, and popular in other modern editors as well.
Vrapper: Not really a Vim plugin, but worth the mention: this Eclipse plugin provides a wide variety of Vim bindings to use inside Eclipse, so you can stay efficient when working on Java/Eclipse projects.

Remko Tronçon: My Favorite Vim Plugins

2013-05-17T22:00:00+00:00

pathogen: Easy management of Vim plugins. I put all my Vim settings in a Git repository, and this plugin allows me to add plugins as a Git submodule somewhere in my settings tree. For an extensive tutorial, have a look at the pathogen VimCast. Several other plugins with similar functionality have emerged since I started using pathogen, but I haven’t tried them since this one does the trick for me.
sensible: Have sensible, safe defaults for a modern day Vim setup. Allows me to trim down my vimrc a bit.
ctrlp: Open files anywhere below your current directory very quickly, using fuzzy search. This is similar to Sublime’s “Go to anything” (which even uses the same shortcut). I almost exclusively open files using ctrlp.
unimpaired: Easy to remember extra ] and [ shortcuts for a handful of useful tasks: cycling through files, buffers, arguments, SCM conflict markers, spelling errors; exchange lines, switch options, insert empty lines, … Also comes with shortcuts to toggle options, such as col (toggle invisible characters), con (toggle number column), cos (toggle spell correction), …
detectindent: Automatically detects whether tabs are expanded or not. Handy for working on multiple codebases with different tab preferences.
a: Switch between corresponding .h and .(c|cpp|mm) headers easily
ack: Lightning fast greps across a project. I actually use ag as backend.
clang_complete: C/C++ code completion that works. Requires clang to be on your system (which it is by default on MacOS X)
endwise: Automatically adds end when you write a begin, but does it conservatively so it never inserts anything unwanted.
fugitive. An extremely powerful Git integration for Vim. Apart from providing an interface for doing all kinds of (interactive) Git tasks from within Vim, also provides a status line entry for showing your current branch etc. There are a couple of VimCast episodes about how to use this plugin.
abolish: A set of search/replace/conversion commands that support plurals, case (MixedCase, camelCase, snake_case, …), … Can be used to rename variables easily, change case of avariable, … There are also some VimCasts about this plugin.
gundo: Graphical overview of Vim’s undo tree. If you undid a couple of changes, did some other stuff, and decided that your initial version was actually better, you can easily revert back. This has saved me and my undecisive mind a couple of times already. Also has a VimCast.
matchit: Match more than just braces with %. Cycles through if/else, matches HTML/XML tags, …
surround: change/delete/add surrounding quotes, parentheses, tags, …
syntastic: Checks the syntax of your current file on save, and displays errors using markers in the sidebar. Saves you a round trip to your terminal when trying to compile/run the file.
taglist: A navigation window with an overview of all functions/variables in your current file. Uses ctags behind the screens, but doesn’t require you to run ctags yourself on the codebase. It can also put an entry with the current function in your status bar (which is useful when editing files with large functions).
tcomment: Quickly comment out lines and code blocks. I used NERDCommenter for a while, but tcomment came with more natural Vim shortcuts (and is also supported by Vrapper). I also tried commentary (mostly because it’s by Tim Pope, and because it supports repeat), which uses the same shortcuts, but this one doesn’t comment indented code blocks the way I want it to (i.e. put the indentation after the comment string instead of in front).
easymotion: Makes it easy to jump to any word in your buffer, by assigning a single letter to each word, highlighting it, and drilling down with each keystroke. Although this plugin is probably as fast and intuitive as it gets, in a GUI mode, it may be a tad faster to simply reach for the mouse and click in the document. However, when editing remote files without mouse support, this plugin is great!
snipmate: An engine for inserting snippets of code. There’s also a standard repository of standard snippets, but I mostly only use my own snippets for larger snippets (e.g. create a new class, insert copyright headers, …). Downsides: it no longer works with clang_complete (although it used to), and it seems hard to override already existing snippets (which is why I don’t use the default repository).
mru: Easily access recently opened files through the MRU list.
dispatch: Asynchronous version of :make, so you can still edit your code while your project is building. The downside is that it requires iTerm on MacOS X or fires off a separate command shell on Linux and Windows, so it’s still not as nice as a native window running a build in its own thread, but it gets the job done.
NERDtree: A better file system explorer than the default one. I don’t really use it that often (since I use ctrlp to open files), but it’s handy for when you need to look around your project tree.
repeat: ‘.’ support for some of the plugins I use.
speeddating: Increment dates using Ctrl-A/Ctrl-X. Not that I often do this, but since it just adds extra support to Ctrl-A/Ctrl-X, I just load it.
molokai: A beautiful dark gray color scheme, based on the Monokai scheme from TextMate, and popular in other modern editors as well.
Vrapper: Not really a Vim plugin, but worth the mention: this Eclipse plugin provides a wide variety of Vim bindings to use inside Eclipse, so you can stay efficient when working on Java/Eclipse projects.

ProcessOne: Google Cloud Messaging Update Boosted by XMPP

Mickaël Rémond — 2013-05-17T17:55:34+00:00

As you know, ProcessOne is about realtime messaging. Our core component is XMPP ejabberd scalable and ubiquitous server. We recently acquired Boxcar to use a familiar and popular brand for our large scale push notification service for mobile as well.

From this perspective, Google’s huge update on its Cloud Messaging service is the biggest announcement from this year Google I/O, as it mixes our two core strengths. We strongly believe this is a big deal for mobile developers and we will explain why.

What is Google Cloud Messaging (GCM) ?

In case you never heard about it, here is a quick overview.

Google Cloud Messaging have been announced last year as a replacement of Google Cloud to Device Messaging. This is a service that allows mobile developer to notify mobile devices (but also Chrome browser) about important changes on the server-side component of the application. It makes it possible for the device to stay up to date, without the need to use polling. Polling is about checking periodically for updates on your server and is bad for several reasons:

it consumes lot of battery, periodically waking up the mobile device network stack.
it consumes a lot of useless resources on the server as most of this resource lead to a “no update” reply.
it introduces latency as the request for new data can happen long after the data availability (unless you put a very low polling interval, which is even worse for the mobile battery). You can get your news alert hours after every one already knows about it, which defeat the purpose of the alert in the first place.

Push notifications avoid all those drawbacks, saving battery life, providing lower latency, reducing server load. As a permanently connected session to Google servers, it get the important notification messages as soon as they happen, in a battery efficient way.

Being a service that runs at device level, it can be optimized across applications running on the same device and perform further battery saving benefits.

So, this is a really critical feature to implement in application relying on data coming from the network (which actually covers a lot of applications).

GCM offers nice outstanding features like:

Support two use cases:
- “send to sync”: short notification to tell client to get update from developer server.
- “send data”: larger notification containing the data payload, avoiding an extra client to developer server roundtrip.
Time to live can be used to destroy message without notification if device was not online before its expiration. Pending messages can also be replaced with the collapse feature.
Delay when idle can be use for less urgent notifications. Device will get it when becoming active again.
Multicast messages to send the same notification to up to 1000 devices.

What does GCM update brings to developers ?

The new update is a brand new service deployment bringing a large set of new features for developers.

In short, it brings:

Persistent connections are supported between developer backend and Google, allowing sending a larger number of notifications faster.
Upstream messaging: This allows the device to send back notifications to the developer server, through Google platform.
Notifications synchronization between devices. Basically, this allows a developer to remove a notification from a device when it has been read / processed on another device.

GCM Cloud Connection Service (CCS): Persistent connections using XMPP

Google choose to use XMPP to allow developers to keep a persistent connection. It works as follow:

You open an XMPP client connection to Google XMPP GCM server (Port 5235 on gcm.googleapis.com).
You can then keep the secure connection open for as long as you wish.
You can then send your usual GCM JSON payload in XMPP message packets.
This is streaming so you receive possible errors asynchronously and you can match it to original push thanks to XMPP message id.

This alone brings you a huge performance increase, allowing your server to send up to 4000 messages per second on the persistent connection. Knowing you are allowed up to 10 connections, you can possibly send many notifications fast (up to 40k notifications per second).

A few things to note:

You cannot use multicast messages with XMPP persistant connection (at least yet).
However, you can mix HTTP connexions and XMPP persistant connections in your use case to optimize the performance depending on the use case.

Upstream messaging

Upstream messaging allows your client to send data asynchronously to your server. Compared to HTTP posts, it offer several advantages:

It is easy for client developer, with a simple gcm.send command. This is “fire and forget”. Client developer sends the data. Android GCM framework save it locally, with the commitment to deliver it.
It is reliable with reliability handled transparently by GCM mobile framework on the client. There is acknowledgement mechanism on the client and between GCM and your server that ensure no message can be lost.
Timing to send is optimized across mobile applications. This allow significant battery saving for messages that are not very time sensitive. Optimization is even performed based on the server side down stream needs. If client or server send messages first, the other direction queue is flushed at the same time.
It supports time to live. If the message could not be send, because network is unavailable and is not relevant anymore, it is discarded.

As a developer, your server will receive the message through an XMPP connection. However, be very careful about your server efficiency: you have to be robust and read data fast as the GCM server will queue for you 100 messages before starting to overwrite them (and if you are offline for 24 hours it will discard your messages).

Multi-devices notification synchronisation

The goal of this feature is to makes your notifications state becomes up to date and consistent across a user devices, by propagating state change between the user application installations on your various devices.

This feature is designed to bring many added benefits in the way multiple devices are handled.

First, to know that your app is used by the same users, you can group your device Registration Ids under the same notification_key. Notification key is typically a hash of the username. You are allowed up to 10 devices linked to that notification_key.

Once you have done that, you can use that notification_key as a user id to send notifications to all devices of a given user. By doing so, you let GCM performs lots of optimizations under the hood. Notification will be send in priority to the active device or the last active device. Other devices will get the notification a bit later in a delay while idle type of delivery.

Once the notification has been processed and dismissed, other devices are notified and they can remove the notification as well. If they were not notified yet, notification is directly canceled from the notification queue.

Conclusion

As you see, update to Google Cloud Messaging is really a big update for developers, increasing the number of situation this platform is relevant.

We are already working on supporting those improvements on our push notification platform to help you all benefits of those improvements.

Stay tuned for more information on this support very soon.

Here is the video of Francesco Nerieri’s talk on GCM:

Prosodical Thoughts: Prosody 0.9.0beta1 available for testing

The Prosody Team — 2013-05-16T17:08:13+00:00

It's the news you've all been waiting for! We present the first beta of our upcoming 0.9.0 release. For those of you not already following our development and nightly builds, here are a few of the major changes in this development branch (codenamed 'Prosody Everyone Edition') since 0.8:

Full IPv6 support for all services (c2s, s2s, HTTP, etc.)
Server-to-server authentication using certificates (SASL EXTERNAL)
A new and improved HTTP subsystem, supporting virtual hosts and fully-reloadable modules
Basic pubsub service
Many other fixes and improvements, see our release notes for more information.

Important: This release introduces some changes that require attention from people who upgrade from previous releases. Please read the upgrading section of our release notes to avoid any surprises.

We expect there to be one or two more betas before rc1, and then the final release soon after that.

As always, we appreciate all the help that we get testing Prosody. If you find any issues, please report them.

Download

Debian/Ubuntu

If you are using our package repository then you can simply install the prosody-0.9 package, which automatically tracks our 0.9 branch.

Alternatively you can download packages manually from here.

Windows

Source

Finally, for you old-school folks...

Source tarball: prosody-0.9.0beta1.tar.gz

ProcessOne: Google I/O 2013: Services, services, services

Mickaël Rémond — 2013-05-16T02:22:17+00:00

Today was the keynote of Google I/O developer conference. The keynote is usually the place where major announcements are made regarding the Google ecosystem.

Despite impressive announcements, the most important thing that strikes me is not what has been released, but what has not been mentioned.

Services, services and more services

First, what are the main areas of focus this year ?

Either on Android, on Chrome or on the Cloud and server engine architecture Google is showing its consistency in pushing further existing services, adding new ones, and integrating all the pieces together. Here is the impressive list of highlights to their service stack:

Google Maps API V2 and location API improvements, with:
- Fused location = faster, more accurate and more battery friendly.
- Geofencing, ability to save up to one hundred location triggers per application.
- Activity recognition based on the phone accelerometer. Device can know if your are walking, cycling, walking, driving. This is a battery efficient, not relying on GPS.
Google+ Sign in, brings deep integration between website and Android apps with Google+ service.
Google Cloud Messaging, Google Push Notification service, with three major highlights:
- Persistent connections are supported between developer backend and Google, allowing sending a larger number of notifications faster.
- Upstream messaging: This allows the device to send back notifications to the developer server, through Google platform.
- Notifications synchronization between devices. Basically, this allows a developer to remove a notification from a device when it has been read / processed on another device.

Google Cloud Messaging is one our main area of interest. We are already working on the new features and we will have announcements to make soon under our mobile Boxcar brand. Stay tuned :)

Google Play Game Service, with:
- Cloud Save to synchronize your game progress across devices.
- Achievements and Learderboard, integrated with Google+.
- Multiplayer API to help developer with networking part.
- Matchmaking to find players to play with.
- Cross-platform experience on Android and iOS.
Google Wallet: low profile (aka not really promoted in the keynote) improvements, like GMail payments, or easier checkout on mobile.
Better developer console to analyse how Android apps are doing and optimize their performance, more specifically:
- Optimization tips
- App Translation Service.
- Referal tracking
- Usage metrics (Google Analytics from the developer console).
- Revenue graph
- Beta testing and stage rollout management

There have also been announcements focusing on Google services improvements or addition for main users (as opposed to developers):

Google Play Store improvements to better promote apps to users.
Google Music subscription service (US only for now).
Huge Google Maps rework and redesign.
Search improvements with focus on:
- more knowledge graph integration in search.
- more integration of personal information and Google+, circle based personnalisation in search results.
- Better conversation (aka iteratively refined voice search), with conversation-based queries coming to Chrome on the desktop.
- Google Now improvements with more cards, to anticipate your search needs on the go.
Google+ improvements, mostly for end users:
- Stream redesign
- Hangouts chat system, which is a cross platform merge of all Google chats. It is cross-platform, focus on conversation, realtime, photo sharing and video group calling.
- Photos management, with impressive auto-enhancement and sorting features.

Note from an XMPP developer perspective: Does the new Hangouts mean Gtalk and XMPP will disappear, along with interoperability ? There was not word about it, but I think so.

Impressive, isn’t it ?

Still, as a developer, that first day strangely leaves me with a feeling of unfullfilled expectations. Why ? I think to understand it, we need to list what Google did not talk about.

What Google did not talk about

In previous Google I/O, the center stage is usually taken by:

Android updates: There was none announced today.
Shiny new devices, usually prerelease to developers. Nothing on this part as well.
New unexpected projects, like Chrome, Google Glasses, Google TV, or even the now dead Wave.

On this side, nothing has been announced. No mention of Android for home or TV. No successor for the now dead Nexus Q. No update on Android Accessory Developement Kit. No glasses push. No new wearable computer.

Despite a few talks on Google glasses tomorrow, there have been little mention of the progress so far in the keynote.

This year, Google is focusing on services for several (valid) reasons:

Those services are updated directly on the devices through Google Play Store. They can more easily push the updates to the end users.
Services are perceived are Apple’s Achille heel.
Services are a way to put Google at the front stage and differenciate the Google experience from the various Android forks. It also allow Google to differenciate from device manufacturers that are increasingly trying to get the front stage with their Android devices.

But as Google focus on Services, the story they tell is increasingly about themselves.

For Android developer, on the most major highlight (outside of Google Services) was Android Studio, a development environment based on Jetbrains Intellij, release today in early preview (version 0.1!).

Google have even been heavily promoting Chrome on Desktop, but now also on Android and iOS, focusing on bringing the same experience from all the environment. Along with the fact that both Chrome and Android and under the unique direction of Sundar Pichai, this leave a strange confusing impression.

My conclusion is that for Google, devices do not matter. When Larry Page says that he wants the technology, the device to disappear, he actually means it in the proper sense. Google Glasses and conversational search are a steps in that direction. They are the most straightforward access to Google services. Ideally, they should not even be needed.

It does not matter if you use Chrome, Glasses, Android or iOS to access Google Services. What matter are the services themselves and the contextual data that can be gathered to improve relevance and personnalisation of the service.

Sundar Pichai said two days ago that Google I/O will not be centered on the devices. It is because devices are not an end but a mean for Google.

I feel at this Google I/O, the goal of Google has never been more clear (if you look through the confusion I mentioned earlier).

At this very moment, the path of Apple and Google may split there:

Google wants to improve people lifes with services, making the technology totally hidden. Apple wants to improve people life by focusing on how people interact with the technology (touch, voice, and more). This goes through devices improvements (lighter, faster, easier to use), not making the devices disappear.

Today, I feel that we are at a turning point, I am really looking forward WWDC to see what will be Apple move.

Isode: The M-Link IRC Gateway: new whitepapers

Will Sheward — 2013-05-14T15:18:04+00:00

Military deployments make extensive use of text chat services, mostly for multi-user chat (MUC). A vast majority of new deployments use the XMPP (eXtensible Messaging and Presence Protocol) standard but there are significant legacy text chat installations using IRC (Internet Relay Chat).

Communication between IRC and XMPP networks is often problematic. In the next major release of the Isode product set, R16, we’re introducing an IRC gateway into our M-Link XMPP Server product. We are doing this because we believe that existing gateways do not include functionality appropriate to our target markets.

Existing gateways allow individual XMPP users to connect into IRC channels (where they adopt a username derived from their XMPP JID). In this model the XMPP user is downgrading to IRC capabilities. The Isode gateway associates an XMPP MUC room with an IRC channel, giving a number of benefits over existing approaches:

The involvement of IRC is totally transparent to the XMPP user. The user will see a normal MUC room which just happens to be connected to an IRC channel.
Full MUC functionality is available locally, for example MUC access control and affiliation management.
There is no downgrade of security for XMPP users with XMPP traffic. XMPP users are still authenticated and connections are protected with TLS.
M-Link security label support is available, including translation to IRC users as FLOT (First Line of Text) labels in the IRC messages.
The XMPP administrator has control of MUC room naming, which does not have to match IRC channel naming.

Chat from the perspective of IRC and XMPP

We’ve released two whitepapers today which talk about IRC, XMPP and the new capabilities in M-Link R16.

In [Interconnecting XMPP and IRC] we describe the operation of both XMPP and IRC and then look at the different approaches to gateways between these two services, comparing the existing approach with Isode’s solution.

In [Deploying IRC, Federated MUC and XMPP Guards] we look at how IRC would operate with a Federated Multi-User Chat (FMUC) deployment. FMUC is a new standard, more information here. The paper also looks at how the solution would work in a cross-domain environment using XMPP Guards.

R16 is currently in late beta and will be released in June 2013.

Rodrigo Duarte (GSoC 2012): Media Server user authentication - XEP-0070

Rodrigo Duarte (noreply@blogger.com) — 2013-05-07T14:41:11+00:00

XEP-0070 is a known specification of how verify HTTP requests via XMPP. It has basically 8 steps.

In the Media Server, when a HTTP request arrives, the HTTP side forwards the request to a AuthVerifier class, this class has control over an XMPP component, to send and receive packets in a synchronous way, via a SyncReplySend util class. Once the AuthVerifier class receives the request, it "asks" if the client has sent it, if yes, the request is authorized, if not, the HTTP side returns a 403 error.

Here is the sequence diagram:

To send its credentials, the client has two options:

Via HTTP auth: Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==
Via URL: /media/test@topics.buddycloud.org?auth=QWxhZGRpbjpvcGVuIHNlc2FtZQ==

In both ways, the client's JID and transaction id, are separated by a ; and are base 64 encoded.

This week, we hope to do the first deploy, to finally see the Media Server running in a production environment!

Ignite Realtime Blog: Smack 3.3 is released

Ignite Realtime Blog (communityadmin@igniterealtime.org) — 2013-05-04T13:46:04+00:00

The Ignite Realtime community is happy to announce the latest release of Smack (version 3.3). It is now available for download. There have been a large number of issues addressed for this release, including new functionality with support for several more protocol extensions (XEP's) and many improvements on existing features.

New Features

[SMACK-331] - Add support for XEP-0184: Message Delivery Receipts
[SMACK-345] - Inproved detection of last activity
[SMACK-361] - Add support for XEP-0115 Entity Capabilities
[SMACK-376] - Setting a custom trust manager to control certificates from outside
[SMACK-388] - XEP-199 XMPP Ping support

In addition to these, there have been many bugs fixed and a variety of other tasks done, the complete listing can be viewed here.