MySpace Open Platform

New Features for OpenSocial 0.9 REST APIs

krunal — Wed, 18 Nov 2009 00:38:00 GMT

Hi everyone,

We are extending our 0.9 REST API offerings by adding new endpoints as well as adding new features to existing endpoints to make our 0.9 offering richer. We are committed to exposing data through Open Standards so app developers can create the finest applications on the web. Some of these new features are not part of the previous MySpace REST APIs so this should encourage you to switch to 0.9 if you haven’t done so already.

The link to the main resource page for REST 0.9 APIs is located here. Please find documentation links and highlights of these new features below. Please review our Terms of use, especially Section 10.2, before you start using these features.

New Endpoints

StatusMoodComments

This endpoint provides a way to fetch the comments posted on a user’s StatusMood updates. It also provides a way to request the comment author’s basic info (image, name and profile URL) along with the comments themselves. This could reduce the number of calls to the server you need to make if you plan on displaying the commenter’s data along with the comments.

Please see details here.

ProfileComments

This provides a way to fetch the comments posted on a user’s profile. It also provides a way to request the comment author’s basic info along with the comments, which again will reduce the number of calls to the server if that information is needed.

Please see details here.

MediaItemComments
You can now fetch comments posted on a user’s images and videos. Again, this endpoint allows you to fetch the comment author’s basic info to save a second request to the server.

Please see details here.

Enhancements

StatusMood

The StatusMood endpoints now offer APIs to fetch friends’ status mood updates as well as provides a way to fetch StatusMood history.
Apps can also fetch recent comments on a user status in the same call.
MySpace now allows syncing/updating StatusMood from various sources like Twitter. You can get that information in your requests.

Check the documentation for the StatusMood APIs here.

Also don’t forget to check out the filters that this endpoint has to offer.

Activities

We are also adding Activity Streams extension properties to activities returned from our OpenSocial 0.9 Activities endpoint in this release. Activity Streams is a data format that describes what people are doing around the web, for example: posting photos and videos, sharing music with friends and writing blog entries. If you are already familiar with the Activity Streams atom format, you can now access all the Activity Streams goodness, like actors, verbs, objects and object-types, in JSON and plain old XML. Find more information about Activity Streams on the http://activitystrea.ms web site.

Check out the MySpace implementation for the same here.

SDKs

Our PHP and Java SDKs have been updated to support these new features and the others are in the works. Also, these new features are developed using Open Standards like OpenID, OAuth and OpenSocial which should help make your experience smooth.

Also, if you have missed out, visit this earlier blog post for more information about complete suite of REST 0.9 APIs.

Happy coding!

Community Success Story: Review site Qype leverages MySpaceID for login and sharing content

beriberikix — Tue, 27 Oct 2009 16:49:00 GMT

While MySpaceID employs a number of powerful features for your site, two in particular are extremely meaningful: a simple user login and a streamlined process to push content into the MySpace stream. Qype, a pan-European local review site, often called “The European Yelp,” recently integrated with MySpaceID in order to leverage Single-Sign On and Activity Publishing.

Qype uses the MySpaceID log in flow and pulls in user’s data to pre-fill a user’s Qype account:

MySpaceID simplifies and encourages users to login, and guarantees quality user data for Qype.

Once a user fully registers, Qype can publish their reviews into MySpace - providing unique and interesting content in the MySpace Stream- and driving traffic back to Qype

Interested in learning about how you can publish into the MySpace stream? Check out our latest documentation on the MySpaceID JSL (JavaScript Library). Interested in what else MySpaceID can do for your product or brand? Our additional MySpaceID docs should fill you in.

Happy coding,

./BBK

Introducing MySpaceID JavaScript Library (JSL)

Donny Mack (DM) — Wed, 14 Oct 2009 02:21:00 GMT

One of the great things about working here at MySpace is that we believe in open content distribution.

As you may have noticed during the past month, we’ve made significant strides in establishing MySpace as a test bed for innovation among the developer community with the rollout of our Qizmt computing framework, MySpaceID integrations with Tweetdeck and Windows Live among others, and the most recent Twitter sync functionality.

Today, we’re adding another enhancement to our list of MySpaceID offerings, our MySpaceID Javascript library (JSL).

In this initial launch the MySpaceID JSL will enable your site to:

Raise activities on behalf of the current user that will show up in their activity stream on MySpace
Make a subset of client-side OpenSocial calls
Retrieve an authorization token for further server-to-server calls for the user.

Check out the docs. here for more information. Also, check out our sample app on appspot: http://myspaceidjsl.appspot.com/ which illustrates all currently supported functionality.

The first two sites to use the MySpaceID functionality are Daily Fill and Redux, making it easy for users to securely bring content experiences from those sites to MySpace to share with friends. Both serve as popular forms of entertainment among users and align with our ongoing efforts to enhance the social entertainment experience.

Find and enjoy videos, photos, music, and websites recommended by people who love the same stuff you do. Link your MySpace account and keep your MySpace friends updated on what you’re up to on Redux.
Login to Daily Fill with your MySpace credentials – no need to create a new account, and post celebrity news articles you like into your MySpace activity stream.

Here’s a screenshot of the new experience on Redux:

Here’s what an activity from Daily Fill looks like in the user activity stream:

Code Sample: Here is a easy to follow example of how to raise activities and make OpenSocial calls with MySpaceID JSL: Example Usage

Given our commitment to open standards, such as OpenID, OAuth, Portable Contacts, OpenSocial, and Activity Streams (all used to create MySpaceID), the ability to allow users to bring in external content was a natural progression for us and we’re excited to see how users respond. As we continue to help set the standard for open authentication on the web, MySpace users can expect to see integrations with many more of their favorite destinations around the Web.

To keep you posted on cool sites integrating with MySpaceID, we launched a new page dedicated to highlighting featured implementations where you can link your MySpace account. Check it out here: http://www.myspace.com/myspaceid.

Visit these earlier company blog posts for more information about our initiatives to further promote open content distribution through collaborations syncing with Twitter, Windows Live and Tweetdeck, in addition to the recent open-sourcing of Qizmt and MSFast.

Full Support of OpenSocial 0.9 REST APIs Now Available

Chad Russell — Mon, 21 Sep 2009 21:28:00 GMT

We are pleased to announce our full support of OpenSocial 0.9 today. Last week we gave you a sneak peek of our OpenSocial 0.9 support by launching our photo API. This week we’re taking it one step further: we’re releasing all of our current OpenSocial 0.9 REST APIs as a public BETA. Here at MySpace we are committed to open standards, and will continue to support community driven protocols like OpenSocial. We’re very excited to take this big step to support OpenSocial 0.9!

Our OpenSocial 0.9 implementation was built on an entirely new framework with three main goals in mind for developers: stability, performance and compliance to the OpenSocial 0.9 specification. These three goals will yield more consistent results, fewer errors, and means that your code should be even more portable to other social networks that support OpenSocial.

While we’re labeling this as a BETA we feel our APIs are in a very solid state and are ready for widespread use.

The PHP and C# SDKs have been fully updated to use all of the new 0.9 APIs we have available. The other SDKs are currently being updated for your use.

Documentation for all the API’s can be found below. In addition to the wikis we’ve started to update the community supported SDKs found at opensocial.org. As always, make sure to review our Terms of Use, especially Section 10.2, before you start using the new endpoints.

Happy coding!

Activities

Provides the event data found in the MySpace Activity Stream.
http://wiki.developer.myspace.com/index.php?title=OpenSocial_v0.9_Activities

Albums

Support for fetching, creating and updating photo albums.
http://wiki.developer.myspace.com/index.php?title=OpenSocial_v0.9_Albums

AppData

A generic key/value store that your app can use to fetch, update and delete data relevant to your app.
http://wiki.developer.myspace.com/index.php?title=OpenSocial_v0.9_AppData

Groups

Provides information on a user’s friend categories.
http://wiki.developer.myspace.com/index.php?title=OpenSocial_v0.9_Groups

MediaItems

Photo support, including photo uploads.
http://wiki.developer.myspace.com/index.php?title=OpenSocial_0.9_MediaItems

People

Gives access to a user’s profile data, as well as their friend’s profile data.
http://wiki.developer.myspace.com/index.php?title=OpenSocial_v0.9_People

StatusMood

Allows support for updating and fetching a user’s status and mood, as well as fetching their friends’ status and mood.
http://wiki.developer.myspace.com/index.php?title=OpenSocial_v0.9_StatusMood

Notifications

Create app notifications that are displayed in the recipient’s mail center.
http://wiki.developer.myspace.com/index.php?title=OpenSocial_v0.9_Notifications

Microsoft enriches Windows Live, Messenger, and Hotmail products by using MySpace’s ActivityStrea.ms API

Donny Mack (DM) — Mon, 14 Sep 2009 17:54:00 GMT

Posted by Monica Keller, MySpace Group Architect, Activity Streams

I’m excited to announce that today Windows Live will start broadcasting MySpace user activity streams to their Windows Live Platform via MySpaceID. The MySpaceID integration with Windows Live keeps you updated on what’s happening on MySpace. Windows Live users can see their activities from MySpace, and those activities can now be distributed across the Windows Live network, enhancing their user experience by providing rich contextual user information. Now you can see the following activities from within Windows Live, Windows Live Messenger, and Hotmail:

Status updates
Blog Entries
Photo uploads
Music

And more activities coming soon... Click here to learn about our activitystrea.ms api.

To check out this MySpaceID integration, do the following:

1. Sign into your Windows Live account by visiting http://profile.live.com/WebActivities/add.aspx?AppID=1140860417

2. Click Add web activities

3. Choose MySpace from the options

4. Add MySpace to your Windows Live account

5. See all your MySpace activities and share them with your Windows Live network

Our Windows Live MySpaceID implementation is built on the activitystrea.ms open standard, making today’s announcement another important step forward in MySpace’s continued commitment to promoting open standards across the Web. Utilizing an increasingly open Web enables our users to broadcast, discover, and express themselves in richer ways across multiple networks.

I hope you enjoy and let us know what you think.

Thanks,

Monica

MySpace Group Architect, Activity Streams

OpenSocial 0.9 Photo Support With Uploads Now Live

Chad Russell — Fri, 11 Sep 2009 22:05:00 GMT

Today we’re pleased to roll out the OpenSocial 0.9 Media Item and Album endpoints, which allows you to upload photos to MySpace and perform other photo and video related functions using MySpaceID and OpenSocial Apps.

