
New IDE: code bubbles - maxharris
http://www.cs.brown.edu/people/acb/codebubbles_site.htm
======
chubbard
I like the concepts of the bubbles and the fact that it show call execution so
well instead of one file at a time. That's really cool, but what I find so
amazing is that since they built on top of Eclipse they got much further
towards a usable system like having an integrated debugger was a nice surprise
to me. 10-20 years ago the gap between an academic project and a finished
product would have been much wider. Not to mention they got to explore more
ground with the concept. Just shows how open source software enables
innovation better.

------
d4ft
I feel like the response has been fairly lukewarm, but to me this is some
really nice (dare I say game-changing) stuff. Mindmap + IDE = great. Why? I
have written in a variety of languages, and my number one complaint, whether
it be with eclipse, textmate, vim, emacs, whatever, is the clumsiness of going
from one file to another and then back to the original. Further, outside of
actual development, when debugging, I really like to have all the different
pieces open at once. This is a nice way for this to happen and is pretty slick
with the different gui movement options. I, like other posters, would be
really psyched if you could have some kind of MVC opener which would
automagically open all the code files using a certain view. That would save a
lot of time shuffling, and then save a lot of time by having them all
displayed simultaneously. Anyway, I'm probably over reacting, but after years
of having to go back to the mouse everytime i need to look at a new file or
struggling to figure out in which square i put which file, this is definitely,
in my opinion, a step in right direction.

~~~
jrockway
_my number one complaint, whether it be with eclipse, textmate, vim, emacs,
whatever, is the clumsiness of going from one file to another and then back to
the original_

Emacs has a stack for this. Jump to related definition with M-., jump back to
where you were before with M-∗. One keystroke is not exactly "clumsy", IMHO.

 _I, like other posters, would be really psyched if you could have some kind
of MVC opener which would automagically open all the code files using a
certain view._

I just open all files in the project with `eproject-open-all-project-files`.
Then I can iswitchb between them. (Of course, there are lots of extensions
that don't require you to have the files open to easily navigate to them;
eproject, anything, ido, etc.)

~~~
jacquesm
Have a look at the 'Leo' editor, it has views on your source using 'cloned'
nodes. It even allows you to group all the code around a bug and a fix
together, document the whole thing and never move any of the original code
around.

It's a pretty neat literate programming tool.

~~~
chipsy
Leo is really nice and I've used it on real projects to refactor and study my
architecture.

~~~
grayrest
I'd actually say that Leo is horrible except for the one feature that makes it
amazing (outlines). I find myself wanting to implement outlines in Vim but
knowing I never will.

~~~
chipsy
That's a fair assessment too. I don't use Leo for the general-purpose work and
new code because it gets in the way when you know what you want to write. But
it does work well if you need to learn what a large, spread out body of code
is doing. Just realigning the position of code helps to spot some previously
hidden repetition.

I would probably use it more if I wrote some scripts to autogen the outlines
for entire codebases.

------
Vivtek
That is a very interesting approach - instead of just presenting _files_ ,
this IDE is already abstracting out some of the semantic structure for you and
presenting code based on its _relationships_. It's meeting you halfway. _And_
it keeps track of things the way you work - by explicitly acknowledging the
task structure of the work, it's again meeting you halfway.

This is a really promising start. Very cool.

~~~
jasonkester
Programming hasn't been about files for a long time now. That's the reason
that we have IDEs in the first place, and why I cringe when people talk about
writing code in a text editor.

Any IDE worth its salt will do all the things in that video, except for the
little draggable bubbles.

~~~
jrockway
_I cringe when people talk about writing code in a text editor_

Yeah, because we have to type M-. to navigate to the related code.

(Also, insert rant about how "UNIX _is_ my IDE".)

~~~
mseebach
Emacs is a text editor in the same way the space shuttle is a vehicle.

~~~
sreque
Can your emacs editor construct hyperlinked call graphs showing all callers
and callees of a given function? Will this call graph generation remain up to
date as I edit files?

Can Emacs give me a hyper-linked list of all usages of a given symbol and do
it properly(lexical scope, etc.), not just doing a simple symbol search?

Can I edit my code in emacs, have a background compiler compile the file on
the fly, and also provide error feedback, hilighting the problem lines with a
tagged failure reason and also providing a hyper-linked list in another window
as well? Last I checked, the best I could do would be to kick off a compile
manually and navigate the errors as a linked list.

