Individual language pack downloads will be restored once new instructions are translated.

Note: Psi 0.15 uses a new profile data format. Data from 0.14 and prior will be migrated to the new format when you run 0.15 for the first time.

Changes:
- Merge many changes from Psi+.
- New message history browser.
- New, fast contact list window.
- TURN proxying for voice calls.
- Store data in more standardized locations based on the platform.
- No longer dependent on the Qt3Support library.
- Domains ending in .local now always work, whether via DNS server or mdns.
- Windows 64-bit and Mac 64-bit now supported. Mac PPC deprecated.
- Legacy SSL port probe feature removed.
- Various small features and bugfixes.

Since 0.14, this version contains about two years worth of merges from the Psi+ project. Thanks to Rion and Dealer_WeARE for diligently keeping the Psi source repo current all this time.

Note: Psi 0.15 uses a new profile data format. Data from 0.14 and prior will be migrated to the new format when you run 0.15 for the first time.

Changes:
- Merge many changes from Psi+.
- New message history browser.
- New, fast contact list window.
- TURN proxying for voice calls.
- Store data in more standardized locations based on the platform.
- No longer dependent on the Qt3Support library.
- Domains ending in .local now always work, whether via DNS server or mdns.
- Windows 64-bit and Mac 64-bit now supported. Mac PPC deprecated.
- Legacy SSL port probe feature removed.
- Various small features and bugfixes.

Since 0.14, this version contains about two years worth of merges from the Psi+ project. Thanks to Rion and Dealer_WeARE for diligently keeping the Psi source repo current all this time.

Schedule:

Oct 3rd: Final

Note: Psi 0.15 uses a new profile data format. Data from 0.14 and prior will be migrated to the new format when you run 0.15 for the first time.

Changes:
- Merge many changes from Psi+.
- New message history browser.
- New, fast contact list window.
- TURN proxying for voice calls.
- Store data in more standardized locations based on the platform.
- No longer dependent on the Qt3Support library.
- Domains ending in .local now always work, whether via DNS server or mdns.
- Windows 64-bit and Mac 64-bit now supported. Mac PPC deprecated.
- Legacy SSL port probe feature removed.
- Various small features and bugfixes.

Since 0.14, this version contains about two years worth of merges from the Psi+ project. Thanks to Rion and Dealer_WeARE for diligently keeping the Psi source repo current all this time.

Schedule:

Sep 24: Final

Basically it’s a CDN service for outbound XMPP or HTTP traffic. For example, suppose you’re building an XMPP service that may have a lot of instantaneous outbound traffic (e.g. a pubsub service with many subscribers). Instead of trying to send a thousand stanzas yourself from a single server, you send a single stanza to Fanout, and it will delegate the transmission to a set of worker servers that each handle a slice of the deliveries.

It’s also got some really good HTTP stuff, for those that need it, like webhooks and long polling. Your one stop shop for scaling push.

Full announcement on the Fanout Blog.

If you’re working on any kind of website or app that delivers data in realtime, be sure to check it out. I hope that if Fanout is successful then it will enable me to put more resources into Psi and other interesting projects, so your support is welcomed and encouraged.

It’s easy to blame this long cycle on my inability to contribute much since early 2010, but it’s not as if contribution in general was lacking. The Psi+ project has remained steadily active, and a couple of years ago we gave commit access to Sergey (Rion), one of the Psi+ founders, and then later on to Khryukin (Dealer_WeARE), another Psi+ developer. Together, they have been merging changes upstream from Psi+ to Psi all this time. I’m amazed at their dedication, having maintained both repositories for years even though Psi had no clear roadmap or release plan. They are choosy about what to merge, too. Many traditional Psi users regard the Psi+ application as a scary patchfest, but the Psi+ developers are no fools. Sure, they enjoy a bleeding edge app, but they also know what’s ready and what isn’t, and only the stuff that is ready finds it way back into Psi. For better or worse, Psi+ is where the action is, so get used to their code being the basis of new Psi releases.

