Home‎ > ‎


This page contains recent announcements related to the project.

Better Rhizosphere treemaps in Google Spreadsheets

posted 21 Mar 2011, 07:19 by Riccardo Govoni

Rhizosphere v0.7 has just been released and includes important improvements in the area of Google Spreadsheets and Google Visualization integration.

Since the earliest releases of Rhizosphere, you have always been able to visualize data from your Google Spreadsheets or any custom Google Visualization API datasource. However, up until today, you only had access to a subset of Rhizosphere features when loading data from those sources. The main issue was related to the fact that both Spreadsheets and Google Visualization API model the datasets they handle as a bi-dimensional tabular data. This limits the type of relationships you can define: there is no explicit way in Google Spreadsheets to specify that a given row (for example representing an employee record) is linked to any other row (for example representing the employee manager). As a consequence, Rhizosphere was not able to offer advanced visualizations (like trees and treemaps) when visualizing data loaded directly from Google Spreadsheets.

Rhizosphere v0.7 introduces several conventions you can use to represent hierarchical data in Google Spreadsheets (and any other Google Visualization API datasource). You have now access to Rhizosphere tree and nested treemap representations of your Google Spreadsheets data. This builds on top of existing Rhizosphere features, which means you can slice'n'dice Spreadsheet-based treemaps using Rhizosphere dynamic filters and navigate them back and forward using Rhizosphere HTML5 History support.

Rhizosphere feature set surpasses equivalent visualizations that have been available so far (Google Visualization orchart, Google Visualization treemap):
  • You can define as many hierarchies as you want on your data. You are not limited to one.
  • Any hierarchy can have more than one root. You are not limited to representing a single tree of information.
  • Rhizosphere trees and treemaps react in real-time to the visualization filters you apply. You can dive to any depth of your treemaps, change the coloring or area rules on the fly (Google Visualization treemap is statically bound to a single area and/or color dimension at creation time), and then navigate back and forward over your analysis using the browser back/forward buttons.

Get started

Get started by having a look at the documentation for Google Spreadsheet users and Google Visualization API users.

How to represent hierarchical data in Google Spreadsheets

If you want Rhizosphere to infer a hierarchical structure from your Google Spreadsheet data, use any of the following conventions.

Describe parent-child relationships

Define two adjacent columns, the first containing an identifier of the datapoint the row represents (such as the name of the employee, in the organizational chart scenario), the second containing an identifier of the parent datapoint (such as the employee manager). If a record has no parent, leave the value of the second column empty.

Make sure the label of the column containing the parent data follows this naming rule: Parent + label of the preceding column. For example, in the organizational chart case, the first column might have the "Employee" label, and the second column will have the "ParentEmployee" label.

Rhizosphere will automatically pick up the relationship between the two columns and will let you display the data using either trees or treemaps.

Describe tree branches using multiple columns

Alternatively, you can define hierarchical data by fully describing the branch of the tree each spreadsheet row belongs to. Define as many adjacent columns as the depth of the tree you want to represent. Make sure all the colums have the same label. Then, for every row, fill the columns with node values running from the tree root down to the element the row itself represents (or belongs to).

Again, Rhizosphere will automatically rebuild the tree structure for you.

Describe tree branches using a single comma-separated column

Finally, you can also put all your hierarchical information in a single column. Fill the columns with node values running from the tree root down to the element the row itself represents (or belongs to), separating them with commas. If you do so, add the CATHIE word tag to the column label. Rhizosphere will notice the column label and try to rebuild the tree from the column values.

Multiple hierarchies

You are not limited to having a single hierarchy in your data. Rhizosphere can handle as many as you want. Here you can find a slightly more complex example that list employees of a fictional store arranging them both according to their organizational chart and according to the department they work in.

The two included Rhizosphere visualizations display the organizational chart and a treemap of sales data arranged by department. You can find the original spreadsheet here.

Rhizosphere mirror at GitHub

posted 6 Mar 2011, 08:17 by Riccardo Govoni

For those of you in love with git and Github, Rhizosphere code is now also available at https://github.com/battlehorse/rhizosphere. Happy forking!

Rhizosphere and Google Visualizations

posted 22 Feb 2011, 16:16 by Riccardo Govoni

Rhizosphere has been able to consume Google Visualization datasources (like Google Docs spreadsheets) since the very first versions of the library, but up until now it didn't fully conform to the specs expected from standard Google visualizations. This implied that, while you were able to visualize in Rhizosphere data coming from the same sources that would power other Google charts, you would have to write custom code for Rhizosphere to do so.

