news aggregator

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

1. Outside IM clients can no longer send messages to Google+ (aka GTalk, aka GMail) users
2. Outside IM clients can no longer receive messages from Google+
3. Presence updates to/from outside networks not allowed
4. Invisible status is missing
5. Unable to block other Google+ users from seeing my status
6. 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
7. 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.

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

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 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.

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.

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.

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:

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

• Windows installer
• Windows zip

Source

Finally, for you old-school folks...

• Source tarball: prosody-0.9.0beta1.tar.gz

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.

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.

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!

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.

When I tell people about Fanout.io, their reaction usually takes one of two forms:

• Sign me up!
• Why would I use an external service for this? Push is easy. I can do it in 20 minutes with <insert modern web framework>.

It is true that there are a bunch of software solutions that make pushing data in realtime easier, and if you're enthusiastic about maintaining your own servers then a cloud service may not be that interesting. It's important to recognize, though, that Fanout is about more than just making push easy. It's about making it scalable.

...

Finally published! FTL because as soon as we made binaries available people started to download it before even I wrote an announcement. And FTL because, once again, we made so much performance improvements that we expect it to be faster than light. From version 2.0 I mention about huge performance improvements. Each time I believe nothing more can be squeezed out of the code and then I find another place to improve.

This is probably our biggest and greatest release yet. With so many new elements, components and functions. Therefore, we are really happy to give this version out to your hands. As usually binary files are available on the project tracking website.

Even though this is our first beta for the 5.2.0 it is already quite well tested and with next betas we expect a few more additions.

Here is a list of major new additions:

1. Cluster auto-configuration with cluster mode active by default
2. HTTP API with REST as the Tigase server component
3. Websocket support as a Tigase server connection manager
4. OSGi support built-in to the core of the Tigase XMPP Server
5. Message Archiving Component - XEP-0136
6. Socks5 Proxy Component with lots of interesting functions - RFC 1928
7. STUN Server Component - STUN
8. New API for SASL extensions and custom SASL mechanisms
9. API changes in plugin/processors, old API still available although deprecated, new API way faster (FTL) and less resource consuming
10. Optimizations, lots of them, we expect this version to be significantly faster and use less resources
11. Some metrics names changed to avoid confusion whether this is a number of elements waiting in queue or number of packets already processed
12. Custom RosterAbstract implementation can be now plugged from a configuration file
13. See-other-host implementation improved, now the redirection can be sent to the client after successful login. Still most of XMPP clients do not support this part of RFC so it is optional.
14. Improved multi-threading support, Timer replaced with ScheduledExecutorService where appropriate to avoid Timer single-thread bottleneck.
15. Extended per-vhost configuration at run-time with new parameters: s2s secret, default filtering policy,
16. Changed the way Tigase delivers messages to bare JID - now more common practice, delivers to all active resources
17. TLS required - full implementation, now Tigase won't allow user authentication without TLS if TLS required is set
18. The server whole active configuration is dumped to a text file which can be reviewed and/or copied to init.properties with custom values.
19. Invisibility through the extension - XEP-0186
20. Improved IPv6 support
21. Clientaccesspolicy.xml support added
22. Lots of s2s improvements and bug fixes

Please give it a try and let us know what you think. Any problems report or suggestions are always welcomed.

Jitsi 2.2 is now available for download here offering stability improvements and feature enhancements. In this release you will enjoy support for XMPP resources, support for Microsoft’s WASAPI audio system, significantly better audio quality over lossy networks such as Wi-Fi, improved conference call stability with Jitsi Videobridge (still a Work In Progress), better video calls and many other improvements and many sorted out problems of the video calls quality. We also now “push to talk” functionality, ability to set the video bit rate, improved window behavior and more readable history logging.

Jitsi downloads are available for Mac OS X, Linux and Windows and are completely translated in Bulgarian, English, French, German, Italian, Spanish. Partial translations for 19 more languages are also included.

