Google Data » Jonathan LeBlanc

OpenSocial Version 2.0.1 Final open for voting

Jonathan LeBlanc — Wed, 16 Nov 2011 19:26:00 +0000

Version 2.0.1 of the OpenSocial specification has been released for voting. One of the major updates to the specification is finalized support for the OAuth 2.0 specification.

For more information on the changes to the specification and related components, please see the voting thread and file diffs here.

Jonathan LeBlanc (@jcleblanc)
Jonathan LeBlanc is a principal developer evangelist with X.commerce. Jonathan has been a member of the OpenSocial community for over three years and is the author of O'Reilly's "Programming Social Applications".

Join The W3C Social Business Jam

Jonathan LeBlanc — Wed, 19 Oct 2011 15:46:00 +0000

OpenSocial made significant strides over the past year with the introduction of new capabilities, and broadening its support and alignment with other standards like Activity Streams (http://activitystrea.ms/) and OAuth 2.0 (http://tools.ietf.org/html/draft-ietf-oauth-v2-22). One of the fundamental tenants of the community is to engage across the standards ecosystem to leverage adjacent standards and technologies when and where possible.

One way to continue the momentum of OpenSocial is to make a clear connection between the specification, the standards it includes and the needs of businesses. Social technologies are changing the businesses that have embraced and applied them but not not only for media. Businesses are using social technologies to better connect with partners, suppliers and employees -- as well as with customers.

But how are the ideas, technologies and standards in the social space holding up as business-use cases are applied ?

The W3C Social Business Jam is a global, online conversation with business leaders, subject matter experts and like-minded individuals about the current state of social business, the future role that social technologies can play in improving the bottom line, and how social technology should evolve in order to support business objectives. A primary objective of the Jam is to cooperatively explore key trends and concepts in social business with an eye towards how social standards can facilitate business goals. The Jam should produce a better understanding for participants of how businesses are using social technologies and the challenges they face integrating the technologies into their existing environments.

Mark Weitzel, president of the OpenSocial Foundation, is one of the noted hosts for the Jam. While Mark will be an active participant throughout the Jam, he is hosting a conversation on the Seamless Integration Of Social from 12 pm to 4 pm US eastern time on November 8.

Come share your insights and opinions. Registration is open and free, and takes just a few moments of your time. For more information, go to : http://www.w3.org/2011/socialbusiness-jam/

David Robinson

Bring OpenSocial gadgets to Moodle

Jonathan LeBlanc — Mon, 17 Oct 2011 22:14:00 +0000

We present here a plugin that allows to bring OpenSocial gadgets into Moodle. OpenSocial gadgets are rendered via Apache Shindig (extension of version 2.0 that supports Spaces).

Moodle is a Learning Management System used in many Educational Institutions (Universities) to manage courses. It is a plugin based PHP application that can be extended by installing additional modules. These modules have to be installed on a Moodle server by a system administrator. The Moodle view usually consists of a main center area and a rather narrow right column with blocks. The center area normally contains main resources, such as, wiki, forum, lesson, quiz, etc. The right block contains some helper plugins, such as, calendar, upcoming events, latest news, recent activity, etc. These are to extend the functionality of the main page.

There are two different OpenSocial plugins for moodle. The first one adds a new module to Moodle. It is very similar to pages in moodle, however in addition, OpenSocial gadgets can be specified. Once it is installed, a teacher can choose a "Widget space" to be added to the course and specify OpenSocial gadgets for it. The teacher can choose whether 1,2,3 column view should be used for gadgets.

The resulting outcome is the iGoogle similar view where students can work with gadgets.

The second plugin adds a new block to Moodle. Teacher can add OpenSocial gadgets to the right
column for already existing in Moodle wiki pages, lessons, forums, etc.

One of the main benefits is that the big pool of OpenSocial gadgets can be used by teachers. Thus, once the OpenSocial plugins are installed in Moodle, a teacher can extend the functionality of Moodle without bothering system administrators with plugins installation. The teacher can add and remove gadgets easily and even can write her own ones. The plugins greatly improve the flexibility in choosing the resources and applications for the course specifics. OpenSocial gadgets can be found in the open widget repositories, such as, Role Widget Store, iGoogle Directory, etc.

In addition to reuse of applications existing in the Cloud and flexibility in choosing applications for the course, contextual gadgets and OpenSocial API are the other additional benefits.

Space extension allows gadgets to adapt to a specific context. For example, wiki gadget saves data for a course and manages access to itself only by people engaged in this course. The same wiki gadget will behave differently being added to another course (different wiki history and different people to access it). Such space extension is already used in production in Graaasp and planned in Apache RAVE project.

OpenSocial API brings the standard way to retrieve and exchange social information between different Moodle installations and other social networks, that improves data portability and interoperability.

Plugins work for new version of Moodle 2.1. It should work for Moodle 2.0, though it was not tested. The installation instructions and source code can be found at github:
OpenSocial Moodle module
OpenSocial Moodle block

This plugin was developed within the ROLE Integrated Project and is already used in 5 courses at Shanghai Jiao Tong University.

Evgeny Bogdanov

OpenSocial 2.0 Brings Us Closer to the Socialized Enterprise

Jonathan LeBlanc — Tue, 20 Sep 2011 21:36:00 +0000

Now that the final version of the OpenSocial 2.0 spec has been announced, we at Wrike, as one of the companies leading the charge on social collaboration, are excited about seeing more enterprises lean into this type of integration. In fact, we’ve just developed our own OS 2.0 widget, which will help transform email functionality within Wrike’s collaboration tools. But before we tell you more about that, here’s why OpenSocial has our collaborative juices flowing.

Open season for innovation

It’s a safe bet that the typical iPhone user is used to working with direct access to multiple apps that can help him work and play more effectively. iPhone Marketplace was a bigger source of innovation for users than the phone hardware itself. Many enterprise solutions miss that open ecosystem opportunity today. For example, Outlook has millions of users spending their whole working days in front of it, who would love the same type of easy access to useful apps that would enhance their workflow. Yet, how many of those users installed Outlook plug-ins? OpenSocial 2.0 has the potential to open up innovation for enterprise software, bringing the right apps with the right integrations in a safe package, directly in front of users who want to benefit from them.

Bridging gaps between the apps

The improved safety, compatibility and connectivity that the OpenSocial standard offers, makes it a lot easier to build bridges between useful enterprise apps. Bridges that go beyond simple data integrations into the land of fully integrated user experiences. Taking my own company, Wrike, as just one example, we’re based on the belief that project management tools should be inherently social, and this is a fundamental part of our value proposition to companies around the world. So, it’s easy to see why OpenSocial has us excited about ways we can keep improving our users’ experience and their productivity, by plugging into the networks and tools they are already comfortable using.

Potential to turn email into a structured, real-time platform

A couple of days ago, Wrike’s widget appeared in the OpenSocial 2.0 sandbox with examples of embedded experiences in the activity stream, emailbox and a compact dashboard. I’d like to focus a bit more on the email component of the widget and share why we see great potential in it.

Email software has effectively been on “lock-down” since its inception. When you receive dozens of emails on a daily basis, it gets really challenging to turn that type of inbox chaos into the cohesive big picture of your projects and goals. From the start, a key pillar of Wrike’s product vision has always been to open up that software and bring emails into a centralized system, turning long email discussion threads into neat plans. This is why Wrike created its email integration, which allows users to create, assign, schedule and discuss tasks right from their inboxes.

Today, people use email even more than when Wrike was conceived. So, instead of try to push email out of the office toolkit “nest” (which seems like a hard and unproductive thing to do), we wanted to leverage the good things about it. OpenSocial 2.0 gives us new opportunities to implement our exciting idea – to turn 40-year email functionality into a structured, well-organized, real-time platform that supports sharing, discussions and other actions you need for collaboration. Wrike’s widget brings emails to life and integrates them fully into the project management process. Users don’t even need to change anything in their working habits.

In parallel with developing our widget for OpenSocial 2.0, we’ve been working on Wrike’s new add-on for Outlook. For the end user, the experience will be very similar to what they get with our OS widget. However, if we look at it from the development side of things, building this add-on atop Outlook is a more laborious and complicated process, a whole other world. That’s where we see the big difference between open platforms and closed systems – in how easily can you plug into them.

With the potential that OpenSocial 2.0 offers and the ease that you can build widgets on top of it, I believe that the world will quickly become attuned to getting this kind of experience for many more email clients. People still strongly rely on email in their work and they just need a way to naturally bring those messages into their collaboration process. So, it turns out that email isn’t dead as some claim, it just needed a rebirth, And OpenSocial 2.0 is an essential part of that evolution.

What’s next?

The new generation of apps, built on the open platform, will bring a new wave of innovation and productivity. OpenSocial has already gained support from many players in the enterprise software market. I’m sure we can expect new marketplaces and ecosystems, and faster innovation as others follow suit.

Users will of course be the ones to benefit, but it’s a win-win for everyone, as we continually find new ways to improve the way that we work. Your company’s mission should they choose to accept it? To socialize the enterprise.

Andrew Filev (@andrewsthoughts)
Andrew Filev is a software entrepreneur with more than 10 years of experience in project and product management. He is the founder and CEO of Wrike, a Silicon Valley-based provider of project management and collaboration software. To learn more about Andrew and his views, you can subscribe to his Project Management 2.0 blog or follow him on Twitter (@andrewsthoughts).

Announcing a New OpenSocial and Emerging Social Technology Book

Jonathan LeBlanc — Thu, 08 Sep 2011 23:18:00 +0000

I'm happy to announce that, as of yesterday, Programming Social Applications is officially out in print. I normally wouldn't post on the OpenSocial blog about my own book but the content is specifically designed for this community, so it's a good fit. Within the book I cover topics on:

Building social applications and containers using Shindig and OpenSocial.
The vast array of features and functionality within the OpenSocial specification.
Front-end code security tools like Caja and ADsafe.
Authentication systems with OpenID
Authorization systems with OAuth 1.0a and 2.0
Emerging social technologies like Activity Streams, Open Graph Protocol, PubSubHubbub, Salmon and others.

I will be conducting a webcast through O'Reilly on October 4th, 2011 at 1pm PDT to talk with everyone about the technology within the book and explore some of the interesting emerging technologies that are upcoming. More details to come shortly.

You can purchase the book here or get a free sample here. For those of you that pick up the book, remember that Chapter 12 (OpenID / OAuth hybrid extension), Appendix I (Environment Setup) and Appendix II (Terms) are offered as an online only download from O'Reilly since the book was getting a little large and we didn't want to simply delete content.

Please send feedback and tell me what you think - I'd love to hear from the community!

List of OpenSocial Containers

Jonathan LeBlanc — Thu, 25 Aug 2011 20:45:00 +0000

Recently there was a thread going around the OpenSocial and Gadgets Specification discussion board about providing an updated list of OpenSocial containers, both at the open and enterprise levels.

From this discussion, we have put together a living document to provide a list of those OpenSocial containers and implementers that we are aware of, including links to their associated information pages or developer networks. You can view the list here.

We Need Your Help

Since this is a living document, the content will always be changing as new containers surface or if we have left something off of the list. For everyone working with different container implementations, we ask that you review the list and help update the content if something is incorrect or missing. We really need the help from container implementers, users and those of you with an extensive OpenSocial container knowledge base to help out.

Thank you everyone.

Announcing the Release of the OpenSocial 2.0 Specification

Jonathan LeBlanc — Thu, 18 Aug 2011 23:28:00 +0000

Following the 11:59 PDT voting cutoff last night, version 2.0 of the OpenSocial specification has officially passed with 22 positive and 0 negative votes.

Version 2 of the OpenSocial specification opens up integration with other well known open source social specifications, ties in both a simplified gadget format as well as new powerful tools, plus announces some deprecated features.

Some of the major revisions to the specification include:

Activity Streams support: Activity Stream provides a mechanism for defining rich and detailed social activities, defined in a simple actor / object / target format. The adoption of this open specification allows OpenSocial to not only provide richer data sources but also to be interoperable with more open streams.

Deprecated support for ATOM: It was determined that the ATOM serialization format for OpenSocial information was not being utilized in practice. Since there were a number of adjacent specification utilizing JSON for the preferred data format, the community has decided to deprecate support for ATOM.

Simplified gadget format: Providing a mechanism for embedding template libraries into a gadget specification file, the ability to integrate data pipelining and templating features within a gadget has been greatly simplified.

Embedded Experiences: The community saw a need to provide a mechanism for providing embedded experiences directly within the gadget. By integrating these features, the content host is able to tell a service how to render its content instead of having the service figure it out themselves. This will provide a higher degree of control over data in a gadget.

New Incubating API
- OAuth 2 support: The OpenSocial 2.0 specification now includes support for OAuth 2. Since the OAuth 2.0 specification has not been finalized by the time of this release, OAuth 2 support is currently in an incubating mode. Currently revision 20 of the OAuth 2 specification is being integrated. Support for OAuth 1.0a is still included in the OpenSocial 2.0 specification and has not been deprecated.
- Common Container: In OpenSocial 2.0, a new optional specification has been added for a common container API. The goal is to simplify the container and gadget integration model. It provides a set of common services that Container developers can leverage for features like in-browser Gadget lifecycle event callbacks, embedded experiences, and selection and action handlers.

Here are a few links that will help you get up to speed on the recent changes and additions:

In addition to this announcement, Andrew Davis has another piece of great news on the Shindig side:

Along with releasing the OpenSocial 2.0 spec today, the OpenSocial Foundation is working together with our members companies, and implementor friends at Shindig are proud to announce the availability of the first OpenSocial 2.0 Container, running the latest Shindig 3.0 build, the Open Social Sandbox, at http://sandbox.opensocial2.org:8080/. The site is a live demo of the latest features of the OpenSocial 2.0 spec including Embedded Experiences, Declarative Actions, OpenSearch and powerful new open gadgets APIs to enable gadgets to jump out of the box. The site provides tutorials, demo videos and is geared towards enabling gadget developers immediately to build new gadgets, and test them out on the site through the "Customize" button.

Lastly, I wanted to say thank you to the entire community and dedicated participants who have made this major release possible.

Vote Now! OpenSocial and Open Source Presentations at SXSW

Jonathan LeBlanc — Thu, 18 Aug 2011 01:12:00 +0000

As a followup to our OpenSocial and SXSW Interactive 2012 post last month, we wanted to make available the links to the OpenSocial and associated technology proposals that have been submitted to the conference.

We would all greatly appreciate it if you could vote up these proposals to ensure that we have a technology presence at the conference next year, presenting the extensive new technology stack that is inherent within OpenSocial 2.0. There are a total of 3178 proposals in for this year and 30% of the decision-making process is up to community votes, so the more votes and comments we can get the better.

The proposals that we have available are:

Distributed Web Frameworks: The Future of Social
Link: http://panelpicker.sxsw.com/ideas/view/10692

Revolution! Open Apps Will Change the Enterprise
Link: http://panelpicker.sxsw.com/ideas/view/12817

Building Social Apps for Business Using Opensocial
Link: http://panelpicker.sxsw.com/ideas/view/12187

If you have a proposal on the technology or features behind OpenSocial I'd be glad to add it into this blog post - please comment on this post with the details.

Thanks everyone.

Building Dynamic Applications with Data Pipelining, Templating and YQL

Jonathan LeBlanc — Wed, 10 Aug 2011 23:12:00 +0000

Hello again everyone,

Today I wanted to go over one of the interesting things that you can do with OpenSocial using templating and data pipelining. Since these were introduced in version 0.9 of the specification, this functionality will not be available if:

The container that you are using does not support OpenSocial version 0.9 or later.
The container that you are using does not support data pipelining or templating.

With that said, let's get right down to an example. For this example, we're going to go through a few steps in order to scrape and display the recent headlines from Reddit:

We will use data pipelining to load in the headlines from Reddit.
The URL of the data pipe will be a dynamic call to the Yahoo! Query Language (YQL). YQL will be used to scrape the HTML from the page, then use an xpath to drill down to the repeating anchor tags that denote the headlines.
Lastly, from the JSON data that is returned back from YQL into the data pipe, we're going to use OpenSocial templating to display out the headline results.

Let's take a look at the gadget code behind this:

xml version="1.0" encoding="utf-8"?>

<Module>

   <ModulePrefs title="Reddit Headline Fetch"

      title_url="http://www.jcleblanc.com"

      description="Obtains reddit.com headlines via YQL"

      author="Jonathan LeBlanc">

      <Require feature="opensocial-0.9"/>

      <Require feature="opensocial-data" />

      <Require feature="opensocial-templates" />

   ModulePrefs>

   <Content type="html">

   

   

   

   ]]>

   Content>