Starting from version 0.5 of the library, which we released today, you can access Rhizosphere as a standard Google Visualization. This is true both for the javascript version of the library and the just released gwt version of it. You can access the documentation for both versions here:
Using Rhizosphere in a page that already uses Google Visualization DataTables for its visualization needs is now as simple as creating a Rhizosphere instance and passing it the datatable via the standard draw() method.

To get you started, we prepared a couple of samples, for both javascript and gwt developers. You can access the javascript sample here and the GWT sample by choosing the Google Visualization tab in the GWT demo application.

Use Rhizosphere with Google Web Toolkit

posted 22 Feb 2011, 15:45 by Riccardo Govoni

After more than a month of sustained work, and over 3 months since the last update, we are finally releasing a new version of the Rhizosphere library (v 0.5) which includes full support for Google Web Toolkit applications.

You can now use Rhizosphere in any GWT application, simply by including the brand new Rhizosphere GWT module in your project. Rhizosphere support for GWT works by providing a Java facade to the underlying javascript library that will be embedded in your application, but it's not limited to just that.

It includes a whole set of features dedicated to GWT developers:
  • asynchronous inclusion of Rhizosphere libraries, so you can have them injected in your application only when the user needs it, minimizing performance impact,
  • use your own POJOs to define the datapoints to visualize,
  • coupled with a powerful annotation-based visualization configuration mechanism,
  • full support for GWT widgets and UiBinder templates to define the visualization UI elements,
  • full support for Google Visualization APIs for GWT to let you use Rhizosphere as a standard Google Visualization even within GWT.
To help you get started with Rhizosphere GWT, we have prepared a lot of material:
  • Comprehensive documentation on how to install, setup and use Rhizosphere within your GWT app,
  • Javadocs for the entire Rhizosphere module,
  • a working demo application at rhizospheregwt.appspot.com that includes annotated examples of all the features supported by the module.
Have a look at it. Once you are ready, you can download the module jar file from the Rhizosphere downloads area and follow the instructions to start using it in your GWT app.

For this release, we'd like to thank Dino Derek Hughes of Google UK that kickstarted the whole GWT branch developing the first proof of concept integration of the Rhizosphere library.

Manage your Google Code projects with Rhizosphere

posted 17 Nov 2010, 07:04 by Riccardo Govoni

We have just released a new showcase application to demonstrate Rhizosphere capabilities! 

If you are a software developer or project manager and have your project hosted on Google Code, you can now browse and manage your issue lists with Rhizosphere.

Just point your browser to the following link and enter the name of your project:

By default, you will get a visualization showing all the issues ever created on your project (including closed ones).

By setting the Advanced Options, you can refine your query to match only open issues, issues to verify, issues that you own or have starred. You can also limit the date range and focus on issues that have been recently created or modified. You can also choose the amount of detail that you want to see per issue.

Once you choose your project, Rhizosphere will load the project data using the Google Code Hosting APIs and present you with a card-based interface. You can then use Rhizosphere to manipulate and browse through your project issues. For those of you who like Agile development and walls full of post-it notes, we hope you will enjoy this!

You can now visually analyze a variety of information about your project: use treemaps to identify issues that most of your users want to see solved, group issues according to any of the custom labels you defined for your project, limit the set of issues being inspected using Rhizosphere dynamic filtering capabilities.

You can chose to display each issue as a brief overview (only the summary and its open/closed state will be visible) or with full details (which include issue labels, opening and closing date, blocking bugs, issue reporters and owners). You can also jump into any issue details by click the issue id number.

We have recorded a few videos to help you get started. You can find them below.

A note about accessing your Google Code data

Rhizosphere accesses your Google Code Data using the Google Code Hosting APIs. This means that by default Rhizosphere only accesses issues that are publicly visible to anyone. Whenever you use Rhizosphere to access your private or personal data (such as requesting the list of issues that you have starred on a given project), Rhizosphere will ask for your permission using the AuthSub authorization protocol. This means that Rhizosphere will never have access to your Google account password.

Additionally, Rhizosphere stores the AuthSub authentication token only temporarily, and any authorizations you granted to Rhizosphere will expire when you close your browser.


