SlideAware

Use SlideAware to easily collaborate on PowerPoint presentations in wiki pages

The reason for the success of wikis is that they make it easy to publish, update and collaborate on content. With SlideAware embedding and review capabilities, it becomes easy to update and collaborate on PowerPoint presentations attached to wiki pages.

Embedding a presentation in your wiki

To allow wiki users to quickly browse presentations, you should use SlideAware embedding capabilities.

First upload your presentation to SlideAware. If you have the SlideAware add-in installed, just click on the Save to SlideAware button in PowerPoint, otherwise sign-in to your SlideAware personal account and click on the Upload button.

Then, click on Share Presentation in SlideAware and go to the Embed tab.

The auto-play option is useful when you want the presentation to look like a Flash banner; see our previous article for more details.

Choose manual play.

• Check the "show review" option to allow users to attach notes directly on the slides
• Check the "show share" option if you want users to be able to embed the presentation in other wikis or blogs
• Check the "show download" option to allow users to download the original PowerPoint
• Finally pick the size you want the embedded presentation to have in your page

And that’s it; just copy the Embed HTML in your wiki page.

Collaborating on PowerPoint presentations in wiki pages 

Wikis make it easy to update pages. Presentations also need to evolve.
By choosing "show review", wiki users can see notes left by other users on the presentation without leaving the wiki. They can also attached their own.

With the SlideAware add-in installed, the author can download the notes into PowerPoint by just clicking "Get Notes". To publish the modified presentation he just needs to click "Save to SlideAware" and the wiki will automatically show the new version.

Example

Below is an embedded presentation that allows review, share and download. Give it a try, add some notes.

Mouse over the red square, it's a note!
Click "review" to add more notes

 

Create a Flash banner for your blog using PowerPoint and SlideAware

Let’s say you want to put a Flash banner on your blog or website but you don’t have the time or know-how to actually build a Flash banner.

 

First, build your banner in PowerPoint:

• If you don't want the banner to have a 4/3 width/height ratio, just change the slide dimensions (in PowerPoint, go to the File menu and choose Page Setup)
• If you want a frame of the banner to be built in stages, just use custom animations (in PowerPoint, go to the Slide Show menu and choose Custom Animation)
• If you want people to navigate to another pages when clicking on a shape in the banner, just add and hyper link to the shape (in PowerPoint, right-click on the shape, and choose Hyperlink...)

 

Then, upload the presentation to SlideAware. If you have the SlideAware add-in installed, just click on the Save to SlideAware button in PowerPoint, otherwise sign-in to your SlideAware personal account and click on the Upload button.

Unlike all other services out there that do PowerPoint to Flash conversion and hosting, we generate a SlideAware SlideShow (that’s how we call the generated Flash movie) that:

•  Respects the dimensions of your slides
•  Preserves the builds
• Turns hyper links into hotspots

Then, click on Share Presentation in SlideAware and go to the Embed tab.

 

 

To create a Flash banner, you want to pick the embed for “auto play” option; provide how much time should be spent on each frame, whether it should cycle back or stop at the last frame, and indicate the dimensions you need the banner to be.

And that’s it; just copy the Embed HTML in your blog or webpage and you are good to go!

 

Banner created entirely in PowerPoint and embedded in autoplay mode
Original slide uses custom animations
Create/Share/Analyze are actually hyper links

 

Newsletter #2: browser upload & richer embedding

Upload presentations from your internet browser You no longer need to install the SlideAware PowerPoint add-in to start using SlideAware. Simply click on the "upload" button and follow the instructions in the pop-up to upload a PowerPoint file to SlideAware. You should install the add-in if: you often save presentations to SlideAware; with the add-in, publishing to SlideAware is one click away you use SlideAware to collaborate on new presentations and you need to retrieve notes from co-workers back into PowerPoint you prefer to keep private documents private; the add-in allows you to store presentation content on an enterprise file store (the document then never goes outside your firewall) Use browser upload if: your corporate policy does not allow you to install any 3rd party add-in you use PowerPoint 2007; just make sure to save your presentation as .PPT (PowerPoint 97-2007 format) you only use SlideAware for live presentations you only use SlideAware to produce Flash banners for your website or blog you only use SlideAware to embed presentations on a wiki; however if you are using a behind-the-firewall wiki, you will need the add-in to store the presentation content behind the firewall New browser upload popup Embed presentations in a blog, wiki, portal or microsite Presentation content does not live in a vacuum. It is extremely useful to have such content embedded within a corporate knowledge sharing framework, such as a blog, a wiki, a portal or a microsite. SlideAware now supports a diverse set of options from an embedding perspective: When you embed in a wiki or a blog, you can now allow people to provide feedback or download the original presentation. Presentation embedded with "allow review" option selected; notes are shown when moused over If you want a flash banner on your blog or microsite, simply embed the presentation in autoplay mode, it won't show any controls and there will be no need for the end user to click through the slides in order to consume the message. Banner created entirely in PowerPoint and embedded in autoplay mode

 

