•
We’ve started taking advantage of Facebook’s special swf tag and now your Sharendipity creations will play directly inside your Facebook feeds when you post them!
Now you can easily share custom apps that are unique to your friends and they can interact with them just like it’s a video. No more new tabs or windows to launch the app elsewhere.
Application Sharing
These are the steps I followed to share an app with my wife to share my Christmas list.
1. Copy the URL of the app
Copy the URL from your browser’s address bar for the application you’d like to share. Each application has its own asset page.
2. Use Facebook post to share the app
You can share your link directly on a friend’s page (if they are permitting it) or you can share it on your own wall. In this case, I posted it directly to my wife’s wall.
Alternatively, you can use the AddThis share options found on the asset page to post or email your application directly to Facebook.
Application Play
Once you’ve posted the application, anyone that finds it within the feed can play it directly. By default, the post will appear with the normal blue play button just like a video.
The feed will automatically grow to create room, and your friends can interact with the application, comment, and share it with their network.
What custom app would you like to share with your friends? Maybe a custom slide show?
•
Sharendipity is proving to be one of the most dynamic (fantastic!) ways of consuming web services of all kinds. With built in support for RESTful web services, it becomes trivial to implement an interface for lots and lots of third party data sources.
When creators chose to share their implementations with the community, everyone gets an opportunity to leverage the web service without ever having to look at an API document. You can simply drag the service into your application and access the data by calling the respective method.
Most implementations available in the community today are returning the data gift wrapped for your enjoyment. For example, you can take advantage of the Facebook Services to access the profile data for all of your friends and it is given to you in a list of “Facebook User” objects. Poof! Your social graph is there for you and you never once went to the Facebook developer wiki!
Likewise, you can use the YouTube services to ask Google for every YouTube video uploaded by a particular user and are presented with a list of assets that not only tells you the URL but also all of the comments, ratings, description, related videos, etc.
As you might tell, I’m smitten with the power of the web services. The following is a sample of the variety of applications that are using web services today…
Most of these examples are application templates, which allow users to personalize the web service calls for their specific needs. For example, the Twitter/Last.fm application lets you configure a band or singer name for the chatter you’d like to display.
Every application comes with its own embed code so you can post it anywhere on the web.
Anyone can implement and share web services so if you haven’t found the service you’re looking for feel free to get started building your own components. You can read our how-to post if you need a primer to get started.
Tags:
web services,
widget
•
We’ve released support for video playback within Sharendipity and we’re eager to see what you can do with it!
Included in this feature are three core integration points for video:
- Native support of the YouTube video player inside your apps
- Support for sharing of Flash Video (FLV) files within the community
- Support for Flash Video (FLV) specified by URL
YouTube support
Google recently announced the addition of native, ActionScript3 support for the YouTube Player API. This enabled Flash developers to add support for embedding the YouTube player inside their Flash applications.
And now we’ve provided an abstracted interface to the YouTube player for you, our Sharendipity creators. You can now add a YouTube video to any primitive actor in the system by simply providing the URL. There are base actions that let you play, pause and rewind the video within the logic builder.
With these four basic primitives, you can quickly build complete YouTube playback applications with UI controls to pause, play, and surf video content.
Check out these fun little mini TVs for an example of how you can create new ways of surfing YouTube videos.
Sharing FLVs just like images
Just like images, FLV files can be shared and re-used by everyone in the Sharendipity community. The work flow for adding FLV files is identical to the one used for images and sounds except there is now a new category in the asset manager called “Video”. Please read the post on sharing images to learn more.
To reuse the FLVs found in the asset manager, simply drag a thumbnail from the manager and drop it on the desired actor in your application.
Flash video support by URL
If you would prefer to access existing Flash video on the web, you can simply drop the URL into the image property for any primitive actor in your application. We’ve implemented the ActionScript 3 video player and it will play any video simply by pointing to its URL.
If the URL points to a YouTube video, we will automatically insert the YouTube player.
Tags:
API,
google,
YouTube
•
We’re really excited to be the winners of the first Ning Appathon today. We won for the best “ported application” category and received a cool $4,000!
Ning had a pretty prestigious group judging the contest…
Submissions for our weeklong competition were judged by Wired Editor-in-chief and DIY Drones Network Creator Chris Anderson, Ning Chairman and Co-founder Marc Andreessen, and blogger and Managing Director of building43 Robert Scoble. The competition began on Nov. 5 with all submissions due on Nov. 12. The entrants were judged on creativity, usability, how well they integrate with Ning Networks, viral features, and usefulness.
It’s more than just an app
One of things we’re most excited about is the transformation we went through as part of this project. This is much more than just a Ning app for us. After all, Ning users have long been able to post their Sharendipity creations inside Ning using the standard embed code.
When we decided to go after this prize, we set the bar very high. We wanted to syndicate the entire software development process. To provide a set of tools that let anyone run their own development site.
This will mean that a teacher can create a template that allows her students to develop their own interactive study guides. And a niche gaming network can run their own game creation contest. All from within their own website, blog, or Ning network.
We aimed to build one application that delivered the creation tools, community aggregation tools, and a means for individual users to interact with their own creations – all in a nice bundle and tightly integrated with the OpenSocial standard. We’re thrilled that Ning recognized us for this achievement!
There’s more to come!
The Ning community provides us with an awesome opportunity to explore niche, custom software development. We’re excited to see what kinds of applications they can create now that the barrier for software creation has been significantly lowered.
Over the next several weeks we’ll talk more about how our tools can be syndicated outside of sharendipity.com. And we’ll help the Ning users leverage our platform to do even more. We’d like to give them the tools to submit their own software to the Ning application directory.
Here’s the official Ning press release.
Tags:
announcements,
ning
•
We interact with lots of creative artists that have done some great work, and are looking for new opportunities to distribute their artwork. In many cases, they like the idea of participating in the Sharendipity ecosystem – particularly with the gamers – but lack the interest in creating authentic games themselves.
Since images can’t be shared directly from the website, it isn’t obvious how to get started. This post is intended to show you how you can share your images from within the Sharendipity editor.
Once they’ve been added, they will be accessible to everyone else within the Sharendipity community.
1. Login
Before you can share anything out to the community, you first need to login with your Sharendipity account. If you don’t yet have an account, you can create an account in a flash by clicking “Create an account” at the top of the page.
2. Launch the editor
The editor can be launched in one of two ways. You can either click the “Create Yor Own” button at the top of the games page or you can launch into it directly using the following URL:
http://games.sharendipity.com/create/
3. Open the asset manager
Once you are in the editor, you manage all Sharendipity assets through the asset manager. This interface provides access to the components local to your application as well as those shared out in the community. This is true for everything from game characters and web services, to artwork and sounds.
Each asset type filter provides a “New” button at the bottom of the asset manager dialog.
4. Select the “Images” filter
From inside the asset manager, select the “Community Assets” tab at the top and then hover over the type filter to select “Images”. In addition to filtering the search results to images, it always presents a new option at the bottom of the window to upload new images – “Upload Image…”
5. Upload your new image
When you click the “Upload Image…” button, an upload dialog will appear that prompts you for the location of the file. Click “Browse” and locate the image on your desktop, and click “Upload” to start the upload process.
6. Describe your image asset
Once the file has been streamed to the server, you will be prompted to describe the asset. The thumbnail should be pre-populated, but you should fill in a name, description, and tags that describe your asset and make it easy for others to find.
If your image is a tile used for animation, use the fields underneath the thumbnail to describe its layout.
Finally, you’ll need to decide whether to make your image public or not. If you do not check the “Visibility” box, the image will not appear in the search results for other Sharendipity users. And don’t worry, you can change this setting at any time after it has been saved.
Happy sharing!
Tags:art, howto
•
Over the past few months we’ve been rapidly evolving the Sharendipity application editor toward a full-featured Integrated Development Environment, or IDE, similar to the environments used by professional programmers. These changes reflect the fact that many of our users today are highly technical, and computer users in general are becoming more and more comfortable with sophisticated environments, such as Microsoft Office or Photoshop.
For instance, we changed our menuing system, replacing the “cute” characters at the bottom of the screen with a more standard set of pulldown menus. While some users may have found the characters less intimidating, the majority of users preferred a standard set of pulldown menus.
We’ve also recently released developer tools including a profiler for optimizing application performance.
Today we’re releasing an additional set of powerful features that simplify application development and debugging.
Tabbed window management
Once an application had a few custom actors or types, the class, method, and behavior editors would become unwieldy, forcing the author to waste time arranging windows.
Editors are now launched in tabbed windows that keep things organized:
New editors are launched on tabs on a single tabbed window. Or tabs can be “torn off” to create new tabbed windows, which can be useful when copying logic statements between methods or behaviors.
In addition, an integrated window manager now places windows in more logical positions, avoiding the player window, remembering previous window positions, and tiling windows that would otherwise launch on top of each other.
Debugging Tools
Previously we released a simple breakpoint capability. Our new release includes full debugging tools, allowing breakpoints to be set and allowing line-by-line stepping through the code as it executes.
To add a breakpoint, simply double-click on the left side of a statement. A stop sign appears to indicate the breakpoint.
When this line of code is executed, execution of the thread will be paused. The “Problems” indicator will turn on when a breakpoint is encountered; if the editor is not already open you can access the breakpoint through the Problem Viewer.
A green arrow indicates where execution is stopped. You can move the mouse over any variable to check its value.
(An exception will produce the same view, except the arrow will be red. And a yellow arrow indicates that execution is stopped within a method called from that line of code.)
The Breakpoints view, accessible from the Advanced… menu, displays all breakpoints and can be used to temporarily disable breakpoints. Double-click on an entry to launch the corresponding editor.
To step through the code line-by-line, use the Thread viewer, which is described below.
Threads
Sharendipity is a multi-threaded environment. When a behavior is triggered, it is executed on its own execution thread. The application executes at a given frame rate, and on each frame the active threads are each executed for a limited amount of time. This keeps the system interactive and allows background processing, for instance a fade effect that occurs as the game continues to play.
The Thread viewer displays all active threads. It also displays threads that are suspended due to a breakpoint or an exception.
In this example a single thread is executing and is suspended due to a breakpoint. The “stack trace” shows exactly where the code is currently executing: the “fetch words” behavior has called the “setup puzzle words” method which has then called “place word randomly”, which is where our breakpoint is positioned.
The Play button will resume execution of the thread, until it hits another breakpoint or finishes execution.
The Step and Step into buttons can be used to step line-by-line through the code, which can be very useful for debugging. The Step function steps to the next line within the method or behavior. the Step Into button will step down into the method that is called from the current line. If the current line does not call a user-defined method, Step Into will simply step to the next line within the method/behavior.
These powerful tools are only possible because Sharendipity is built on a very sophisticated object-oriented architecture and runtime environment. This core architecture and toolset makes Sharendipity a powerful tool for you to build interesting interactive web applications.
•
I love working in a startup. I get to interact directly with our audience on a regular basis. I also get to respond to what they have to say in near real-time.
We’ve wanted to play around with the UI in our advanced creator for quite a while. The problem was that there were just too many other projects going on. Well we got some candid feedback from a user (something we, and most likely every startup, value incredibly) and decided it was time. Two days later (it would have been one, but I broke something…), the new UI was out there to play with.
We decided to get rid of the characters that represented different actions in the UI and go to a more traditional IDE look and feel. The basic reason being that it’s hard enough to drive adoption without presenting a new paradigm for user interaction. The new UI makes things much more visible and accessible:
We also highlighted a lot of our community features through the Help tab on the right. Ideally this provides the resources our users need to build things as well as generating more of this type of interaction.
There are a ton of cool things about this whole process. First, it help drives engagement and loyalty. Second, it encourages additional feedback. Third, if it doesn’t work out, we get to try something else out as quickly as we did this. I’ve worked at a couple of places where it was nearly impossible to turn around big changes like this on a rapid basis.
So if any of you have additional feedback on the user experience in the advanced creator, we’d love to hear it. Feel free to use our Get Satisfaction page, the community forums, or post a comment right here on the blog. There’s also a Google Group created by this same user that you might want to use to interact with other Sharendipity users.
•
Several web service interfaces have been built and shared within the Sharendipity community including services for Facebook, Twitter, Flickr, Posterous, and Google Docs. Using these components you can quickly and easily access the data from these sites/services.
But what happens if you can’t find the service you’re looking for? Or if you want to improve on one of the existing services and make a better one yourself?
This post is here to help. We’ll walk you through some of the basic elements for building a new component that interfaces with an external web service. To get started, first launch the Sharendipity editor.
Create new object type
Creating a new type provides you with the ability to define custom assets that perform a particular job or store specific data. They don’t necessarily have to be a displayable actor inside your World. The definitions for these new assets are entirely up to you.
In the case of a web service, you’ll define the location of the service, describe inputs, and then define custom actions that let the users of your service interact with it.
- Open the Explorer dialog and select New from the Types tab.
- Name your new type. For example, “Twitter Service – public timeline”
- Declare that your new type “is a REST Web Service” by clicking the + sign next to its name, and selecting the is a button. You can find the REST Web Service type by selecting Other… and navigating to the Local->Types tab in the Explorer that is launched. The following diagram highlights this navigation.
Default properties
Once you have the REST Web Service type defined, you must specify the details of your web service by initializing a couple of parameters.
Custom properties
Many web services have optional and required parameters. For instance, the Posterous API lets you specify the subdomain of the site you are reading from. In order to define parameters, you must define custom properties in your type that are of type REST Input.
Each REST Input has a name and value pair. The name value should be the parameter name as defined by the web service API you are trying to access. In the Posterous example, the name field is ‘hostname’. The value field carries your parameter value. When the web service is invoked, each REST Input is automatically appended to the end of the URL property.
If you were to look at the full URL when the service is invoked, you’d see something like the following:
http://posterous.com/api/readposts?hostname=gregtracy
As you are making calls to the web service, you can simply manipulate the value parameter of the REST Input to change your query to the respective web service.
Web service actions
By default, there is a single method defined for all web service types called invoke web service. This is the mechanism by which you initiate a call to your web service. It can be called internally as well as externally by users of your component.
Just like other objects in the system, you can create your own behaviors, methods, and properties for your new type. For instance, you may want to create your own invoke method which takes parameters that are passed to the web service. For example, passing in a user ID to a Facebook web service to specify the user whose profile you would like to access.
Referencing the service
Once you’ve defined your web service type, you can share it with the rest of the community with the Save option found in the object builder. Otherwise, the web service will be saved along with the application you’ve defined it in.
Whether or not you share it, the new type can now be accessed from anywhere else in the application.
- If you drag it into your World and drop it, you will be prompted to create a new custom property for the World.
- You can drag it into a behavior or method and drop it to create a local variable inside your logic.
- It will also be accessible from the Other tab when you define new properties anywhere within your application.
Just remember that if you don’t save the service by itself, you can only access is from the Local tab of the Explorer within the current application. If you do save it, it will appear in the Types tab for everyone.
Tips for better reuse
Creating an abstraction of the web services call is a nice feature by itself. However, it becomes most useful when you provide really easy access to the data that is returned. For instance, rather than simply providing the invoke web service call and letting the callers parse the data returned, try creating methods that do that parsing for them.
- The Twitter service has a method that returns an array of Twitter Status types.
- The Posterous service has a method that returns an array of Posterous Blog Post types.
- The Facebook User service has a method that returns an array of Facebook User types.
Each of these services define new methods that call the invoke web service method internally and parse the return data automatically. This way, users of the services don’t have to worry about how any of the data is formatted.
For more details, including specifics for the Facebook integration, check out the web services page on the wiki.
Tags:
create,
howto,
invoke,
web services
•
One of the really cool ways that you can integrate Sharendipity into your own web applications is by passing arguments into the Sharendipity player via the embed code. This functionality allows you to incorporate data such as user session IDs or anything else managed by your own server into a running Sharendipity app.
Accessing Application Parameters
Accessing the parameters to your application is really simple. There is a method on the Application called “Get Application Parameter.” Access the Application object by clicking on the “Actors” tab in the Values section of the Behavior or Method Builder. Click on the object called “Application” and scroll down to the section where the methods are listed. Just drag the method into the right-hand panel and enter the name of the parameter that you want to access:
Setting up the Embed Code
Once you have implemented the Application action, you just need to pass the respective parameter(s) within the embed code. For example, this is the embed code that is being used for the example application in this blog post:
<object width="300" height="200" data="http://static.sharendipity.com/player.swf?aid=3371&appParam=Sharendipity%20Rocks!!!" type="application/x-shockwave-flash">
<param name="src" value="http://static.sharendipity.com/player.swf?aid=3371&appParam=Sharendipity%20Rocks!!!" />
</object>
Every application comes with its own embed code. Note, however, that the default embed code will not include your custom properties. When you add your embed code to your website, you will need to add the list of parameters. In the example above, it is the section :
"&appParam=Sharendipity%20Rocks!!!"
You can see that we’re already passing the application ID to the Sharendipity player (”aid=3371″ in this case). All we’re doing is passing the Flash application another parameter as part of the querystring that can be accessed inside Sharendipity. This is the value that is pulled out when the “Get Application Parameter” method is called with “appParam” as the name of the parameter we want. If you’re running a web server, you can set up your pages to dynamically write whatever value you want into the embed code.
The Final Application
Here’s the result of what we just made (click inside the app, press the “Esc” key, and rewind the app to see it run again):
Tags:
creation,
game
•
As Sharendipity continues to mature, we are beginning to add more advanced features to the editor that can aid the developer in building his or her application in a significant way.
Traditional programmers using professional development environments are used to having certain tools available to help them troubleshoot their applications. Creators in Sharendipity, including our non-programmers, also require methods for debugging problems and tracking down performance issues. This post highlights a few of the features we’ve added that will help improve your development experience.
If you have any feedback about how we can continue to improve the tools please let us know. We’re always listening.
The Console Window and Trace Statements
One of the more basic troubleshooting tools developers use is a console window that provides a simple way to display arbitrary information about the program. Sharendipity now has a Console Window that can receive text output from an application. The console can be accessed through the Director menu:
This will bring up the console window, shown here with output from the Teslaformer game:
You can display text on the console window using the “trace” action available in any Behavior or Method of a class in Sharendipity. The trace statement can also take just about any type. You can even concatenate values together using the “+” operator as shown here:
The console can be useful for monitoring all kinds of activity within an application. For example, you can print messages to the console simply to let you know when a particular behavior is running, or you can print out individual property values as they are changing.
The Problem Viewer
The Problem Viewer is a dialog that displays logic errors to the developer that prevent the application from running correctly. When there is a problem in an application, a red notifier saying “Problems” will appear in the top-left corner of the editor. Clicking on this will bring up the Problem Viewer dialog.
The viewer displays basic logic errors that prevent applications from starting (e.g. forgetting to assign a value in a property set action) as well as errors that occur while the application is running (e.g. your logic is expecting objects to be present and they aren’t).
Double-clicking on an item in the Problem Viewer will take you directly to the location of the problem. You don’t need to go searching around for the location of the error.
Below is a view of the Problem Viewer in an application I set up to be broken intentionally. You can see that there are a lot of issues and the Problem Viewer allows me to see exactly which classes and methods they’re coming from.
The Profiler
The Sharendipity editor also includes some new functionality that lets you analyze which parts of your application are taking longer to execute. Similar to the Console Window, the profiler can be accessed from the Director menu:
Clicking on “Performance…” in the director menu will bring up the Performance Management dialog, which looks like this:
In this view, Profiling has already been enabled and data is being collected in the running application. From the menu you can view the current profiling data, and you can also clear the profiling data. Viewing the profiling data will give you a view similar to this:
Similar to the Problem Viewer, double-clicking on one of the rows in the Profiler will allow you to see exactly which calls are taking all of the time, including breakdowns by constructs such as “if” statements:
Breakpoints
Like most debugging tools, Sharendipity also offers a way to halt execution of a thread to examine the current variable data. The current implementation uses a “Breakpoint” statement. Under the hood, this throws an exception that will show up in the Problem Viewer, preventing following statements in the behavior or method from running. Opening the problem viewer and double-clicking on the Breakpoint exception will bring you to the Behavior or Method where the breakpoint was hit.
The really handy part is that now you can mouse over variables in the Method Builder or Behavior Builder to see their values:
The Sharendipity Wiki
I’ll also take a second to mention that a lot of information is documented over at the Sharendipity wiki. If you happen to get stuck, this is a great place to start. There are also forums there that allow you to ask questions about any of the topics on the wiki and we’ll respond as soon as we can.
The Complete Picture
With the addition of these new developer tools, the platform is really starting to display its true potential. Not only is Sharendipity a complete authoring environment for Flash games and applications, it provides distribution as well as monetization opportunities for the developer, all built on a platform designed for sharing and extensibility.
Tags:
breakpoints,
creation,
debugging,
game,
performance,
profile