This isn’t to say there haven’t been non-Psi+ contributions to 0.15. A big one is TURN proxy support for voice calling. You can set up a TURN server, and finally put an end to voice call connectivity problems. This feature was actually implemented just after Psi 0.14 was released, back when I was working at Barracuda Networks. Finally it sees the light of day! Additionally, Michail (mblsha) merged his rewritten contact list code. It uses the Qt 4 model stuff. You can select and drag multiple contacts now, and it should be a lot faster too. This new contact list code, along with some other changes (like the rewritten history window), helped us transition away from Qt3Support at long last. This was primarily important so we could compile against the Cocoa version of Qt/Mac. Of course it’s also nice to be relieved of having to link to unnecessary libraries like QtSql. Either way, it’s about time we officially got off of Qt 3. Seriously. Qt 4 has been out for like 7 years, and Qt 5 is just around the corner. Seeeeriously.

So if we’ve had features in the queue and regular contribution, why the hold up? Well, the real reason it has taken so long to get 0.15 out the door is because making a Psi release is just plain hard. Particularly with the introduction of GStreamer as a dependency since 0.13, a considerable amount of compilation judo is needed to produce official binary packages. Psi has some 20 dependencies. Keeping these current, and producing builds for both Windows and Mac takes more than a passing familiarity with the project. We got by when I was at Barracuda because it was my day job to make this stuff happen. I was also provided various build machines. These resources are now gone (which included a PowerPC Mac, which is one reason why Psi 0.15 is not available for PPC, not that anyone cares). In order to produce Psi builds again, I needed to recreate the environment I had at Barracuda. Actually, I needed to do it one better: I needed to automate as much as possible so that not only Psi but dependencies could be maintained using minimal brainpower. It needed to be possible for me to push a single button and get a release, with no arcane steps that I’d soon forget the moment I switch focus away from Psi.

In March of this year, I set out to build this magical solution. The result is a new repository, psideps, which handles the building of dependencies, as well as some additional scripts in Psi’s own repository to simplify building Psi itself. It’s all a bunch of bash scripts and makefiles, and fairly straightforward. The devil is in the details though. Most dependencies required patching to build properly, and a lot happens in three years. Growl went payware. Ndhotkeyevent only built with clang. Glib atomic operations got broken on Mac. GStreamer had some critical regressions. Build patches were numerous. Psideps has 24 .diff files, and that’s not even including any ad-hoc sed crap I do to some of these packages. My favorite patch is the one where I slow down certain configure scripts (by injecting sleeps) because they execute too fast on MinGW and cause random failures. Also, people expect 64-bit builds these days, so the scripts do multiple passes, and of course all that fun install_name_tool stuff in Mac’s case. It’s not like all dependencies built cleanly in 64-bit either. I mean, that would have been too easy. Getting this all correct took patience. Builds take a long time, especially in VMs. Suddenly, the Windows build of some dependency breaks. I fix that, but in the process break the Mac build. No wait, it’s only the 64-bit pass on Mac that I broke, so I’ll need to fix in a way that doesn’t break 32-bit. This is build failure whack-a-mole. Rebuild again. Wait 30 minutes again. Curse all of these dependencies of which I am not an author… again. Finally, everything builds in every combination and there is harmony. All in all, it was a lot of time spent, and hardly any of it was on Psi itself. I did use the past couple of weeks to shake out bugs and get Psi into a release quality state, but all other time since March was put towards build automation. I am quite sick of watching compilations at this point. However, this work was hugely important. The notion of building a Psi release has gone from something completely unapproachable (by its own founder!) to something one might do while sleeping.

Lately I’ve been wondering where to go from here. Originally, Psi was created to suit myself and other IM geeks. It became a bit more than that, though, inadvertently becoming a flagship XMPP client of sorts, and there were a run of sponsored forks promising greater user-friendliness. I’d like to think Psi helped further open IM in general, and for awhile this was my major motivation. However, nowadays XMPP is everywhere, and implemented in some pretty amazing clients. Most people I know use Adium, iChat, Pidgin, Gmail, etc. Empathy/telepathy is taking over desktop Linux. What role does Psi play in this world, where XMPP has already won? I’m happy to report that since 0.15 Beta 2, Psi has already been downloaded over 8000 times from SourceForge. That’s in just two weeks. I guess the role it plays is an app that many people seem to like. Perhaps that is good enough, and we can put the MSN-looking forks and world domination plans to rest. Psi has its niche.

Even after all this time, I still love hacking on Psi, and the challenge has always been balancing it among my other responsibilities. Now that we are on track to be able to produce releases again, I hope we can return to a routine again of releasing semi-regularly, even if it continues to just be patches from Psi+.

Enjoy.

Note: Psi 0.15 uses a new profile data format. Data from 0.14 and prior will be migrated to the new format when you run 0.15 for the first time.