Using Rhizosphere to access your Google Code project data gives you a number of benefits:
  • Mobile access: You can access your issue lists from your PC and from your mobile devices (with a dedicated, mobile-friendly interface), so you can keep track of your tasks also when you are on the go! We tested Rhizosphere for Google Code on iPad, iPhone and iPod touch devices. We also have preliminary support for Android devices, although functionality is limited because of some known bugs.
  • Presentation mode: You can broadcast remotely any action that you perform while managing your Google Code project via Rhizosphere. If you work on a distributed team, you can drive your weekly iteration planning from your desk (or maybe your iPad!) while other team members on other side of the world follow you in real time on a shared project view. Have a look at the videos below, or learn more about Rhizosphere broadcasting capabilities.
  • Treemaps: Use layout and clustering algorithms which are not available on Google Code. For example, create a treemap of your issues by the number of stars each one received, to quickly identify and prioritize most wanted items.
  • Dynamic Filters: Use Rhizosphere filtering capabilities to slice'n'dice all your project activities in real time.
  • and all other standard features that come with any Rhizosphere visualization.

Demo Videos

The following video gives a basic introduction on how to use Rhizosphere for Google Code project management:
The following video shows how you can broadcast a visualization for others to follow, and how you can access your Google Code projects data from mobile devices:
If you are interested about Presentation mode and mobile access, we also recommend these live demos about broadcasting a Google Code project analysis from a PC to multiple mobile devices and viceversa from a mobile device to PC.


When using Rhizosphere for your Google Code project management activities, keep in mind that:
  • Rhizosphere is still an experimental library, and Google Code integration even more so. Don't be surprised if you find strange behaviors or quirks, and help us improve it by filing new bugs!
  • This integration with Google Code exists to demonstrate Rhizosphere capabilities. Although we aim to provide a useful service, we may not be able to offer a rich enough feature set to cover all project management needs.
  • We currently offer a read-only view of your project activities. We plan to introduce bulk actions and issue manipulation features soon, but they're not quite ready yet!
  • Because of the limitations in the APIs and services used, you might not be able to load all your project issues with Rhizosphere, if you happen to manage a big project with thousands of bugs. We recommend you limit the visualization only to issues that matter to you most (such as looking at bugs opened in the last few months only).

Learn more about Rhizosphere

If we managed to get you excited about Rhizosphere, you should consider following our project activities or keeping an eye on Rhizosphere on Twitter.

New rhizosphere domain: www.rhizospherejs.com

posted 10 Nov 2010, 09:45 by Riccardo Govoni   [ updated 10 Nov 2010, 10:38 ]

You can now access Rhizosphere demos and documentation at www.rhizospherejs.com (this will live alongside the current rhizospherejs.appspot.com for the foreseeable future, so no hurry in updating your bookmarks). We also added a number of subdomains to simplify URLs even further. To summarize the relevant Rhizosphere links:

Rhizosphere broadcasting via AppEngine Channel API

posted 10 Nov 2010, 06:24 by Riccardo Govoni   [ updated 10 Nov 2010, 08:46 ]

Update: If you are only interested in learning how Rhizosphere uses the AppEngine Channel API, skip to the last paragraph of this article. You can find the relevant code in rhizo.broadcast.js (client side, focus on the rhizo.broadcast.Transmitter class) and broadcast.py (server-side).

During the last Google I/O gathering, the Appengine team presented a new set of APIs called the Channel API. The Channel API allows real-time bi-directional communication between Appengine applications and their clients, including server push and other similar features previously known collectively under the name of Comet (you can learn more by watching the Google I/O presentation video). This is a fundamental requirement to implement social features in web applications where multiple users can collaborate together on the same task. Think about chat rooms, shared editing of Google Documents or broadcasting a Google docs Presentation to multiple attendees.

Rhizosphere is tool dedicated to slicing and dicing datasets in a visual way. Wouldn't it be great to be able to do so collaboratively, allowing others to see the analyses that you are performing on any given dataset?

Wait no more! In the last few weeks we have improved Rhizosphere to integrate with the Channel API and you can now broadcast in real-time any analysis you perform on a visualization to any audience you might want to target. Broadcasting a visualization takes just the click of a button and it works in the same ways of a Google docs presentation mode: you drive the visualization and every attendee to which you sent the visualization URL will be able to follow any operation you are performing on the visualization (assuming they also have access to the underlying data you are visualizing through Rhizosphere).

The following video shows how easy is to use this new feature.

Rhizosphere broadcasting demo