Our first newsletter: tutorial, versioning, live review and notes

Video Tutorial With our new tutorial, using SlideAware is as simple as watching a video! The tutorial will give you step-by-step instructions on setting up your account, sharing a presentation, collecting feedback, etc... You will get up and running in no time. Learn more Versioning Maintaining multiple versions of a document can be painful. Not only is it time consuming, but all these pres_v1.ppt, pres_v2.ppt, pres_v3.ppt files are starting to clutter your hard drive! With the addition of versioning, SlideAware makes this completely transparent: Every time you save to SlideAware, a new version is created for you. The full audit trail is accessible in case you ever need it. And best of all, the links you sent (for review or for self-paced view) automatically point to the latest version, so no need to re-email anything! Live Review Getting feedback on your presentations has never been easier. Forget the painful approach of emailing multiple versions of a document and trying to coordinate the collective feedback manually. With 'Share for review', getting feedback is as simple as sending a link: Your reviewers only need a browser to leave notes. They always work on the latest version of your document. The document they work on is read-only (you decide which changes you want to apply). They can see each other's notes (bye bye duplicates!). With live Chat, you can easily communicate with other reviewers. Your notes in PowerPoint In PowerPoint, retrieving the notes your reviewers added is now a single click away: press 'Get Notes' and the notes will appear on your slides. Delete the individual notes after you have addressed them, and when you are done, just save your presentation to SlideAware. SlideAware automatically handles everything for you: Your presentation will be versioned (automatic audit trail). Your reviewers will see the updated version (no need to re-email anything). And the notes you haven't addressed will be copied over!

Technorati Tags: Powerpoint, collaboration, sharing, versioning, Web20

There is a world outside of Ruby on Rails

Here is a typical conversation we get pulled into: Why again did you chose Erlang for a Web2.0 app ? Surely, you must have heard of Rails ? Erlang is such an obscure language. What about database support, documentation, a vibrant community, a developing environment, debugger, migration tools, etc... these do make a big difference in the long run (and surely outweighs the fact that YAWS, the Erlang app server, might or might not be faster than Apache)

Well, these are all valid points, and this is precisely because Erlang is strong in all of these aspects that we ended up selecting it as our language of choice. Let's digg a little further if you will.

Erlang is an obscure language
However you look at it, functional languages (Lisp, Haskell, Ocaml, Erlang) are less popular than your typical Ruby/Python/Java/C#. But who said the most popular language was the best ? (wouldn't we all be programming in VB if this was the case :-) Maybe it is possible that there exists some hidden gems out there and it might be worth the time investigating these obscure languages. Notice that Paul Graham faced the exact same questions when he decided to go with Lisp for his startup in 98 !

If you pay close attention to the current trend in language development, you will notice that more and more functional programing features are making their way into procedural languages:

• the .each and .map operators in Ruby/Prototype (actually Javascript is more functional than you might think...)
• the clever use of blocks in Ruby (usually called closures in most other languages).

There is a reason for this: they do make programing easier (and not to forget the Python crowd, Erlang supports list comprehension. Sweet...) I cannot wait to see these languages adopt pattern matching (no, not your typical string regexp pattern matching, but the type which allows you to write a IPv4 header parses in just a few lines) . This is so elegant once you understand how it works...

One thing to be note though is that Erlang is not object oriented. This might seem like a small detail, but after having been taught for years that objects are the answer to every programing problem (including curing cancer and ending world hunger), it does require a little bit of an initial shift in your thought process...