Following is a list of the most important changes brought by this build:

• Adds an alternative to PortAudio using Windows Audio Session API (WASAPI) (Not yet but soon to become the default audio system on Windows).
• Adds the possibility to send message or call a specific contact resource over XMPP.
• Allows setting the video bit rate.
• Adds presence, avatars and phone types to the “Transfer Call” dialog.
• Fixes duplication of incoming messages and file transfer panels when show history in chats is enabled.
• Adds a new Jitter Buffer implementation that greatly improves audio in lossy networks such as Wi-Fi.
• Adds support for searching for contacts in Thunderbird address books.
• Adds organization name in LDAP and OS X Address Book search results.
• Detects video support in XMPP vCard-s (important for CUSAX deployments).
• Improves Jitsi Videobridge call stability (Work In Progress).
• Fixes false-alerts for chat window closing.
• Implements a way for users to disable call waiting via configuration.
• Fixes various problems with video calls.
• Adds “push to talk” functionality (quick unmute while pressing Ctrl+Shift+T).
• Prevents firewall prompts from popping up every time Jitsi is started on Mac OS X 10.6.
• Fixes copying of smileys, links and message headers in the chat history window (which wasn’t previously possible).
• Adds TLS client certificate login strategy for XMPP.
• Adds a minimal (configurable) duration for RTP DTMF tones.
• Adds retransmissions for 180 Ringing SIP responses over unreliable transports.
• Fixes NAPTR sorting by preference.
• Allows use of distinct (configurable) port ranges for audio and video streams.
• Improves incoming call window placement.
• Upgrades to latest ice4j version, for better WebRTC compatibility (Work In Progress).
• Makes conference related menu items available regardless of the currently active window.
• Fixes the event configuration file chooser to remember the last stored file location.
• Reverts to use of vanilla bouncy castle libs to address comments received during the Debian submission.
• Logs dates in all history files as ISO 8601 with time zone.
• Various other fixes and improvements.

See the full commit log here: http://goo.gl/AfKzq

Best regards from the Jitsi dev team!

I’m not easily persuaded to try out a new editor, but since I heard so many great things about Sublime Text, I decided to give it a try. After all, it looked a lot better and smoother than my old and rusty Vim, and I’m a sucker for look & feel. So, I took the free courses on tuts+, and tried it out for a while on my daily tasks. Here are my findings.

Let’s start with the pros:

• Sublime is cross-platform. I wouldn’t even consider using any editor that only works on one platform, so this one was a must.
• Not only does Sublime work on each platform, it looks and feels awesome on all of them. Very smooth, responsive, and appealing to the eye.
• One of the distinctive features is support for multiple cursors: You can make the same change to different parts of the text by simply selecting different parts, and starting to type, and you see the changes happening live. This is very handy for refactoring, such as renaming a variable.
• The command palette makes it very easy to do any operation you can’t be bothered to remember the shortcut for. Simply open the command palette, type a few letters, and Sublime will use fuzzy searching to suggest the command/option. Almost as good as remembering a shortuct.
• Every operation and option is available from the intuitively laid out menu. Not that you use the menu a lot (or even at all, thanks to the command palette), but it’s great for looking around and learning all the things you can do with the editor.
• You can quickly open files and jump to specific symbols using the Go to anything popup. I was already using this exclusively to open files on Vim through ctrlp, but Sublime adds support for symbols and lines to this interface as well, which can come in handy.
• You can trigger builds of your project while editing files, see the results, and quickly cycle through build errors. This integration is very well done, much smoother than in Vim for example.
• You can use Vim commands to move around and edit text, which is obviously nice if you’re used to those already, and means you can do lightning fast edits.
• Of course, there are lots of useful operations on text, with sensible keybindings
• Sublime is extensible, using a Python-based plugin system. There seems to be a very large and dedicated community, writing plugins for it, which means you’ll most certainly find all the integrations and features you want on the web.