Module>

Let's break down the components of this gadget. First let's start with the meta data within the node. There are three features that we will need to require:

First we have the OpenSocial version that we want to include. For our needs we can include version 0.9 of the specification since that will allow us to include the other features we need, namely our second and third Require statements for opensocial-data (Data Pipelining) and opensocial-templates (Templating). These three will give us the features that we need for the example.

Next we have the innards of the node. Let's explore the first This is our data pipelining section. When the gadget loads in the container that we are running it in, this section will issue an HTTP request to populate an object with the return value of the request. In our case this will be a GET request to the YQL service.

To define a data pipe, we set the type of the script block to text/os-data and then define the os XML namespace. Within the script block, we set the object that we want the data returned to to be "reddit". We then issue a data pipelining HTTP GET request to the YQL service, using the href attribute. This URL used includes the following components:

The public YQL URL: http://query.yahooapis.com/v1/public/yql

q: The YQL query to run, placed as a query string parameter.

format: The format to return our data in, in our case JSON. This is also placed as a query string parameter.
If we look at the query that we are using, we can see what the components of the request are:
SELECT * FROM html WHERE url="http://www.reddit.com"
AND xpath='//a[@class="title"]'
YQL uses a query syntax much akin to SQL. In our request we are using the html table, which defines request functionality to allow us to scrape data from an HTML page and then apply an xpath to drill down to the nodes on the page that we want to capture. In our case, we are capturing all data from http://www.reddit.com where the xpath (or nodes that we want to return) is any anchor tag that contains a class of title. If we explore the source code of http://www.reddit.com we can see that each title on the page is indeed an anchor tag with a class of title. At the end of the request the reddit object should now contain the return value from the request or, in other words, the headlines from the Reddit homepage.