This new endpoint was built from the ground up with an eye on performance. It should add some nice gains in terms of stability and performance over the old API and you should start seeing fewer errors, especially during the upload process.

To allow you to start really digging into it we’ve created a couple of wiki pages that should help you get up and running.

http://wiki.developer.myspace.com/index.php?title=OpenSocial_v0.9_Albums
http://wiki.developer.myspace.com/index.php?title=OpenSocial_0.9_MediaItems

Another quick way to get started consuming the new photo functionality are the SDKs. There is a list of community supported SDKs linked to by the OpenSocial Foundation’s official website that we are helping to update for 0.9:

http://wiki.opensocial.org/index.php?title=Client_Libraries

We’ve completed the PHP and C# SDKs, so you can check the individual SDK sites for further details.

For Adobe AIR applications that use MySpaceID, we also have an AS3 SDK, which can be found at:

http://wiki.developer.myspace.com/index.php?title=Category:MySpaceID_SDK_for_ActionScript_3

This SDK only uses 0.9 for photos. The rest of the SDK methods use the 0.8 REST APIs until we release broader 0.9 support.

Before you start using the new photo endpoints, we ask that you review our Terms of Use, specifically Section 10.2:

http://wiki.developer.myspace.com/index.php?title=Developer_Addendum_to_MySpace.com_Terms_of_Use_Agreement

MySpace integration with TweetDeck Goes Live

Gerardo — Wed, 09 Sep 2009 13:13:00 GMT

We are excited to announce a MySpaceID integration with TweetDeck, a personal browser for staying in touch with what’s happening now, connecting you with your friends on MySpace and other social networks – all in one place.

The MySpaceID integration with TweetDeck lets you stay in touch with everything that's happening on MySpace sorted with columns for status and moods, comments on your profile and your friends' activity stream, including playlists, photos, events, videos, apps and more. You can receive notifications to make sure you don’t miss a thing.

With this integration you can keep your finger on the pulse of MySpace in TweetDeck as well as:
•      Update your status and mood from TweetDeck.
•      Stay in touch and see your Friends’ Status and Mood easily.
•      View photos, events, videos and more in Friends’ Activity Stream column.
•      Preview MySpace photos and albums.
•      Keep an eye on your profile with the ‘My Comments’ column.

Let us know what you think of this integration and happy connecting! For more information and to download it for free, visit www.myspace.com/tweetdeck and http://tweetdeck.com.

“New App Notifications!” indicator is now live

CodeStorm — Thu, 27 Aug 2009 18:38:00 GMT

We’re happy to announce a new engagement component for apps: Notification Alerts. When users receive notifications, they will see a “New App Notifications!” alert on their user home page.

New alerts are shown just below the main profile image when a user first logs in. Below is a screenshot of how indicators look:

Clicking the alert takes the user directly to the app notifications section of the mail center:

Notifications are a great way to keep users engaged (we’ve already seen good numbers for apps using them!)

Are your apps using notifications? To learn how to implement notifications (and start showing these indicators,) see our documentation on how to get started with notifications.

Any feedback? Let us know below.

Digsby gets an upgrade and adds MySpaceID

Brandon Black — Thu, 13 Aug 2009 05:43:00 GMT

We’re excited to let everyone know that our friends over at Digsby just released a new version of their feature-rich, but incredibly lightweight all-purpose chat client yesterday which now includes an incredibly note-worthy implementation of MySpaceID.

For those of you who aren't familiar with it, Digsby is a desktop application that allows you to simultaneously use all your favorite IM clients (AIM, Yahoo, GoogleTalk, MSN, Jabber, ICQ) and keep track of your email inbox all in once place. Digsby also provides some very handy integration with all your favorite social networks where you can keep track of what all of your friends are doing and receive notifications straight to your desktop. Additionally, through the use of your Digsby.com account, Digsby allows you to organize your friend lists and take all your settings and preferences with you to any computer you are using.

Digsby's newest release includes a ton of useful new features, here are just a few of them:

MySpaceID and Activity Stream - Powered by the MySpaceID APIs and open standards including OpenID and OAuth, you can now view your entire activity stream, update your status, receive messages and notifications from MySpace, and much more straight to your desktop using Digsby. The seamless integration between Digsby and MySpace allows you to do much of what you can do on MySpace's website, including browsing photos straight from the activity stream. This is a great example of how any developer can add incredibly rich social networking features to their application quickly and easily using MySpaceID.

Global Status - A new status update dialog that allows you to set your status across all your social networks and Twitter in addition to all your instant messaging networks. This new dialog for setting your global status includes spell checking and the ability to easily share links and photos with others directly from your status.

Digs.by (URL Shortening) - Along side the new global status update dialog that was introduced with this latest release, Digsby is adding a URL shortening service specifically for Digsby users. This new URL shortening service will serve all links from http://digs.by and in the future the team at Digsby plans to provide history, tracking, and statistical information to this URL shortening service.

Great work by the Digsby development team! We can't wait to see what cool features they come up with next.

What is MySpaceID? Watch a video explaining it here.
To learn more about integrating MySpaceID into your website or application, click here.
To learn more about Digsby, please visit http://www.digsby.com
To download the latest version of Digsby, please click here.