How's emacs' refactoring support? Judging by the following stackoverflow post,
it's pretty poor: [http://stackoverflow.com/questions/673554/how-can-i-
refactor...](http://stackoverflow.com/questions/673554/how-can-i-refactor-c-
source-code-using-emacs).

How's Emacs' keyword completion? Last I checked, it was just a hacky
dictionary look-up, whereas an IDE can semantically analyze the source to
provide intelligent suggestions.

Even if you can get Vim or Emacs to do some of the above, it usually isn't as
easy to use or as useful as an IDE. For instance, I know you can get call
graph support in Vim using cctree.vim, but it relies on cscope, which requires
refreshing the database manually, is slow to load, and tends to generate
incomplete tag sets.

IDE's are, well, better integrated, and so can do many things a lot better
than looser environments like Emacs and Vim. Their UI's tend to be a lot more
powerful because they are not designed to be run on windowless environments.
Personally, for small projects I use Vim and for large projects I use an IDE
with a Vim emulation plugin like Netbean's JVI plugin.

~~~
lutorm
Emacs can do whatever you want. If it doesn't, it can be added. In fact, Emacs
_is_ an IDE...

It's just not a mouse-based IDE. Mouse clicking makes my hands hurt much
faster than using the keyboard. I also find it annoying to switch from
mouse<->keyboard, so I don't want a UI that relies on constant mousing.

~~~
Silhouette
Respectfully, I think you're avoiding the main point of the post to which you
replied.

Good keyboard navigation in an editor is valuable, and many IDEs have poor
support for it. On this we can probably all agree.

But as I read it, the grandparent post was about functionality. Modern IDEs
have a level of semantic awareness that generic editors like Emacs don't, at
least not without a prohibitive amount of effort to implement it. As a text
editor, Emacs is very powerful. As a _code_ editor, it lacks support for even
basic semantic analysis, which means such tricks as it does have are naive
operations based on text matching. In a world where even entry-level IDEs have
support for basic refactoring, auto-completion and code navigation, Emacs is
the dinosaur that hasn't seen the asteroid yet: awesome raw power but
completely unaware of the bigger picture.

~~~
abstractbill
The flip side of this is: Emacs was invented around the time I was born, and
could be used to edit the languages that were available at the time. It can
still be used to edit those languages, as well as the hundreds (thousands?) of
languages that exist today. I won't be surprised if it's around in 10 or 20
years more, and _still_ able to edit every language under the sun at that
point.

Emacs may have a shallower understanding of languages than an IDE, but the
_breadth_ of languages it understands is pretty amazing.

~~~
Silhouette
Sure, but when you're working on a project that uses only a few languages,
specialised tools are always going to be much more effective, and you just
update the tools as you update your choice of language(s). Jack of all trades
is master of none, as the saying goes.

~~~
abstractbill
In many ways I'd love the luxury of writing code in just a few languages. The
reality is though, at justin.tv, I've needed to write code in (at least) 7
different languages over the past 2.5 years. I would not have liked to learn 7
different IDEs on top of learning new languages. (We don't tend to
gratuitously start using new languages - it's just often a requirement as a
project gets more ambitious and wants to do more things and reach more
targets).

~~~
Silhouette
I sympathise with you on the polylingual tendencies. I'm currently working on
something for one client that uses several different programming languages
plus the usual web-related stuff all on the same project (and with perfectly
legitimate reasons, not just because of historical baggage).

Still, I think this raises an interesting question: is it more beneficial to
choose exactly the right language for each project in isolation, or to adopt a
"good enough" general purpose language that can be learned in more depth by
the development team, and used together with comprehensive library support and
a strong and familiar IDE?

------
thetable
It's odd that it's so rare in software to find window widgets that push each
other out of the way instead of overlapping.

I'm thinking of the gazillion pallettes in Adobe CS that _always_ occlude each
other. You'd think they'd have figured that out by now.

~~~
altano
Visual Studio sort of does this. When you drag one pane over another, the
default is to have the panes be tiled or tabbed (depending on where you drag
it). It's all very intuitive too, with the arrows to guide you through what
you're doing. Visual Studio's window management is totally awesome and one of
my favorite features.