Now let's look at the templating script block:
This is the block that will define the template for displaying our results. To define a templating script block, we define the type to be "text/os-template" and then we can include the object (in our case from the data pipelining request) that we want to make available to the template - we set this to "reddit" - the same value that we set as the key of the data pipelining request.

Now we can simply define the HTML that we want to use, with the variables, to display our results. For this simple use case we'll simply create an unordered list with all of the headlines displayed as anchor tag links. In OpenSocial templating, we can insert the value from a data source by including the variable that we want to act upon, displaying it in the format ${VARIABLE}. For instance, in our data pipe if we defined our key to be "foo" and in the foo object we have a sub-element named "bar", we could display it using ${foo.bar}. Another aspect about templating that we're going to be taking advantage of is repeaters. This will allow us to repeat a block of code for each object available, and is done so by adding a repeat="${OBJECT}" attribute on the block that should be repeated, in this case the
tag. This will create a list item for each headline we encounter.

Now, if we look at the HTML block knowing this, we can see that we are creating a root unordered list node, then creating a list item for each headline we encounter in the Reddit headlines object. The headlines are embedded in the object at reddit.content.query.results.a. Within each list item we display an anchor tag. The href of the anchor is set to that of the headline link and the text of the link is set to the headline that we get back from the query.

Once the gadget has rendered you should be presented with a very unstyled unordered list, which you may then apply CSS on to. Using this type of setup with a service like YQL, data pipelining, and templating, you can create gadgets that render very dynamic content while reducing the amount of coding that is needed.