Fix For appInvites and IFrame app

Donny Mack (DM) — Fri, 31 Jul 2009 19:16:00 GMT

We’ve heard from a few developers that they are currently experiencing a few issues with Application Invites in the v0.7 container and PostTo for IFrame based applications. We take all platform issues seriously and your feedback and cooperation are paramount for the success of our platform. We are working on getting the fixes out from our end, but in the meanwhile we wanted to alert you to the fix you can do from your end now.

For purely onsite applications:
When creating the Message object that you pass to requestShareApp make sure to include a value for TITLE (cannot be undefined):

// create the rSA message
var body = "Some message.";
var title = "This will be ignored but can't be undefined.";

// create an opensocial.Message object
var reason = opensocial.newMessage(body); reason.setField(opensocial.Message.Field.TITLE, title);

// initiate requestShareApp
opensocial.requestShareApp(recipient_array, reason, your_callback_func);

For IFrame applications:
You’ll have to change your reference to our IFrame Kit – This is mandatory as there is not a fix from our side for this. Rest assured that appropriate actions are being taken to mitigate this from happening in the future.

Before you needed the following scripts included:

<script src="http://x.myspacecdn.com/OpenSocial/references/gadgets003.js" type="text/javascript"></script>
<script src="http://x.myspacecdn.com/modules/common/static/js/Apps/ifpc003.js" type="text/javascript"></script>
<script src="http://x.myspacecdn.com/modules/common/static/js/Apps/json001.js" type="text/javascript"></script>
<script src="http://x.myspacecdn.com/OpenSocial/IFPC_externalIframe004.js" type="text/javascript"></script>

Replace with:

~~<script type="text/javascript" src="http://js.myspacecdn.com/OpenSocial/RPC/RpcContainer.000.js"></script~~>
<script type="text/javascript" src="http://js.myspacecdn.com/OpenSocial/RPC/RpcContainer.003.js"></script>
<script type="text/javascript" src="IFPC_externalIframe005.js" ></script>

<script type="text/javascript">
gadgets.rpc.setRelayUrl('..', 'http://profile.myspace.com/Modules/Applications/Pages/rpc_relay.aspx');
</script>

Code for IFPC_externalIframe005.js can be found HERE .

We have updated our sample application for reference.

After we have the fix out for appInvites to handle the missing Title you can go back to not including it if you choose.

We are deeply committed to the MySpace Open Platform and we’re sorry for any inconvenience this may have caused. We’re working hard to get a fix out now.

MySpaceID implementation launched on the new Yahoo! homepage

Kiam — Wed, 22 Jul 2009 19:19:00 GMT

A MySpaceID implementation launched yesterday on the new Yahoo! homepage. One of several “Apps” Yahoo! has been testing since March as part of its new homepage, the MySpace application enables users to keep up to date with the information and people they care most about.

After logging into MySpace from the new App on the Yahoo! homepage, users can simply hover their cursors over the MySpace icon to get quick access to their MySpace friend updates, friend requests, and even manage their MySpace status, mood and more – keeping users engaged with what’s happening on MySpace.

This app is a great example of MySpaceID’s ability to leverage MySpace’s extensive social platform on other sites, and we’re pleased to see the momentum around the product continue.

MySpace is part of the new features of the Yahoo! homepage that include:

My Favorites – People can easily choose MySpace from a dashboard of apps and add it directly to their homepage. The apps give people the ability to preview, interact with, or navigate to MySpace from one easy check-in point.
Social Updates – People can now share their current “status” with friends directly from the Yahoo! homepage, as well as see what their friends are doing on MySpace.

Please take a minute to try out the app by visiting the new Yahoo! homepage and logging in with your MySpace credentials. If you don't see the new Yahoo! home page with the MySpace icon, click on "See the New Yahoo" in the upper left hand corner.

-- Kiam on behalf of the Open Platform Team

New Viral Channel for MySpace Apps

Test User — Tue, 07 Jul 2009 22:41:00 GMT

App Activities are now visible to all the friends of a user, regardless if they have the App installed. This means that App Activities are another channel by which your App can virally grow.

If you are already publishing App Activities, you technically do not need to make any changes, however we encourage you to think about how to best leverage App Activities as a user acquisition channel.

To ensure a quality user experience, we provide users the ability to block unwanted App Activities and other communications. If the user has the App installed, they will have the option to turn off receiving App Activities for the App or uninstalling the App. If the user does not have the App installed, they have the option to block all communications from the App.

As always, the user experience is of utmost concern to us. We'll be closely monitoring the use of this feature. Any developers that are found to be abusing this functionality to the detriment of the user or in violation of the Terms of Usage will be dealt with immediately.

The team has put in a lot of hard work into this feature and the required infrastructure to support it. We look forward to seeing the results of developers taking advantage of this new viral growth channel. Please send us your feedback and success stories.

Invites max now at 20

beriberikix — Mon, 06 Jul 2009 16:23:00 GMT

App invites are one of the leading drivers of growth for Apps. We've received a lot of good feedback about the recent introduction of multiple recipient invites and many developers have asked to increase the maximum amount invites one can send at a time.

In response, we're testing increasing the maximum amount of invites a member can send at a time from 10 to 20. This feature is now available in production. Check it out!

As always, please send your feedback in the comments; we really do read your responses and do our best to address them.