~~~
mhansen
Does it work well with multiple monitors yet?

~~~
altano
I was watching a channel9 video where one of the devs claimed multiple-monitor
support in 2010 was improved. I'm not sure how, or even what needs improving
for that matter (I use VS across two monitors.)

~~~
daok
VS2010 let you have 2 files open. In VS2008 you cannot have 2 sources code
file open in each of your screen. Only one (of course you can put other
windows to other screen but not multiple code windows).

~~~
altano
Oh! I've never tried that. That explains it. I only put panels on my 2nd
monitor.

------
viraptor
I see how useful it could be, but I wonder if it would be good for me. So far
I've tried to run in exactly the opposite direction:

1\. not using mouse at all

2\. concentrating on what needs to be _done_ to what _object_... not _where_

I'm a heavy Vim user, so I'm relying on ctags / incremental searching /
positions stack for a lot of work. This goes exactly the other way - click
your way through to the point you want to get to.

On the other hand, I'd probably prefer to fix bugs in this environment instead
of in Vim, because it gives a lot more context and freedom. It looks good
for... let's say "exploratory programming".

Maybe it's time to think 2 different IDEs - for "writing code" and for
"modifying code"?

~~~
Vivtek
But to your #2 - that seems to me to be exactly what this IDE is doing. That's
the way I see it, anyway.

~~~
viraptor
It's better than normal eclipse for sure - you get the arrow link between
related methods, etc.

What I meant is that in Vim I go to a name in ctags. That's what happens -
whether I'm in the same file, or different, or I looked at that tag before.
Type in tag name -> go - that's all that happens.

With code bubbles, I could have the bubble already open, but just off the
screen. Or maybe it's open in another dependency. Or maybe it's not open at
all. I have to look at the screen, localise the bubble, make a decision and
then do the action (either click existing bubble, or open a new one). Of
course it's too early to criticise it, without testing beforehand. But it
definitely got my attention, as something I tried to avoid. Having one good
way to access stuff == less thinking.

Let's say that Vim is stateless, but bubbles are stateful :)

~~~
nitrogen
It should be possible to add equivalent keyboard shortcuts to Code Bubbles, so
that finding a nearby bubble could be accomplished by ESC,/tagname or
something.

------
sofal
Guys, we need a better way for exploring big open source projects (like
Android, for example), preferably online. Google Code Search is pretty good,
but I think there is so much more that can be done.

~~~
alexgartrell
The most striking thing is how few people here have addressed this point.
Everyone seems to be living in a fantasy land where "learning APIs" is as
hairy as it gets. I've messed with portions of the Linux Kernel, Chromium,
Mozilla, and Coda Filesystem codebases. In each occasion, tools like code-
search (provided by lxr.linux.no, mxr.mozilla.org, Google COde, and even `find
. | xargs grep`) have been invaluable in getting anything done.

Chromium, Mozilla, and the Linux Kernel were unpleasant, but manageable with
the existing tools, because of the incredibly strict guidelines imposed upon
contributors as far as code style and other things. On the flip side, the Coda
Filesystem, which has grown as the result of many relatively disjoint Ph.D.
research projects) requires a whole lot of help and handholding from the guys
who have put a decade into it already. I can only imagine private code bases
being a LOT worse.

An IDE that makes semantic relationships more obvious to the new guys would do
a lot to ramp new people up faster and would really be a huge benefit from a
community standpoint as well as just being generally helpful to existing
developers.

That said, this is a good first step, and not necessarily perfect. It kind of
looks like a toy now, so managing screen real-estate better would be the next
big step, I think.

~~~
nitrogen
Do you find that "find . | xargs grep" is more useful than "grep -HnR" in some
way?

I recommend setting up cscope for hacking the kernel. I haven't done any
kernel hacking for a while, but when I did I found cscope (and vim+cscope)
very helpful. Since it's database-driven and designed to run on systems from
the 80s, it's still extremely fast.

------
snprbob86
This is awesome!

I'm kind of a weird mixed-bread developer. I'm now a heavy Vim user, but was
once a heavy IntelliJ IDEA user. I'm also currently a heavy Resharper user at
work. I understand the importance of really solid, visual tools, but I also
understand the importance of simplicity and flexibility. There is a middle
ground, I know it.