Jonathan LeBlanc (@jcleblanc)
Jonathan LeBlanc is a principal developer evangelist with X.commerce. Jonathan has been a member of the OpenSocial community for over three years and is the author of O'Reilly's "Programming Social Applications".

New OpenSocial Community Groups on Facebook

Jonathan LeBlanc — Mon, 25 Jul 2011 20:38:00 +0000
Hello Everyone,

This will be a quick update for the OpenSocial community. I wanted to let everyone know that we have two new upcoming avenues for people to reach out to us on Facebook. This will allow us to build more communication channels for those wishing to talk with others who are working with or interested in OpenSocial, or the many open source technologies that it is integrated with.

So, with that said, here are the two new channels on Facebook for to take a look at - a page and a group:
Group: https://www.facebook.com/groups/206139742771249
Page: https://www.facebook.com/pages/OpenSocial/104087289690470
I will be adding and filling in the content on these pages in the coming days so that they are complete. Please feel free to use these channels to engaged with others in the community.

Jonathan LeBlanc (@jcleblanc)
Jonathan LeBlanc is a principal developer evangelist with X.commerce. Jonathan has been a member of the OpenSocial community for over three years and is the author of O'Reilly's "Programming Social Applications".

Calling All OpenSocial Container and Application Developers

Jonathan LeBlanc — Fri, 15 Jul 2011 14:42:00 +0000
Do you work on the implementation of a container or develop applications within existing OpenSocial containers? If so, we’d love to interview you in a new blog post series that will allow developers to showcase the new and innovative things that they are doing with OpenSocial.