Changes:
– Merge many changes from Psi+.
– New message history browser.
– New, fast contact list window.
– TURN proxying for voice calls.
– Store data in more standardized locations based on the platform.
– No longer dependent on the Qt3Support library.
– Domains ending in .local now always work, whether via DNS server or mdns.
– Windows 64-bit and Mac 64-bit now supported. Mac PPC deprecated.
– Legacy SSL port probe feature removed.
– Various small features and bugfixes.

Since 0.14, this version contains about two years worth of merges from the Psi+ project. Thanks to Rion and Dealer_WeARE for diligently keeping the Psi source repo current all this time.

Schedule:

Sep 17: Final

With Livefyre, comments feed into the page live with no refresh needed.  The system is social: you follow friends and topics, and get notifications when interesting things happen across the web (e.g. “Your friend Julia has just commented on the article ‘The Internet Needs More Cats.’”).  We also do things like keep track of every user’s reputation for automatic moderation, and drive traffic to other bloggers based on user interest.  We want to shift website comments from being silo’d and disconnected, where hardly anyone knows who is leaving what comments and on what websites, towards a highly connected and social system, where website comments become as relevant to people as their Facebook news feed.

And yes, it is powered by XMPP.

Check out the Livefyre website, and be sure to read the TechCrunch article.

In this article we’ll talk about a tool that can assist with making our objects behave properly: ObjectSession.  It is just one of many tools I’ve come up with over the years, but I’m starting to feel confident enough in it that I figure it is time to talk about it.

Introducing ObjectSession

The great thing about ObjectSession is that the concept is quite simple and yet it manages to solve many problems.  The way it works is you create an ObjectSession instance that keeps track of a “session” of queued signal/slot activity.  Instead of using QMetaObject::invokeMethod() or QTimer to perform queued calls directly, you tell your ObjectSession to perform these calls, with the advantage that you can reset the session at any time to cause all queued calls to be canceled.

Additionally, there is ObjectSessionWatcher which can keep track of session validity.  You know the old trick about using QPointer on the stack, to find out if your object has been deleted after you emitted a signal?  ObjectSessionWatcher is intended to replace this usage.  You create it on the stack in the same way as QPointer, but you use it to find out if your session has been reset instead of if your object has been deleted.  This allows you to easily provide signal safety for all methods, not just destructors.

ObjectSession can currently be found under src/irisnet/corelib in the Iris SVN.  Here is a snippet from objectsession.h:

class ObjectSession : public QObject
{
        Q_OBJECT

public:
        ObjectSession(QObject *parent = 0);
        ~ObjectSession();

        void reset();
        bool isDeferred(QObject *obj, const char *method);
        void defer(QObject *obj, const char *method,
                QGenericArgument val0 = QGenericArgument(),
                QGenericArgument val1 = QGenericArgument(),
                [...]);

        [...]
};

class ObjectSessionWatcher
{
public:
        ObjectSessionWatcher(ObjectSession *sess);
        ~ObjectSessionWatcher();

        bool isValid() const;

        [...]
};

There are a few more methods available than shown above, but these are the main ones.

Now let’s go over some usages.

Basic setup

Usually you’ll have just one ObjectSession per object, set up like such:

class Foo : public QObject
{
        Q_OBJECT

private:
        ObjectSession sess;

public:
        Foo(QObject *parent = 0) :
                QObject(parent),
                sess(this)
        {
        }
};

Note: The defer() call allows you to make queued calls on any object, so it is not necessary for the ObjectSession to live in the “public” object like this. You can easily tuck it away in a private class d-pointer if you want, and still target signals of the public class.

Emitting a delayed signal, with ability to retract

The defer() call works just like QMetaObject::invokeMethod(), even allowing you to specify arguments.

void Foo::startServer()
{
        udp = new QUdpSocket(this);
        if(!udp->bind())
        {
                // app expects the error() signal to be asynchronous
                sess.defer(this, "error", Q_ARG(Foo::Error, ErrorBind));
                return;
        }

        [...]
}

void Foo::abort()
{
        sess.reset();
}

Now the user can call startServer(), abort(), startServer() all in a row without returning to the event loop and there is no worry that the above signal might accidentally be misinterpretted as part of the second “session”. The sess.reset() method destroys the deferred call queue.

Safely emitting a signal in the middle of a code block

Instead of using QPointer to check if your object is destroyed, use ObjectSessionWatcher to see if your object state is still sane.