Unfortunately, there are also some cons:

• Although Sublime is cross-platform, it seems to not have been designed for the user who actually uses it on different platforms. For example, the key-bindings differ from platform to platform, more than merely Cmd becoming Ctrl. This is probably rooted in Sublime’s decision to use shortcuts that are native to the platform. Remembering different shortcuts for different platforms is a nuisance, and causes regular incorrectly typed shortcuts when switching a lot.
• Settings are stored in fixed, platform-specific locations. Again, this is because Sublime chose to integrate with the OS as much as possible. However, this makes it hard to store your settings in a central Git repository, and share it across different machines and OSes.
• Sublime uses JSON as settings format. Although that sounds sensible, it actually has a big disadvantage: each line of your settings needs to end with a comma, except for the last line. This hit me almost every time I wanted to customize something. Another consequence of using JSON is that the settings file isn’t very powerful: since it’s basically just key/value pairs, you can’t do anything conditional (e.g. depending on which machine you are on), or source other files.
• There is no console version available. I regularly need to edit files on remote systems where I only have a terminal available. In that case, I need to switch back to another editor.
• And then the obvious one: Sublime is closed source, and not cheap. I don’t have anything against closed software per se, and I’d gladly pay the (relatively steep) price of the editor if I’m going to use it all day, every day. However, I have some practical problems: the systems I work on every day can’t run Sublime, since it is linked against older libraries than the ones I have available. Since I can’t recompile Sublime myself to link against the older libraries, it ends there. And then there’s the fact that I don’t like the idea of my editor’s life depending on one person’s focus and ability to avoid being hit by a bus. If the project dies, maybe someone will create a clone to support the current userbase, but I still consider it a risk.

I only tried Sublime Text 2, but since these issues are pretty fundamental, I don’t think they will have been addressed in the upcoming version. Since I had an uneasy feeling about these things, and was regularly hitting the issues over and over again, I finally decided to go back to Vim. However, I think Sublime Text is a great editor, and is probably the closest an editor will ever get to being a Vim alternative I find worth considering.

Alex has started the membership voting process (big shout-out and thanks to Lance for getting the bot updated!) and would love it if all the current members chat with the memberbot and vote on the 2013 Q1 membership applications.

Proxy voting will continue until the close of business on May 1st with the meeting to follow on May 2nd.

Default value:  RosterFlat.class.getCanonicalName() Example:  --roster-implementation=my.pack.CustomRosterImpl Possible values:  Class extending tigase.xmpp.impl.roster.RosterAbstract Description:  This property allows you to specify a different RosterAbstract implementation. This might be useful for a customized roster storage, or extended roster content or in some cases for some custom logic for certain roster elements. Available since:  5.2.0 Author:  Artur Hefczyc Date:  Wed, 2013-04-24 Product:  Tigase XMPP Server

Presenting at realtimeconf.eu

Just a quick note to say that I now consider my Epicurean dialogue on happiness to be finished, thus completing a journey of exploration that began five years ago when, thanks to my friend Manuel, I decided to start translating the ethical writings of Epicurus (although in fact I have been interested in Epicurus ever since I read and responded to Ray Shelton's paper "Epicurus and Rand" back in 1997).

...

Pushpin makes it easy to create HTTP long-polling and streaming services using any web stack as the backend. It's compatible with any framework, whether Django, Rails, ASP, or even PHP. Pushpin works as a reverse proxy, sitting in front of your server application and managing all of the open client connections. Communication between Pushpin and the backend server is done using conventional short-lived HTTP requests and responses. There is also a ZeroMQ interface for advanced users. The approach is powerful for several reasons:

• The application logic can be written in the most natural way, using existing web frameworks.
• Scaling is easy and also natural. If your bottleneck is the number of recipients you can push realtime updates to, then add more Pushpin instances.
• It's highly versatile. You define the HTTP exchanges between the client and server. This makes it ideal for building APIs.

...