As an aside, I think that the GUI toolkit confusion is one of the biggest
blockers to this sort of innovation. Terminal emulation is just the lowest
common denominator. HTML/JS/CSS is the closest thing we have towards a
portable, successful GUI toolkit. And it's simply still not quite ready to
fight the advanced desktop graphics battle necessary for this sort of new
bread of tools.

------
abyx
2 things

1\. /Way/ too much mouse-action for coding in my opinion

2\. I saw no mention of the best killer feature I can see for this, which is
allowing refactoring and restructuring of code by extract bubbles, moving them
around, popping bubbles... I've been wanting to perform refactorings in a
visible fashion for quite some time now.

------
matrixownsyou
nice. i can see myself using this for django projects (a bubble for the
urls.py, another for the view and another for the template)

~~~
guelo
I'm thinking this won't work so well for dynamic languages. The demo video is
using a Java project.

~~~
jrockway
Because not declaring the type of variables makes code not work with bubbles?

~~~
guelo
The demo is relying heavily on code navigation features that are only
available to static language IDEs such as "Open Declaration", "Find All
References", code completion, navigating object hierarchies, code outlines,
inline docs, and other fancy code traversal techniques.

~~~
mulander
Take a look at Squeak. The Smalltalk folks have been doing this for a long
time _with_ the GUI utilities. SLIME is another dynamic environment that knows
and can tell You much about itself.

~~~
jrockway
This information comes from actually running the code.

Not that this is a bad thing, though. People seem really afraid of having the
code they just wrote be executed, but I think this is an unfounded fear. And,
as SLIME shows, you get great information from running the code; much better
than mere static analysis.

~~~
nitrogen
I was about to ask, "Why don't they just run the code, and provide something
like reverse debugging or VM state snapshots to explore different code paths?"
but it seems that's already been covered.

------
Quiark
Reminds me of Smalltalk...

~~~
jcromartie
Specifically Squeak... I wonder if it is built with Squeak?

~~~
Semiapies
No, Eclipse.

~~~
jcromartie
It is an Eclipse plugin, yes, but it could still be written in Squeak?

------
keltex
Note: requires monitor with 2560 x 1600 resolution.

~~~
jrockway
1920x1200, actually. And that is not too uncommon; I've had my monitor at home
for 5 years and it's that resolution.

~~~
viraptor
I'd highly recommend any serious programmer with a screen smaller than
1920x1200, to upgrade... and get two of them while they're at it. After some
time with that setup, it becomes painful to get back to something smaller.

I've tried 3 screens (in: square, wide, square configuration) for a while. I
wouldn't say no, if anyone gave me that again, but I didn't notice any
significant improvement over 2 screens.

~~~
jrockway
I've written lots of good code on my 9" eeepc, and didn't really hate the
experience that much. Conversely, I have 2 19" monitors at work, and don't
really find it productive at all. (We are asking for 2x 30", which should
help.)

The difference is that I use Linux/xmonad on my eeepc, and Windows XP at work.
A good window manager will make your computing experience 1000x more enjoyable
than a new monitor will.

(As I mentioned above, I have a 24" monitor at home and use xmonad with that.
Needless to say, that is the best environment of the three.)

------
jamesrcole
[edit: fixed link]