./bbk

Announcing MSFast

Yadid — Tue, 23 Jun 2009 21:36:00 GMT

Announcing MSFast By Yadid Ramot, Performance Architect, MySpace

Tracking User Experience

An overview of MySpace’s new open-source performance tracking tool - MSFast

We wanted to share with everyone an open-source project we’ve been working on at MySpace that, while relevant for developers, has a broader application for everyone. As developers ourselves, like many of you we are constantly trying to figure out the best way to profile and track the performance of our pages. After deep market research, we realized that the market for profiling tools lack features and capabilities which we think are important for efficient page optimization. These conclusions pushed us to develop a new homebrew tool, MSFast, which will hopefully cover all of these missing pieces.
It seems to us that the average web developer gives too much attention to tracking the time it takes for his content to download, and less-to-no attention to the order of the assets and the behavior of the page as it loads.

Tracking Downloads

The first problem you can have when tracking download speed is that the data is not normalized and could be inaccurate for long term trending. There are too many possible points of failure when tracking your site periodically, such as; your ISP changes your test box’s connection speed unknowingly (repairs/mistakes etc.), added a new hardware that change the bandwidth, installed a new local firewall that slows the connection, etc. These are just examples of local changes that will cause your site to appear slower/faster, but in the real world outside of your test box, these changes won’t be reflected.
Another problem you can have when tracking downloads is, while it’s important to keep in mind the simple equation of [slow connection + heavy content = slow site], there’s nothing much you can do about it to help speed up your site. So, you compressed your content and headers to the limit, removed the cookies and picked the fastest backboned CDN for your site, but on the user’s end, the site still act slow. What’s next?

User Experience

There are a lot of factors that need to be considered when optimizing the user experience on a page, such as ordering and prioritizing downloads, using the right type of download mechanism (blocking vs. async), utilizing the sockets correctly and that’s only for optimizing the content delivery. There are a lot of other elements that could cause bad user experience that has nothing to do with the actual download speed of the page. Elements with a really heavy JavaScript functionality, flash objects with a large amount of sprites that spike the CPU, heavy ActiveX controls that use a lot of memory, weird browser rendering quirks… these and more, can really clog the client’s machine and create a bad user experience when browsing our site.

Page Performance

As far as we know, the current common methods for profiling and capturing page performance are by:

Running an HTTP sniffer when requesting the page and measuring each request
Timing the page’s ONLOAD event
Injecting a code before and after JavaScript calls and timing them

For the download side, using the right HTTP tracking software that generates accurate waterfall graphs can really help developers to re-prioritize requests and optimize the way content delivers by showing the order of downloads and which request blocked the pages vs. which were download in parallel.
On the events side, the ONLOAD and other before/after benchmarks can help developers measure specific and known functionality that blocked the rendering of the page.

What’s Missing?

Using the current available tools, we can track real-time download bottlenecks, JavaScript bottlenecks (as long as we know roughly where they are) and the ONLOAD event. Here’s what we felt was still missing:

Normalize the download speed to generate accurate results
Automatically detect performance bottlenecks caused by an object that spikes the CPU or clogs the memory
A good way to tell when content is displayed and how long it took to render each UI element on the page
Detect blocking browser rendering quirks

So to sum it all up, for our purposes, the ultimate performance profiling and user experience tracking tool should have:

Normalize download data – Throttle down the inbound connection to ensure steady speed
An HTTP sniffer – Track download speed and blocking requests
JavaScript profiling capabilities – Profile how long it take to execute each function and detect blocking functions
CPU and Memory profiling capabilities – Detect how much memory and CPU the page consumes and how much each element costs us
Screenshot capturing abilities – Capture the page as it render to see exactly what was rendered during each event
A mechanism that tracks the time it takes to render each segment of the page

During the past ~6 months, we at MySpace have been designing and developing a tool that would do exactly that (and more ;] ) and we ended up with “MSFast” - a browser plug-in that gives developers a complete, deep look at everything we could think of, from the moment the page leaves the web-server to the moment the page is completely rendered.

MSFast

In short, the way MSFast works is by setting up a custom proxy server on the client’s machine and using that proxy to 1. Normalize the download speed by throttling inbound data 2. Injecting the page with a set of JavaScript functions that executes a series of tests and measurements.

MSFast main features are:

Measure the CPU and Memory Consumption

MSFast captures the CPU and memory state of the browser’s process from the moment the page leaves the webserver to the moment the page is completely rendered.

Screenshots of the page

MSFast automatically takes screenshots of the page while it renders. These screenshots could then be reviewed against the rest of the collected data to see the actual UI state of the page.

Review downloaded files and show download time estimation on different bandwidths

MSFast captures the page’s HTTP traffic and stores the connection times. Since we throttle the connection and always ensure a constant tracking speed, we can display download estimates for each file, under different bandwidths.

Measure and show estimates of the time it takes to render each section of the page in different connection speeds

When the page loads, MSFast breaks it apart to roughly ~60 sections with an equal amount of HTML characters in them, and measures the time it takes to render each one of these sections. A developer can then review each part of HTML and see the time it will take to render it using different connection speeds.

Review the rendered HTML

Using MSFast, a developer can skip over the rendered code and see which section of HTML was processed by the browser during the page’s lifecycle.