Broadcasting a visualization is extremely easy and you don't need anything more than your browser. The Rhizosphere backend and Google Appengine systems take care of all the details. It works seamlessly with any browser currently supported by Rhizosphere (Chrome, Safari, Firefox, Opera) and it integrates nicely with Rhizosphere history management , meaning that you can still use your browser navigation buttons to move through the visualization state, and all attendees will also pick the changes up.

However, keep in mind that the Appengine Channel API is still under testing and not officially released at the time of this writing. Also Rhizosphere code that uses such API is just out of the oven, so it may still be rough on the edges. For this reason you should consider this feature experimental and the following caveats apply:
  • Several features are still missing (such as tracking the number of attendees) and error detection (such as connection terminations and timeouts) is very basic. A few known bugs exist in the current implementation (you can track the current status of Rhizosphere broadcasting from the project issue tracker)
  • Although Rhizosphere implementation of the broadcasting feature is fairly general, the only current implementation relies on Google Appengine infrastructure to provide the messaging backends required for it to work. You won't be able to use the feature if you are deploying your own custom visualizations built on top of Rhizosphere outside of Google Appengine.
  • Rhizosphere broadcasts are currently uni-directional only: there is one presenter and multiple attendees. It is still not possible to have full bi-directional collaboration where multiple persons collaboratively manipulate a given visualization.

How do I broadcast my visualizations?

Rhizosphere broadcasting is an experimental feature that you can enable in any of the demos available at http://rhizospherejs.appspot.com. Be sure to have the experimental features checkbox toggle before activating any demo. You will then find a Broadcast button among the other visualization controls. When you hit that the visualization will start broadcasting its state and you will be offered a link pointing to the broadcast URL. Share that link with any person that wants to join the visualization and start playing!

Both the presenter and all the attendees can stop/resume broadcasting any time they want. Visualization state will be automatically re-synced once resuming either broadcasting or following.

Please remember that Rhizosphere broadcasting is not encrypted and broadcast URLs are by default public: although they are difficult to guess, there is no access control mechanism and anybody that has the link to a shared visualization can join it. Keep this mind if you plan on sharing confidential information via Rhizosphere broadcasting.

If you are familiar with hand-on coding and want to enable broadcasting in your custom Rhizosphere visualizations, you just have to include the rhizo.broadcast.BaseComponent UI control (defined in rhizo.broadcast.js) in your visualization chrome. Have a look at this template page to get an idea on how to do it and familiarize yourself with the documentation about Rhizosphere UI concepts. We will update the documentation with specific examples shortly.

What about mobile devices?

No worries, they are supported out of the box, both to broadcast and receive shared Rhizosphere visualizations. Look at the screenshot to the right for an example of a visualization broadcast from an iPhone to a desktop browser.

Because Rhizosphere UI is tailored for the device it runs on, you will be able to share the same experience between all participating users, no matter what device they are using, with Rhizosphere taking care of rescaling and tweaking the visualization to match the device capabilities.

Rhizosphere broadcasting is not expensive in terms of resources and it shouldn't bog your phone down, however at the current stage of development, we tested Rhizosphere broadcasting only on high-end mobile devices (iPhone, iPad, iPod Touch and Android 2.2+) and on high-speed networks (3G or wifi).

Broadcasting Internals

This paragraph is for those among you interested in learning more about how Rhizosphere interfaces with the Google Appengine Channel API.

Rhizosphere already has a module, defined in rhizo.state.js, dedicated to distributing state information among the different entities that participate in a Rhizosphere visualization. It is the so called State Manager. The State Manager is aware of the current visualization state (more exactly, it is aware of the state of all visualizations that exist in a given web page, if multiple ones are present) and it can compute the delta changes that transition the visualization from one state to the next (for example, the user changing the visualization layout, or applying some filters). Among other things, the State Manager is responsible for integrating a visualization with the browser history capabilities, so that you can use the back/forward buttons of your browser to navigate through the visualization states.

To integrate with Appengine Channel API, we simply added a new pair of bindings to the State Manager, so that any local state change that occurs in a visualization will be pushed upstream to the Appengine servers, which will in turn push it to any other participating client. On the receiving end, the client just pushes state changes receive from the wire to the local State Manager which applies them to the local visualization.

The following diagram explains the sequence of events:

Note that because the existing state management infrastructure is re-used, history is accumulated also on the receiving side of a shared Rhizosphere visualization, meaning that the user at the receiving end can replay the visualization using his browser back/forward buttons just like he would do with a local visualization!

