As mentioned before, over the last few month I’ve been involved in quite a few integration projects, using mostly SugarCRM and Request Tracker. One of the interesting challenges was the Single Sign-On (SSO) between the two.
In my years of working as a system administrator I’ve done some pretty complex setups and integration solutions, but I don’t think I’ve done anything as twisted as this one recently. The setup is part of the large and complex client project, built on their infrastructure, with quite a few requirements and a whole array of limitations. Several systems were integrated together, but in this particular post I’m focusing primarily on the SugarCRM, RoundCube and Request Tracker. Also, I am not going to cover the integration to full extent – just the email related parts.
In the few jobs I had, I was responsible for creating a new system and integrating it with some other systems. The variety of the systems is pretty much irrelevant – anything from back office systems and CRMs to trading platforms and CMSs. The common factor between them is the integration is often done through some form of the API.
The most important lesson I’ve learned while working with third-party APIs is this:
Never ever use a third-party API directly from your application. Instead, create an abstraction layer between your application and third-party API.
This might seem like a bit of extra work, but, trust me, it’s not. It will save you plenty of time and frustration. Here are my reasons:
- Your own abstraction layer will help smooth out API’s edges. If you are using third-party API, chances are, it feels weird at times. It doesn’t matter what sets you off – function names, or required obvious parameters, or maybe the logic or order of calls that you have to make. Instead of getting annoyed every time, you can abstract all that weirdness into a separate layer, which will probably not change all too often. And your application coding will be more fun.
- Easier maintenance. Even the best APIs change. And when it happens, you don’t really want to go through all of your application and change all calls to the old version of the API. Especially, if the updated version is not fully backward compatible. Instead, you’d just rather update your API abstraction layer and be done with it. And if you do, like you should, have unit tests covering your API abstraction layer, it will be trivial for you to see if you broke anything or not.
- Easier reuse and more control. One of the biggest problems with third-party APIs is that you don’t control them. Third-party introduces features, bugfixes, upgrades, and maintenance down-times whenever THEY want. You rarely have much say in it. When you have a layer in between the third-party API and your application, you have more control as to how all those things affect your application.
- Easier migration to another third-party API. And you know that these things do happen. You’ve been using one provider of the service, and now there is a better one. If you were using first provider’s API directly from your application, you are pretty much in trouble now. Going through the whole application replacing calls to the new API, with different set of parameters, data types, and return values, is a huge undertaking. If only you had an abstraction layer, all you’d have to do now would be to change that instead. Sure, you might need to extend it a bit, or introduce changes to the currently used functionality. But, from my experience, such changes would be much smaller and simpler (since you are working with your code on both ends).
Google Reader has been recently integrated with Google Talk.Â Somewhat.Â If you use Google Reader and Google Talk, and you have some buddies in your Google Talk contact list, who also use Google Reader, then from now on you will be able to see each other’s shared items.Â Through the “Settings“, you can control who you want and don’t want to see in the “Friends’ shared items“.
This is a really nice piece of functionality.Â First of all, it saves you all the effort of finding and subscribing to “Shared items” RSS feeds of all your friends one by one.Â Â Secondly, it helps to highlight interesting stuff from your buddies, even those that you might accidentally omitted from your subscriptions.
So, what am I missing there?Â Two things.
First, the option to rename buddies.Â I am blessed with contacts who choose all sorts of nicknames and avatars.Â I prefer real names.Â And I attach real face pictures to all my contacts whenever I can.Â And I’ve done it in my Gmail contacts.Â That information should be used for the Google Reader friends list.
Secondly, I need an option to enter a discussion with my friends regarding an item in my Google Reader.Â That can be something I have shared, or that can be something my friends shared.Â I want a “discuss in chat” and “discuss in email” buttons.Â “Discuss in email” should be, in this case, different from “Email this item”.Â We both (me, and the friend with who I’m entering a discussion) have read the item.Â We just need a reference, like a subject, and URL to the item (original article?), just in case we need to run through it again or quote something.
While the second point is harder to implement (requires user studies, interface cluttering, etc), I’m really surprised that the first one wasn’t done.