Validate the content of your page against a set of proven “best practice” rules of web development

MSFast has a custom list of “validators” that could run against the tested page and alert the developer if their code goes against a set of common “best practices”. These rules are fully customizable and MSFast exposes an API for writing additional business-specific custom rules.

Open Source

We are dedicated to working with the developer community and see a great opportunity in giving back to the development community by open sourcing MSFast. We hope that this project will be one of the first of many future projects that we will open source ?

For more details and download directions please follow this link – http://www.msfast.com

By Yadid Ramot, Performance Architect, MySpace

MySpaceID WordPress Plugin Announced at WordCamp SF 2009

Kiam — Fri, 05 Jun 2009 23:18:00 GMT

On Saturday May 30 in San Francsico, we announced the MySpaceID WordPress Plugin at WordCamp SF 2009. Interest was so overwhelming that we ran out of flyers to hand out!

For those people who want more information, the plugin is available at:
http://wordpress.org/extend/plugins/wp-myspaceid/

Documentation on how to install it can be found at:
http://wiki.developer.myspace.com/index.php?title=MySpaceID_WordPress_Plug-in_Setup

What is the MySpaceID WordPress plugin?

If you have a self-hosted WordPress blog, the MySpaceID WordPress plugin lets your users log in with their MySpace credentials to leave comments. This brings a few advantages:

Rather than leave comments anonymously, your users can now easily log in with their MySpace credentials in as little as 2 clicks and have their MySpace user name, picture and link automatically show up in the comment. Many users care about letting others find out more about them, and this is a really convenient way to do that, while boosting social engagement on your site.
After a user logs in, a cool-looking but unobtrusive bar appears across the bottom of the page. It lets the user share your blog with his friends simply by updating his status on MySpace.
The above status update contains a link to your blog, so that it drives traffic to your site (free marketing!), plus improves your PageRank.

How awesome is that? In addition, the following features are coming soon:

When a user posts a comment, he can optionally share that with his friends as an activity on MySpace.
When you post a new blog entry, you can share it with your friends as an activity on MySpace.

This is the first release of this plugin, and as it undergoes several iterations in the coming months, we want to improve it with your input. Please make sure to post your suggestions and comments to our MySpaceID forum at http://developer.myspace.com/Community/forums/60.aspx.

We are really excited to be working with the WordPress community on a plugin that is a win-win for all. Currently, our plugin works only with self-hosted WordPress installations. If you have such an installation, make sure you install it and try it out!

Thanks to our developers who built this plugin: Chris Baker (www.myspace.com/christopherbbaker) and Steve Ng (www.myspace.com/stevenng, Twitter: @stevenng)!

DevJam Videos are Available!

rondata — Fri, 05 Jun 2009 02:29:00 GMT

Greetings Developers,

The first batch of MySpace Open Platform DevJam videos has been uploaded!
Please click on a link below to view the video, and also check out our DevJam page for the uploaded presentations.

MySpace Open Platform - State of the Union
Presented by:
Jason Oberfest, SVP of Business Development for MySpace
Gerardo Capiel, VP of Product for the MySpace Open Platform
Max Engel, Product Manager for MySpaceID and the MySpace Open Platform

Building a Business on MySpace
Presented by Dan Yue, Co-Founder of Playdom
http:/www.playdom.com

How to Port Apps to MySpace
Presented Sebastien de Halleux, Chief Operating Officer and Co-Founder of Playfish
http://www.playfish.com

A Case Study on Monetization
Presented by: A.T., EVP, Sales & Business Development of Zynga
http://www.zynga.com

Thanks to all who attended DevJam. It was great meeting with you.

We'll be uploading more videos as they become available.

Thanks,

Rhonda

San Francisco DevJam: Streaming Live

rondata — Tue, 26 May 2009 11:35:00 GMT

Greetings Developers,

DevJam starts today at 10:00 AM PST!

For those developers that aren’t able to attend the devJam in person, you can watch it live! Tune in to http://www.myspace.com/devjam2009 for all the details.

With this, we are excited to announce UStream’s implementation of MySpaceID – props to the team for an awesome implementation!

You can interact with fellow developers in real time as you watch the devJam. Chats will also appear as status updates back on MySpace and you can check out the profiles of other developers watching the sessions. I encourage all of you to check out the devJam and this exciting new implementation of MySpaceID – It’s a great example of what MySpaceID can do and hints at what’s to come.

Also, we have another exciting announcement: Zynga will be presenting a case study on monetization.

You won't want to miss this!

Coming in person? We can't wait to meet you. Hope to see you there or see you online.

Rhonda

View the full agenda here: http://myspacesfdevjam.eventbrite.com/

UPDATE - Maintenance Outage Tomorrow Night 5.20.09

rondata — Wed, 20 May 2009 00:37:00 GMT

Greetings Developers,

A quick heads up, we need to take care of some routine maintenance tomorrow tonight. During this time, apps may be disabled and the developer site may be inaccessible. his planned outage starts at aprox 9:00PM tonight (PST) and will last aprox 2-3 hours. Expect downtime between 9:00PM - 12:00AM (PST).

Let me know if you have any questions.

Thanks!

Rhonda

REST App Notifications Are Now Available

Test User — Sat, 16 May 2009 00:26:00 GMT