We’re especially interested in hearing from the community about:

The challenges you’ve experienced while working with the specification and how you overcame them.

Are there any technologies or specifications that you’ve integrated with an OpenSocial container or application that you believe married well with the OpenSocial specification?

How is OpenSocial being used within enterprise solutions?
How is OpenSocial being used on mobile devices?

Are there any technical implementations that you thought worked especially well? Code implementations to showcase these integrations are always welcome.
Do you have any helpful tips, techniques or snippets that have been useful to you in the past?
Using these “OpenSocial in the wild” posts, we’re hoping to hear more voices from the community and give creators the spotlight. These are the people that are on the front lines, implementing, and hearing from them what works, what failed, and what customers took to as far as features will allow us all to better understand how this technology is being used.

If you would like to be heard, please e-mail me at nakedtechnologist at gmail dot com and tell me, in brief, what you’re doing with OpenSocial. I’ll ask you a series of questions from that initial overview and then feature you in our new “OpenSocial in the wild” blog posts.

Thank you.

Jonathan LeBlanc (@jcleblanc)
Jonathan LeBlanc is a principal developer evangelist with X.commerce. Jonathan has been a member of the OpenSocial community for over three years and is the author of O'Reilly's "Programming Social Applications".

OpenSocial and SXSW Interactive 2012