Database support
Who needs Oracle/Mysql when you have Mnesia, a free, distributed, in memory database ? The ability to store native Erlang structures out of the box is so liberating: suddenly the need for your object-database mapping layer almost vanishes (well, not 100% to be fairly honest, but a big chunk of it: no need to create a 1-to-n relationship or a n-to-n relationship and a mapping table in many simple cases)

Not to mention that Mnesia supports table replication and is fully distributed, with the ability to add new 'nodes' on the fly. All of this out of the box ! (did I mention it was free too ?) This makes scaling up almost a joke. Compare this to the usual nightmares (and cost) of trying to implement a distributed Mysql/Oracle...

Developing environment/Debugger
This is where Erlang really shines. Remember that Erlang was initially created by Ericsson to ease the development of a highly scalable, fault tolerant telephony system. Not only did they create the language Erlang, they also came up with OTP (Open Telephony Platform). The name might be misleading: OTP is whole set of tools/libraries meant to make development in Erlang easier (and all of this is now open source)

The database Mnesia, for instance is part of OTP (and it comes with a graphical table explorer). Other tools, like a process explorer, and a graphical debugger are there as well. The ability to reload code on the fly is almost native to Erlang. And with a few lines of code you can do this across processes/machines (this starts becoming critical once your deployment infrastructure grows).

Also, OTP comes with what is known in Erlang world as gen_servers, which basically allows you to easily create synchronous and/or asynchronous services which can be called from any Erlang node. Another one of these hidden gems which makes your life way easier...