This approach might be conducive to RFS 5: Development on Handhelds
(<http://ycombinator.com/rfs5.html>).

Bubbles - smaller chunks of information more suitable for a small display

Arranged in a spatial layout - fits with the spatial, panning style of the
iPhone UI.

------
LiveTheDream
The main benefit of this IDE, compared to terminal stalwarts vim and emacs, is
the effective use of a large, high-resolution screen. The color-coding and
context grouping is really slick; IMO vim gets a bit visually confusing if you
split windows more than twice.

My main gripe about this system would be the normal one of moving back and
forth between the keyboard and mouse. Also I wonder how sluggish it gets if
you have multiple workspaces and debugger sessions open.

The alt+drag static call graph was another cool feature.

Ultimately, the best tool is the one you know best. Any IDE will have a very
tough time competing with 30-odd years of developers perfecting all the small
stuff in vim and emacs.

------
chaosmachine
Wow, I've been dreaming of being able to do exactly this for a long time, but
I didn't think I'd ever see it implemented.

------
shaunxcode
I have an unfinished project where I was attempting something similar - I am
going to throw it up on google code now and I guess put up a demo in case
anyone is interested in the code. It's all just simple javascript/jquery proof
of concept. You can see it here
<http://www.churchofturing.com/dragedit/dragedit.html> and google code is
<http://dragedit.googlecode.com>

~~~
jacquesm
Nice stuff! I just played around with it for a bit and it seems you have the
basis of something interesting there, now for an application!

~~~
shaunxcode
thanks - I am always hesitant to release projects where I know it is only a
quarter of the way there. But what good does it do just having it sit on my
hard drive? hah. There are some key bindings working ctrl+space creates a new
editing pane, ctrl+arrow keys should let you move between panes - however I
wrote this so long ago that I did not know ctrl+space brings up a menu on mac.
hah. The other key bindings do not seem to work on my mac either. If I get
some time this weekend I think I will polish this up, get
saving/loading/exporting working etc.

~~~
jacquesm
I've had this idea for a while and maybe this can be a part of implementing
it:

A website where programmers can contribute 'widgets' which can be mashed
together to create applications. Widgets would be written in python, and would
have access to a bunch of underlying services and to other widgets.

You'd use an interface like what you have here as the 'ide' to create the bits
and pieces of code that go in to making a component, and then a similar
interface to combine components in to working websites.

The end result would be hosted on the same service, either using your own URL
or using a subdomain of the service.

It sounds like a large amount of work though, to get that up and running,
especially the security angle is a complicated one.

------
houseabsolute
This is the IDE I didn't know I was missing. Navigating around the code is
undoubtedly the highest overhead task I do. This IDE seems like it fixes that
problem.

------
Semiapies
The smart tiling and interaction of "bubbles", beyond just IDE-centric
actions, most intrigued me. I'm reminded, of all things, of playing with the
Acme editor. The overarching task bar with nameable, savable, and shareable
sessions was nice, too.

Such things strike me as generalizable beyond just IDEs.

------
ximeng
Interesting idea. Drawing a line between two procedures to find the shortest
call path between them could save time navigating an unfamiliar codebase.

Edit: Also interesting - storing an old debug session with state and being
able to visually compare that with a debug session made after code changes.

------
InclinedPlane
Regardless of anyone's opinions of this particular IDE / workflow it's been
clear for a while that the future of developer tools will almost certainly
include:

\- IDEs that take advantage of greater knowledge of code than just a simple
organization of text files (e.g. reflection, call stacks, static and dynamic
analysis, etc.)

\- Tying bug-tracking, automated testing, and source control together in a
coherent way.

\- Generally merging the developer workflow into a seamless experience instead
of a disjoint series of steps across N sets of distinct tools.

Already we're seeing plenty of movement in this direction, with things like
visual studio's intellisense, more in-IDE unit test tools, and the plethora of
refactoring tools out there.

The days of IDEs that do little more than compile and keep track of
collections of files for you are numbered.

------
angusgr
I thought this was a really interesting idea. In uni (college) I became pretty
dependent on Mind Maps (using FreeMind) for planning essays. Laying all the
relevant concepts and relationships out visually worked really well for me.

From that angle, I think anything that helps programmers visualize the
structure of their software is a good thing. I think any half-decent
programmer is good at maintaining these kind of relationship graphs in their
head, anyhow. But that's no reason why tooling can't make that even better.
There's potential for a programmer to visualise the structure of their
program, beyond what they can hold in their head.

I also like that this idea encourages good overall design, short logically
arranged methods, and neatly compartmentalises "workspaces" in a visual way.

I have a few criticisms, though:

\- Nowhere near enough keyboard-driving for my liking. :).

\- It'd be great if zooming out could transform the representation a bit, so
instead of ant-size pieces of code the user could work with only the higher-
level abstractions between the bubbles they've laid out. I see this happening
from the "groups" and "workspaces", but not being inferred from the code
itself.

\- Is there some other way to show bubbles that were opened independently, but
are actually related in the code? Apart from drawing a specific line and
seeing the call graph (which is neat, btw.)

\- I'm concerned about what happens when a single workspace gets bigger than a
single window.

\- What happens when design (as it often needs to) breaks through neatly
defined abstractions, and lines start needing to be drawn all over the place.
Can Code Bubbles represent this without driving the programmer insane, and
(also) can it represent this in a way which encourages the programmer to see
better ways to refactor?

