Blowing Bubbles: A Radically Different Type of IDE

A group at Brown University has a very different take on the ubiquitous “IDE”‘s or “Integrated Development Environment”s) in which programmers live as they write and debug their code. The design uses what seems at times like a never-ending collection of bubbles in ways that are by turns ingenious and overwhelming:

Although the graphics are certainly more pleasant than the IDEs I’m used to, I find myself constantly lost as I try to establish my context within the overall program, and the sense of watching a program’s flow through this metaphor is unusual to say the least. Ultimately, I find I’m more drawn to the team’s other ideas (such as code factoring via a simple direct manipulation gesture) than I am to their overall bubble metaphor.

For more, see the team’s site at:

What do you think?


One response to “Blowing Bubbles: A Radically Different Type of IDE

  1. I liked the ideas in the bubble metaphor. As far as context, when you are working with a large code base context is also hard to establish with current IDEs. Most IDEs are set up to examine one file at a time, so you spend a significant amount of time tabbing between windows (alt-F6 in Eclipse…use it all the time). In fact, being able to “establish the context”, as you say in your post, is I believe the strength of code bubbles.

    When you are working on a largish program (in my case, about 200K lines), keeping track of context: where is this method used within a clique of components? What does it use? often becomes mentally tiring, and critical for correct development. With this tool, you can create this context once and have it immediately visible with the bubble group, rather than having to tab through several files. You, the programmer, have to create and name sensible groups, but I don’t think I’d find this too difficult.

    They had to show everything in one video, making it quite confusing. However, I suspect that you would have a few groups that define the current working set of methods under development or test and that would be a very convenient view of what one is working on.

    The debugging stuff I thought that was very cool. I consistently end up flipping back and forth between methods to gain context for the current execution. Having that information immediately visible through the call stack bubbles would (I think) make the flow much easier for complex debugging problems.

    So much of coding is contextual – sliding back and forth along the call stack whether statically or at runtime. I think that code bubbles support that pretty well. On the other hand, this tool may be an excuse to ask for a second 30″ monitor – it uses up screen real estate at a prodigious rate.

    The use of F9, stolen from the Mac, is a nice touch, though I’m not sure how well it will work in this context since all bubbles look more or less alike. I use F9 all the time on my Mac at home to “find” some doc when I have 20 programs open and find it consistently faster than the tools I have in Windows 7 at work. I would like it better if the group names were overlayed so that it would be straightforward to pick out the group you want.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s