Community
The Erlang community is definitely smaller than the Ruby/Python communities, no doubt about this. But maybe this is not such a bad thing: small communities tend be more proactive in helping newcomers. People are more available (it's not unusual to see Joe Armstrong, the father of Erlang, reply to your posts on the mailing lists...). It's the same warm, small community feeling you experience when you get a Mac. Hard to describe though...

The best tool for the job
Let's forget about languages for a second. Let's look at what you really need to develop a scalable Web2.0 app. With Ajax being all over the place, you start seeing the need to serve a lot of small requests (don't render the whole page again, but only areas affected by your click. Single page apps are the new black !) This is where having a language explicitly designed to handle massive concurrent processes brings you a competitive advantage.

Look at our latest code push for instance. We just introduced the ability to have live review sessions for PowerPoint slides. You basically see other people currently reviewing the same presentation, you can leave real time notes and also have to ability to send quick IM messages. Think about what really happens in the background for a second. Because all of this is real time, every user is constantly going to the server asking "is there any new note/IM message to display" ? Now, we decided to go with a simple polling approach (== no Comet). This means we have to handle a lot of tiny requests/responses. This would be almost suicidal in any other language (or you would need to start adding plenty of servers to support any decent number of users). But not quite so in Erlang since the language was designed for this type of workload... It just scales beautifully (and yes, we still need to add extra servers as well to handle a large load, but just not as many...)

Here is a picture of what our app looks like (to fully appreciate the live functionality, you will have to sign up)

I could just go on and on about why I think Erlang is going to be a source of competitive advantage in the Web2.0 world. I am convinced we will start seeing more and more startups out there leveraging the power of massive concurrency. At the end of the day, the question you should be asking is not why WE are using Erlang, but why you are NOT using it ?

ps: just so that there is no confusion, this is not a RoR bashing article. I am myself a huge rails fan (and DHH is my hero, of course). But let's keep in mind that rails is not the answer to everything...

Technorati Tags: ajax, erlang, programming, rails, ror, ruby, Web20

Do you value your time at more than $4 per hour?

As you may have seen on TechCrunch, SlideAware just launched the capability for a group of users to collaboratively review and provide feedback on a PowerPoint presentation.

For the release we updated our website to include a product tour of the new features. As with our previous product tours we created it in Microsoft PowerPoint and published it by embedding the presentation on our website as a SlideAware SlideShow.

While I was responsible for creating the tours in PowerPoint the rest of the team: Didier, Wolf & Vijay had significant input into the content. We are firm believers in being the earliest adopters of our own products for REAL work, so all of this input and feedback was provided using SlideAware. Eighteen notes and two iterations of review & update later, we had the final version of the tour.

Using SlideAware to support the process meant that there were only 3 versions of the PowerPoint (my initial version + 2 updates) vs the 11 versions (mine plus 2 each from the other guys including their comments) that there would have been without SlideAware. The net result being, I spent less time incorporating their feed back and getting the updated versions out.

The process was also more engaging, we did the second review in realtime while on a conference call, and because everyones notes are instantly visible we were able to get feedback on the feedback as well as on my original content

All told I can safely say that we ended up with a better quality presentation and cut at least 3 hours from the process, about 25% of the total time it would have taken had i not been using SlideAware. If this was the only thing that I did with SlideAware this month I would have to value my time at less than $4 per hour for the $12 subscription fee to not be a complete no brainer.

To see the end result take a look at the final product tour at http://personal.slideaware.com/view?l=nAWNU

Using Erlang for your Web 2.0 Application Server

In the last post, I gave an overview of the evolution we went through. Today I want to describe in more detail what we have built. There is a lot of ground to cover, so I will focus for now on the front-end of the server architecture, i.e., the part that interacts with the clients: the browser and the PowerPoint add-in.

We will discuss our approaches to database clustering (using pg2 and mnesia), full text search (using mnesia) and file storage (using Amazon S3) in future articles.

A simple URL mapping layer

We built a simple layer over Yaws to map URLs of the form x/y to calls to module www_x, function do_y and prepare the returned value (JSON, XML, HTML or simply an error code) for the response.
The AJAX calls and the XMLHttpRequests from Flash use JSON. The calls from the PowerPoint add-in expect XML. HTML is only generated for the requests that render the initial screens (login page, main page, etc).
The module www_x must also implement a check_access function that our layer calls first before calling do_y. Most of the time check_access calls a utility function that checks your cookies, in some cases no authentication is required (e.g. the login screen).

No sessions

The server keeps no state about sessions. Each request is self-contained which allows us to use any load balancing solution or to bring servers down for short amount of time without logging out users. Instead we rely on cookies (which we pass around as a request parameter, in the case of the PowerPoint add-in calls). Simply storing user (and other) ids in the cookie would be unsafe. Storing a key that would need to be looked up to recognize a user would effectively mean having persisted session ids. So instead, we store the user (and other) ids in the cookie in an encrypted string.

Apache + Yaws combo

On the deployment side, we started with Yaws serving static and dynamic content.
We then went through a benchmarking exercise (using Ab and Tsung).  We could fill an article just on that, let just say that at the end, Apache 2 with the right configuration and the worker MPM did better on our tests than Yaws 1.68.
After that, we had Apache for static requests, and Yaws behind Apache (using mod_proxy) for dynamic requests. More benchmarking showed us that Yaws alone was much better than Apache + mod_proxy + Yaws for dynamic requests.
So now, we have Apache 2 for static requests and Yaws for dynamic requests. personal.slideaware.com goes to Yaws while static.slideaware.com goes to Apache.

Coming next...

SlideAware  Personal helps user distribute presentations:

• either asynchronously with controls about who can see the presentation and analytics about what was seen and who saw it,
• or synchronously (think WebEx).

Our next technology post will describe how we can support many live slide shows simultaneously thanks to Erlang.

Enabling Niche Marketing with Web 2.0 Tools

In today's competitive environment sales and marketing folks are tasked with creating targeted messaging for micro-market niches, delivering that message across multiple channels and monitoring the campaign's execution. The true challenge is however executing the campaign within budget and an acceptable timeframe, made difficult as it typically requires significant resources from outside the sales and marketing team to:

• Create the rich content, usually in the form of a website or flash movie, and provide the hardware infrastructure to host it.
• Store the files containing additional materials, product spec sheets, pricing spreadsheets, white papers etc, and make them available online
• Create the forms and databases necessary to gather additional customer information
• Provide reporting tools to monitor the campaign

There is however an alternative approach if you are missing one or more of the components above, and don't have the budget or time to put it in place.

To illustrate this approach I created an example using a tool box of products and services that could easily be used by the average sales and marketing person to execute a niche marketing campaign. Click through the example below to see how you can:

• Create rich content using Microsoft PowerPoint
• Publish it as a SlideShow using SlideAware that can then be: embedded in a Website; Blog; or distributed in an email campaign
• Provide access to additional information using Joyent's BingoDisk
• Gather additional customer data using Wufoo

From Python to Ruby on Rails to Erlang…

We started working on SlideAware Workgroups about a year ago. After collecting feedback from Alpha users in November 06, we decided to build the simpler SlideAware Personal which allows users to publish presentation to a URL and conduct live slideshows. SlideAware Personal has been live since March 07. SlideAware Workgroups will be released in the next few months. Both applications share the same architecture.

There are really two front-ends:

• The PowerPoint toolbar which provides buttons to allow users to very easily send slides to SlideAware or get feedback from co-workers. It is written in Visual Basic Application and leverages external DLLs for image and flash generation, file compression, etc.

• The web application leverages Dojo and Scriptaculous and interacts with the server using XmlHttpRequest. The user interface is entirely done in JavaScript in the browser. The JavaScript code manipulates the business objects (slides, presentations, tags, users,  etc.) and generates the user interface using Dojo widgets. The server is invoked to persist and query objects. It serves data as JSON instead of sending back HTML snippets.

The back-end has gone through several iterations.

We wrote the first version (0.1) of SlideAware Workgroups using Python and TurboGears. TurboGears combines a template engine (Kid), an object-relational mapping manager (SQLObject). Data (slides, presentations, tags, users) was stored in a SQLite database, while text indexes for the slides’ content were stored using Lucene. We leveraged xml-rpc to communicate between the python server and the java server (Lucene). We had a Jython wrapper on the java side.

We decided to switch to Ruby on Rails for the second version (0.2) of SlideAware Workgroups. Rails has a much larger following and finding solutions to issues is therefore a lot easier. Because the presentation layer is entirely done in the browser in JavaScript, our back-end code is fairly lean and was ported to Ruby on Rails in a matter of weeks. We kept SQLite, xml-rpc and Lucene. We added Lighttpd in the mix as our web server.

At that point, we started wondering about how our heterogeneous back-end stack could be made available, reliable and scalable. We had been hearing for a while about Erlang, the concurrent programming language initially developed at Ericson,  and Mnesia the real-time distributed database written in Erlang that is part of Erlang’s Open Telecom Platform,  and Yaws the web server written in Erlang.

We liked the idea of replacing our multiple language stack (Lighttpd + RoR + SQLlite + XMLRpc + Jython + Lucene) with an Erlang-only solution (Yaws + Mnesia + Erlang).

We were particularly intrigued by the promises of:

• High concurrency: Yaws leverages Erlang’s  light-weight threading system and supposedly performs very well under high concurrency. Mnesia’s tables can be replicated across nodes to allow more reads to happen concurrently.
• High performance: Mnesia resides in memory and is built to allow fast real-time lookups.
• High reliability: Erlang flagship project, the AXD301 which has over 2 million lines of Erlang has achieved a NINE nines reliability (yes, you read that right, 99.9999999%).

So we made the switch for version 0.5 of SlideAware Workgroups.

In my next post, I’ll tell you whether Erlang lived up to our expectations…

Where presentations and enterprise wikis meet

Many of the typical usecases for wikis in the enterprise are to support business processes that either:

• Result in presentations, or
• Would greatly benefit from the inclusion of rich content in a presentation format

While most wikis currently support embedding of rich content as images, they do not effectively support rich content in a presentation format.  This support needs to go beyond a sequential SlideShow that uses an embedded image per slide.  A number of other key functional requirements that have to be met, including:

• Content security: Most of the content in these use cases is confidential and at a minimum should be subject to the same access controls as the wiki page in which they are embedded.
• Rich presentation functionality: Explaining complex concepts is easier when builds are used to introduce points incrementally.  Additionally builds are extremely effective when you need to associate points with highlighted areas of images.
• Embedding & links to external content: Wiki pages are great for establishing context and can provide a strong context for the content of an embedded presentation.  The value of a presentation's content is however greatly enhanced if you can link it to external information either in the wiki or out on the broader internet.
• Ease of use: The reason for the success of wikis was that they made it easy for content producers to publish & update content, the same needs to apply to the presentation content itself.

As an example I have created a wiki page and used SlideAware to embed a couple of presentations that illustrate the importance of these requirements for the following usecases:

• Knowledge management
• Product specification
• Project management

View the SlideAware Wiki Example