\- Arbitrary areas and names, in a flat namespace on a flat 2D plane, with no
relationships between them, is nice and simple. However, it seems like it
would limit you when working with big projects and lots of different, but
related, spaces.

------
mcormier
This is very interesting. To me it looks like it creates a hybrid interface
experience in between traditional programming and visual programming languages
such as Prograph.

<http://en.wikipedia.org/wiki/Prograph>

------
jurjenh
Its refreshing to see new ideas being implemented well. What makes this
particularly interesting is the panning desktop metaphor (which seems to be
getting more and more popular) and is quite appropriate for multi-touch
screens (think ipad).

It would be most interesting to see this idea extended in this manner, and
possibly alter it so coding can be done differently. One possible way might be
to have a collection of functions available, then link them together to create
new functions. In most cases, this could be done using relatively few
commands, so could be done on a touch-only screen.

------
peter_severin
I love Eclipse for enabling stuff like this.

------
defdac
What I like about Bubbles is that it manages to visualize the program more
like how I think graphically. I've never been a text programmer. I see the
code in a visual way in my head, far from typing on a keyboard. About the
opposite of Emacs/Vim. I seldom remembers the names of classes and methods,
but where they are in a code landscape where the code almost have different
kind of colours and textures. Negative space and beautifulness of code is
important to me, and it has nothing to do with the text itself. The less I
need to use a keyboard the better.

------
jacquesm
This reminds me of the software that comes with the lego robotics sets.

~~~
axod
Yeah. good for learning how to program, but silly afterwards.

------
scotty79
Maybe dumb Microsoft MDI concept will stop to haunt us now. Each IDE for last
15 years has same set of functions, and they are vastly insufficient. Shit
that happens in your typical program is really much harder to observe then it
should be.

Program is interconnected mutating tree. Why the hell we are looking at its
latest snapshot through set of flat files showing encoded parts of these trees
grouped chaotically?

On the other hand, why anyone who tries to actually show trees forces me to
enter 2+(2*5) as five nodes without using my keyboard?

------
brianobush
Neat concept, the problem I see immediately as it assumes I am coding in Java.
This would be fine if you worked in only one language. I work in several
languages within an average day.

~~~
jrockway
Hopefully the interface points are well-defined enough that you wouldn't need
a view like this over the entire set of projects.

------
perplexes
Reminds me of Squeak, first, because of the white->blue gradients. Second,
this is like the Canon Cat/Archy (Raskin interfaces), where you have tons of
room, and you just demarcate segments you want to look at.

What was striking for me was the "capture my workspace and send in email"
feature. Couple this with the Omniscient Debugger
(<http://www.lambdacs.com/debugger/>), and you've got me sold. Oh, but I'm a
Ruby programmer.

~~~
Groxx
I've wondered for a long time why debuggers don't _all_ have a "back" feature.
Small controls on what's saved / how much memory can be used seem to me to be
_easy_ to add to any debugger. Just save memory states and rewind, the whole
thing can be implemented with a stack. If someone knows a good reason, I'd be
interested.

You've ended up adding more things for me to read / look into. I love
programming... there's _no_ way I can keep up with it all, so there's _always_
something interesting.

~~~
chronomex
GDB 7 has supported going in reverse for few months now:
<http://www.gnu.org/software/gdb/news/reversible.html>

------
BigZaphod
Whoa. This looks kind of amazing! It's almost like an evolution of the
Smalltalk browser approach, but in a direction I would not have expected. I
think I like it!

------
gridspy
Hopefully this will make working on the Gridspy project easier. Typically I
have 3 IDEs open - my Firmware IDE, Eclipse + Visual Studio.

In Eclipse I am editing a twisted project (usually 3 different files at once
but only 2 methods from each) and a Django project (probably about 10 files to
juggle there).

In Visual studio, I tend to have another 10 files open (the firmware builds to
Win32 too).

God it would be awesome to have all that on one monitor in little bubbles.

------
colings86
I really like this, although is views seem to lend themselves very much to
functional programming as the bubbles in the demo only show the methods of a
class and obtaining a view of a class as a whole does not seem to be inherent
to the IDE. With functional programming you only care about the functions so
maybe that would be an ideal target for this IDE

------
Groxx
There are a LOT of good ideas in there. Will definitely have to watch /
possibly extend this...

* saves for later ___

------
tlrobinson
Did this vaguely remind anyone else of Hugh Jackman's virus writing "IDE" in
Swordfish: <http://www.youtube.com/watch?v=AUJFOuHIS4Q>

And on that note, how come all academic screencasts are so monotonous?

------
gchpaco
This is one of the first things I've seen—for any language—that could be more
useful and powerful than Smalltalk environments. The most useful feature IMHO
is the chaining but having find references and the like in there is extremely
attractive.

------
ivankirigin
I'd like to see a mini map view, like in StarCraft, where you could select an
area to instantly pan to that set of bubbles.

edit: ohh the top bar acts like that. Kinda cool. Very biased against vertical
scrolling, which might be bad for certain kinds of files.

~~~
mulander
It has a mini map on the top of the screen.

------
motters
Looks good. It's so rare to see any real innovation in development IDEs. I
also like the idea of colour coding bubbles or attaching icons to them, and
being able to arrange them in chronological order.

------
davidw
Looks pretty cool actually. There are often times when I need to see a little
bit of code from a number of files, to trace what's happening. Anyone care to
make an emacs mode for this?:-)