We're happy to announce that we've just released the final piece of app notifications. You can now send app notifications directly from an OAuth REST end point. The REST end point allows you to pass in up to one thousand (1000) recipients at a time making it ideal for mass messaging communications to users of your app. This method also allows you to send notifications on a true server-to-server basis which is not initiated by a user action.

The general notifications page can be found in the developer Wiki. Documentation for the REST end point can be found here.

Enjoy!

Register Now! San Francisco DevJam - Tuesday, May 26th

rondata — Wed, 13 May 2009 23:19:00 GMT

Greetings Developers!

The MySpace Open Platform would like to invite you to another special DevJam Event.

This DevJam covers everything you’ll need to know about how to build great apps using MySpace Open Platform. We’ll begin with the State of the Platform, and tell you all about what’s happening now and exciting things to come. We’ll cover everything from porting apps to MySpace, leveraging our messaging channels, making existing offsite applications more social with MySpaceID, and everything in between. You won’t want to miss this DevJam event!

If you can’t attend in person, don’t worry! We plan to livestream the event, stay tuned on that front for more details…

Guest Speakers include:

Jason Oberfest, General Manager of the MySpace Open Platform and SVP of Business Development
Gerardo Capiel, VP of Product for the MySpace Open Platform
Dan Yue, Co-Founder of Playdom
Sebastien de Halleux, Chief Operating Officer and Co-Founder of Playfish
Max Newbould, Product Lead for MySpace Open Platform’s OpenSocial container
Max Engel, Product Lead for MySpaceID

And many more!

Space is limited, so click below to see the full agenda and to register now!

http://myspacesfdevjam.eventbrite.com/

See you there!! :) :)

Rhonda

App Notifications for OpenSocial Container now LIVE

Test User — Tue, 12 May 2009 20:38:00 GMT

Just a quick heads up, sending notifications from the OpenSocial container is now live and ready for use. As I mentioned in my previous blog, this is ideal for implementation of action prompting messages, such as turn based indicators. Per the updated Terms of Usage, notifications sent from the OpenSocial container are limited to ten at a time, and all ten must be friends of the current app viewer. Please make sure you familiarize yourself with the full updated details in the documentation.

You can test out notifications in action by checking out a Simple Notifications App and a Advanced Notifications App.

Here are some current known issues:

The App Notifications home page indicator isn't currently on. Expect this functionality to be turned on shortly.
Notifications aren't currently deleted when a user uninstalls an app. Expect this shortly as well.
Direct REST access to notifications (for mass messaging to all users). Just around the corner... ;)

Please let us know if you run into any problems or if you have any feature suggestions. We hope you enjoy this feature!

How to figure out Maximum OpenSocial Query Result Sizes

Scott — Thu, 07 May 2009 16:00:00 GMT

Many social web sites, Hi5, Orkut, MySpace, and others, all implement the OpenSocial specification. A number of the features in the specification allow you to get sets of items in one JavaScript call. These methods allow you to retrieve sets of friends, activities, and more. The OpenSocial specification requires the containers to support page sizes of 1 to 20 items per fetch. The spec allows for containers to support larger pages at the container's discretion. When working with a container, you may want to know what the upper limit actually is. You can find this information by searching the documentation of each OpenSocial container or you can write a tool that just tells you what the value is. Let's write that tool!

To find these limits, you will normally need access to an account with a moderately large number of friends, activities, albums, pictures, etc.-- about 200 of the value you are testing should work. The key part here is 'access' to such an account. In all but the friends case, you should be able to create an account with those characteristics without external assistance. For the friends case, you'll need to figure out which of your friends is well connected, then convince them to run this application and report back any results. Let's build an application that tests the friends case.

To start with, we'll set up a simple UI that allows us to state how far along we are in the testing. When all is done, we want to report back the maximum page size for this container. Our markup is:

<style type="text/css">
    .results{
        overflow:scroll;
        height:350px;
        width:100%;
        border-color:#000;
        border-style:solid;
        border-width:thin;
    }
</style>
<p>
    <b>Maximum friend page size: </b><span id="maxPageSize"></span>
</p>
<div class="results" id="testOutput">
</div>
<button id="btnRunTest" onclick="runTests();">Find Person Maximum</button>

Now, we need to write some OpenSocial code to discover those limits. The function we are writing will report back the largest page size that can be used for the current account. If you try this with an account that has 2 friends, the largest page that makes sense is 2 people. Ideally, you will have access to an account that has more friends (or other resource) than what fit in a single request. The idea is simple-- we start by testing a page of size 20 (the smallest 'big' page according to the OpenSocial specification). If that request succeeds and returns 20 friends, we double the number to 40 and try again. Eventually, we will either get all the friends in one request or we will request a page that is larger than what the container supports. If the requested size page is too big, the size of the resulting array will be smaller and will tell us what the maximum is.

We start by keeping track of the size of the last successful test in case we overshoot the top and start getting errors. We also have a simple output function that adds strings to the testOutput <div> tag.

var lastSuccessfulTestSize = -1;
function writeInfo(info){
    document.getElementById("testOutput").innerHTML += info + "<br/>";
}

We then need to run the tests. This involves initializing the outputs and then calling the workhorse function, findMaxPageSize.