Plain Ajax requests are used to publish state changes from the broadcasting side. Appengine Channels came into play to push received changes in real-time to all other attendees of the shared visualization.

The Rhizosphere components that come into play client-side to realize all the above are defined in the rhizo.broadcast.js module:
  • rhizo.broadcast.BaseComponent : the UI control that let the user start and stop a broadcast (or follow / unfollow a visualization broadcast elsewhere ).
  • rhizo.broadcast.FollowStateBinder, rhizo.broadcast.BroadcastStateBinder : components respectively responsible for publishing local changes to AppEngine and applying to the local environment remotely received changes.
  • rhizo.broadcast.Transmitter : the actual facade in front of the Google AppEngine Channel API. It is responsible for establishing bidirectional channels, receiving and publishing messages.
On the server side, the Appengine handlers defined in broadcast.py handle the logic to establish a new channel and to distribute incoming messages to all registered listeners.
For more information about the Appengine Channel API internals, refer to the slides from the Google I/O presentation (pdf).

Brand new documentation

posted 22 Oct 2010, 05:43 by Riccardo Govoni   [ updated 22 Oct 2010, 06:25 ]

If you so far shied away from Rhizosphere for its lack of documentation, fear no more!

We just launched a completely revamped documentation site, with extensive documentation for end users, developers and contributors.

We will also soon include detailed API docs for the whole Rhizosphere library, to make Rhizosphere even easier to understand, if you are interested in its internals.

At the same time, we are also launching a new Rhizosphere Google discussion group where you are free to discuss Rhizosphere features and ask questions.

Want some more? Have a look at all the possible ways you have to contribute to Rhizosphere.

Stateful visualizations with HTML5 History

posted 18 Oct 2010, 09:51 by Riccardo Govoni

HTML5 brings many innovations to the web development landscape. One of the new features is HTML5 History (w3c spec): a set of APIs to manage the navigation context and browser history via the back / forward navigation buttons.

Before the advent of HTML5, browser history management was pretty much limited to full-page navigation from one url to the next. This doesn't work well with javascript-heavy web applications that rely on javascript code to manage their state, rather than navigation between URL.

Rhizosphere is one of such applications, where there are no transitions between webpages, but the entire application live inside a webpage, with javascript code doing the heavy lifting and managing the entire UI. Up to today, Rhizosphere had no history management, meaning you could not use the browser buttons to transition between Rhizosphere visualization states (hitting the back button, for instance, would bring you out of Rhizosphere, to the page you were browsing before).

Today, we released the new rhizo.state module that enables HTML5 history navigation in Rhizosphere for browsers that support it (Chrome, Safari 5 and Firefox 4 beta at the time of writing), out of the box with no configuration needed.

Try it by yourself on some sample visualizations (picasa, bugs, multiple visualizations per page) : perform some sample operations and then try moving back and forward using the browser buttons.

Support is extensive, and Rhizosphere tracks the state of all its features: layouts, filters, selections and even any drag'n'drop you perform. You can now replay any operation you perform on the visualization, moving back and forward through the history. See the video demonstration:

Rhizosphere HTML5 History demo

More importantly, since Rhizosphere history management is integrated with the rest of the browser navigation history, you can follow outgoing links and navigate out of Rhizosphere, with the guarantee that Rhizosphere will be restored in the state you left it when you navigate back to it.

Rhizosphere history works seamlessly also when you have multiple Rhizosphere visualizations on a page, or when Rhizosphere is embedded as a gadget with a Google Spreadsheet, iGoogle or other contexts.

Tech details

If you are interested in the technical details, have a look at the documentation on top of the rhizo.state module. HTML5 History is not a final spec yet, so it has been quite fun to work around the existing quirks and provide a solid implementation and user experience.

(image courtesy of http://www.madreinspain.com/ )

Support for Internet Explorer (9) on its way

posted 13 Oct 2010, 04:19 by Riccardo Govoni

Rhizosphere do not officially support Internet Explorer yet. The current solution we recommend is to use Google Chrome Frame instead. However, Internet Explorer 9 (currently in beta) standards support is much improved compared to the previous versions. Rhizosphere runs on top of IE9 almost without issues (some drag'n'drop functionalities are not working at the moment, and there might be other bugs).

If your browser of choice is Internet Explorer, please give the IE9 beta a try with Rhizosphere.

1-10 of 32