void Foo::tcpSocket_connected()
{
        [...]

        ObjectSessionWatcher watch(&sess);
        emit connected();
        if(!watch.isValid())
                return;

        tcpSocket->write("hello world");

        [...]
}

void Foo::abort()
{
        sess.reset();
        tcpSocket->deleteLater();
        tcpSocket = 0;
}

Now if you emit connected() and the user calls abort() during that slot, the watcher is immediately notified that the session is no longer valid. This way we can bail out instead of crashing on the next line.

Note that destructing ObjectSession also causes any watchers to be invalidated, so we get signal-safety of the destructor for free too.

Emitting multiple signals in a row

There are a couple of ways to do this. One way is to use deferred signals for all but the first:

void Foo::someFunction()
{
        [...]

        sess.defer(this, "sig2");
        emit sig1();

        [...]
}

The other way is to use a watcher:

void Foo::someFunction()
{
        [...]

        ObjectSessionWatcher watch(&sess);
        emit sig1();
        if(!watch.isValid())
                return;
        emit sig2();

        [...]
}

Which way you do it depends on your mood. The second method is a little more straightforward, but has the drawback that if the user invokes a nested eventloop in response to sig1(), then sig2() will not be emitted during the new eventloop. So for example if sig1() causes a modal dialog to appear, then the object might seem like it is blocking or not working until the dialog is dismissed.

(That said, nested eventloops are pure evil and will cause you all sorts of problems anyway. Can you imagine other events suddenly activating in your object, while someFunction() is still sitting there partway executed? Maybe even causing other signals to emit, before sig2() ? Yeeeesh..)

Deferring calls to your own slots

In all the examples so far we’ve used defer() to invoke signals, but it is also useful for queuing up calls to your own slots. Here’s an alternate way to handle the delayed signal from earlier:

void Foo::startServer()
{
        // set object state
        state = Starting;

        udp = new QUdpSocket(this);
        if(!udp->bind())
        {
                // process the error later, so object state remains consistent
                sess.defer(this, "slot_bindError");
                return;
        }

        [...]
}

int Foo::state() const
{
        return state;
}

void Foo::slot_bindError()
{
        // now we atomically change the state and emit error
        state = Inactive;
        emit error(ErrorBind);
}

void Foo::abort()
{
        sess.reset();
}

There is also deferExclusive() to ensure that a call is only queued once at a time. This is useful for making sure an “update”-style function runs at the next eventloop.

void Foo::sendText(const QString &str)
{
        queueOutboundData(str);

        // make sure we push out pending data at the next eventloop
        sess.deferExclusive(this, "doSend");
}

void Foo::sendPhoto(const QPixmap &p)
{
        queueOutboundData(p);

        // make sure we push out pending data at the next eventloop
        sess.deferExclusive(this, "doSend");
}

void Foo::doSend()
{
        // push all items in the queue out the network
        [...]
}

If the session is reset, such deferred slot calls would get canceled in the same way that deferred signals do. How convenient! Now you can avoid having background slots continuing to execute when they shouldn’t be.

Conclusion

ObjectSession is a simple class that can be used to solve a number of problems with QObject development that are otherwise quite awkward to solve. The key for me was to discover that almost all of the problems have to do with an object switching states, stopping, or being destroyed. So, if there could be a simple way to manage those situations then we could solve just about everything. I’m using ObjectSession in a few of my classes now and I’m quite pleased at how easy it is.

Happy coding!

New in 0.14
- Added color options to the chat window.
- Can now specify a reason for kick/ban in groupchat.
- Improved User Info window, to show more fields and photo view/save.
- Support for Enchant as an alternative to Aspell.
- Commandline interface now supports choosing profile and setting status.
- D-BUS interface now supports setting status and indicating sleep/wake.
- Fixed voice calling compatibility bugs with Pidgin and Empathy.
- Various other minor improvements and bugfixes.

Final on December 2nd if no showstoppers are found.

New in 0.14
- Added color options to the chat window.
- Can now specify a reason for kick/ban in groupchat.
- Improved User Info window, to show more fields and photo view/save.
- Support for Enchant as an alternative to Aspell.
- Commandline interface now supports choosing profile and setting status.
- D-BUS interface now supports setting status and indicating sleep/wake.
- Fixed voice calling compatibility bugs with Pidgin and Empathy.
- Various other minor improvements and bugfixes.