function runTests() {
    document.getElementById("testOutput").innerHTML = '';
    document.getElementById("maxPageSize").innerHTML = '';
    findMaxPageSize(20);
}

findMaxPageSize takes a single argument: the maximum page size. I start out at 20 since that is the lower limit for any container. findMaxPageSize will have to follow the basic steps of getting a list of people:

Construct an IdSpec indicating who to pick and then which group. We'll get the viewer's friends.
Set the fetch params to indicate we want the first N friends by setting the opensocial.DataRequest.PeopleRequestFields.MAX param to N and opensocial.DataRequest.PeopleRequestFields.FIRST to 1.
Make the request and wait for the response.

In the response, we then:

Check if an error occurred. If so, reduce the size of the page and try again.
If no error occurred, get the list back. If the list size is smaller than what we asked for, we've hit a maximum for this person. Note: this is only absolute for the container if more friends exist.
Otherwise, try again with a larger number.

Here that is, reduced to code:

function findMaxPageSize(testSize) {
    var dataRequest = opensocial.newDataRequest();
    var params = {};
    params[opensocial.IdSpec.Field.USER_ID] = opensocial.IdSpec.PersonId.VIEWER;
    params[opensocial.IdSpec.Field.GROUP_ID] = 'FRIENDS';

    var idspec = opensocial.newIdSpec(params);

    var fetchPeopleParams = {};
    fetchPeopleParams[opensocial.DataRequest.PeopleRequestFields.MAX] = testSize;
    fetchPeopleParams[opensocial.DataRequest.PeopleRequestFields.FIRST] = 1;
    var fetchPeople = dataRequest.newFetchPeopleRequest(idspec, fetchPeopleParams);

    dataRequest.add(fetchPeople, 'fetchPeople');
    dataRequest.send(function(response) {
        var nextTestSize = testSize * 2;
        var max = 0;
        var foundMax = false;
        if (response.hadError()) {
            nextTestSize = parseInt((lastSuccessfulTestSize + testSize) / 2);
            writeInfo(testSize + " was too big. Trying " + nextTestSize + ".");
        }
        else {
            var ppl = response.get('fetchPeople').getData().asArray();
            lastSuccessfulTestSize = testSize;
            if (ppl.length < testSize) {
                max = ppl.length;
                foundMax = true;
            } else {
                foundMax = nextTestSize == lastSuccessfulTestSize;
                max = nextTestSize;
            }
        }
        if (foundMax) {
            writeInfo("Found the maximum friend page size.");
            document.getElementById("maxPageSize").innerHTML = max;
            return;
        }
        else {
            writeInfo(" Trying " + testSize + ".");
            findMaxPageSize(nextTestSize);
        }
    });
} 

When running this on MySpace, I found that the maximum number of friends/page is 100 (as of today). This code works on OpenSocial 0.8 and 0.9 containers and can be useful for optimizing your applications for the different platforms you use.

App Notifications, Terms of Usage and REST Access

Test User — Thu, 07 May 2009 02:36:00 GMT

With the initial release of App Notifications just around the corner I wanted to clarify some features and best practices for implementing app to user communications.

The first piece of App Notifications we’ll be releasing will allow you to send notifications directly from the OpenSocial 0.8 container. This is the ideal method for sending “action prompting” messages to the user from the app, such as “Your Turn” indicators. Sending notifications from the container will ultimately be limited to ten (10) recipients and they must be friends of the User.

The next component (which will be released shortly after the container functionality) will allow developers to send notifications directly from a REST end point. Using the REST end point, developers can send notifications to any of their app users, making it ideal for digest or informational type messages. You’ll be limited to passing a maximum of one thousand (1000) recipients per call to this end point and it will be throttled (for obvious infrastructure reasons).

As part of our commitment to the MySpace App user experience, we’ll be making some specific updates to the Terms of Use. In addition to the standard rules of content for app communications (no advertising, no incentivizing, etc.), App Notifications obviously need to be directly and clearly related to the sending app. Any users you mention in notifications must be aware that their information is being included and you must provide a way for them to opt out. Please be sure to familiarize yourself with the new terms.

The entire team has worked very hard to get this functionality out and we’re excited to see the great new apps the community creates using it!

Adding Friends as Testers and Developers!

Test User — Mon, 04 May 2009 21:39:00 GMT

Sharing and testing apps in progress has historically been limited to just fellow app developers. This has made testing apps on any large scale prior to release difficult. We’re happy to announce that we’ve updated the developer site to easily let you manage and add who has development and testing access to your apps.

From the My Apps section of the developer site you can now click the “Developers & Testers” link to view a paged list of your friends along with a “Developers” and “Test Users” column.

Simply drag and drop any of your friends into the “Test Users” column and they’ll have immediate access to view and use your app in progress.

Any of your friends that are registered developers (indicated by an asterisks [“*”] next to their display name) can be dragged into the Developers column where they will have full rights to your app source code.

Editor's Pick Category is Live!

rondata — Thu, 30 Apr 2009 19:27:00 GMT

Greetings Developers,

Just a quick note, Editor's Pick Category is LIVE!

We've gotten some great apps submitted to Developer Relations and have selected a few to spotlight here. This list will be periodically rotating as we find more great apps to spotlight.

Thanks again for your participation and we look forward to seeing some more great apps!

Rhonda