------
jwr
Now if somebody just plugged this into Emacs, or just got me an extensible
(Lisp-based) bubble system with SLIME so that I can connect to a Clojure
environment and inspect my code…

------
buster
For everyone who has worked on a project with multiple directories, files,
people and technology this looks really promising (if not awesome).

------
hvs
Looks like something that should be implemented as a plugin for Eclipse or
Visual Studio. Kind of interesting, though.

~~~
gridspy
I guess that is why it is an eclipse plugin.

Pity it doesn't interoperate with all eclipse-compatible languages (just yet).
I'd love to use it to work with Python.

------
jaytee_clone
I'm sure there's an emacs mode for that ;)

------
pgbovine
this sort of thing would be awesome for boosting developer productivity if
they have 3 24" monitors ... nowadays it's quite affordable to buy 3 24"
monitors (at ~$300 a piece), and when they're all linked-up horizontally, an
IDE like this one could truly kick butt

------
leif
Seems the next logical progression of the LXR. I'd love to see the linux
kernel in this.

------
JabavuAdams
Very cool. This is closer to how I envision my ideal IDE.

------
cookiecaper
I don't think there's any reason to put the default video embed at 1080p. Just
wasted a lot of my bandwidth, honestly; I didn't make it full-screen or
anything and would have been fine with 360/480p

~~~
voidpointer
It's great they put it up that way as that seems to be the native resolution
the demo was recorded at. That way, you get the optimum display quality of the
text. Since most of the screen stays the same much of the time, it isn't that
much of a bandwidth waster after all even at the higher resolution.

------
owinebarger
I think they're trying to reduce the impact of the superhuman levels of
concentration displayed by the uberhackers. I don't like it.

~~~
0x44
I disagree, they're augmenting the current impact of a super-human level of
concentration displayed by an "uberhacker" by giving the fruits of that
capacity to everyone. Automating a super-human level of concentration in one
part of the development process will free up brain cycles for use elsewhere.
The best developers won't instantly cease to be the best developers because of
a mind-mapping IDE.

~~~
owinebarger
The second sentence of my earlier post was my idea of comedy.

------
j23tom
now apple should sue them - they inveted it first - no doubt ;)

------
aheilbut
C-x 2 C-x 3

~~~
viraptor
Without screenshots / explanation / some more content, you're not very
informative... (edit: I know it's emacs, but without explanations it's like
saying C-x M-c M-butterflies)

~~~
aheilbut
Alright, I confess to being a little glib; however, I'm merely suggesting
another way that people already commonly "see many fragments of code (or other
information) at once without having to navigate back and forth."'

It's not nearly as slick as code bubbles, but it does work for many of the use
cases suggested above.

~~~
Qz
Slickness is an underrated quality of good user interfaces.

~~~
yters
Indeed, programming is more about conceptual understanding than typing speed.
I see bubbles as being more useful for understanding how an entire code base
fits together than emacs buffers and windows.

Though, if we had a desktop that is infinitely expandable, then emacs, and any
other windowed application for that matter, could be put to the same use.
Really, bubbles is best as a general workflow paradigm, of which programming
is a sub problem.