Jonathan LeBlanc — Fri, 08 Jul 2011 20:17:00 +0000

On June 20th, SXSW Interactive announced that they have opened their panel picker for submissions to the 2012 SXSW Interactive festival.

With all of the community efforts going on around OpenSocial 2.0, this would be a perfect time to submit a panel or talk on the wonderful efforts going on for OpenSocial and we ask that, as a community, we get involved in spreading the word around the integrated technology that are revitalizing the landscape of social application and container development.

An official panel will be submitted to discuss the new standards and technologies that are being integrated within OpenSocial 2.0. This will cover much of the work done on the specification, the future of OpenSocial, our enterprise involvement and the technology backbone that the new specification is being built around.

We would also love to see other members of the community submit talks about some of their involvements with OpenSocial. For instance, we'd love to see submissions about some of the following, just to name a few:
How OpenSocial foundations and techniques can be applied in a mobile strategy.
How new authorization models like OAuth 2 are fostering adoption of open standards.
How standardization of activities through Activity Streams are building a foundation for social sharing across platforms.
How OpenSocial is driving the socialization and communication channels of enterprise platform solutions.
If you submit a panel or talk, please respond to this thread to let us know (with a link to that talk) and I will work on compiling a list of the "OpenSocial community talks" for a future blog post. This will allow us to all vote as a community and show each other some support.

You can submit your talks here.

I look forward to hearing from all of you.

Jonathan LeBlanc (@jcleblanc)
Jonathan LeBlanc is a principal developer evangelist with X.commerce. Jonathan has been a member of the OpenSocial community for over three years and is the author of O'Reilly's "Programming Social Applications".