Welcome to the Slashdot Beta site -- learn more here. Use the link in the footer or click here to return to the Classic version of Slashdot.

Thank you!

Before you choose to head back to the Classic look of the site, we'd appreciate it if you share your thoughts on the Beta; your feedback is what drives our ongoing development.

Beta is different and we value you taking the time to try it out. Please take a look at the changes we've made in Beta and  learn more about it. Thanks for reading, and for making the site better!

Code Bubbles — Rethinking the IDE's User Interface

timothy posted more than 4 years ago | from the don't-get-distracted-now dept.

GUI 198

kang327 writes "As Java developers we are used to the familiar file-based user interface that is used by all of the major IDEs. A team at Brown University has developed an IDE for Java called Code Bubbles that makes a fairly radical departure from current IDEs — it is based on fragments instead of files. The idea is that you can see many different pieces of code at once. Fragments can form groups, have automatic layout assistance, wrap long lines based on syntax, and exist in a virtual workspace that you can pan. A video shows reading and editing code, opening different kinds of info such as Javadocs, bug reports and notes, annotating and sharing workspaces, and debugging with bubbles. They report on several user studies that show the system increases performance for the tasks studied, and also that professional developers were enthusiastic about using it. There is also a Beta that you can sign up for."

Sorry! There are no comments related to the filter you selected.

Sounds like Smalltalk's code browser. (5, Insightful)

Anonymous Coward | more than 4 years ago | (#31429294)

Welcome to the 1970s. Squeak [] is one of the better implementations these days.

Re:Sounds like Smalltalk's code browser. (1)

TheRaven64 (641858) | more than 4 years ago | (#31429430)

Indeed, welcome to the '70s, but the Newspeak code browser these days is a lot nicer than Squeak / Pharo's approach.

Re:Sounds like Smalltalk's code browser. (0)

Anonymous Coward | more than 4 years ago | (#31429578)

I don't know about smalltalk, but there's a family resemblance -- it reminds me a bit of Self with the Kansas desktop. It's not bad, but I really do prefer browsing with trees and keyboard controlled "quick open" popups. I'm just not productive with mouse-centric interfaces.

What HR Wants... (5, Funny)

sycodon (149926) | more than 4 years ago | (#31429904)

Java developer with 40 years experience in Code Bubbling concepts.
5 years experience with the Code Bubble IDE.

Deja vu (2, Insightful)

ascari (1400977) | more than 4 years ago | (#31429300)

It looks like those (incredibly crappy) multi window IDEs of ten years ago. The name is cute though.

Re:Deja vu (0)

Anonymous Coward | more than 4 years ago | (#31429760)

Sounds like APL (1960s) and the earliest version of MS-DOS (1980s): "workspace" == "ALL your files in a single directory".

Can I version-control bubbles (or the code fragments associated with them)? No, I didn't think so.

Plus, you're still working in Java.

But if I did write in Java, I'd totally sign up for the beta! I'd impress the hell out of my boss with all the cool-looking, click-fucking-around.

Re:Deja vu (1)

K. S. Kyosuke (729550) | more than 4 years ago | (#31430678)

Can I version-control bubbles (or the code fragments associated with them)? No, I didn't think so.

What prevents you from doing so? Since when do diffs and versions work only with small files and not with large ones?

bubbles = isolation (1)

caffeinemessiah (918089) | more than 4 years ago | (#31429306)

Initially, the idea of "code bubbles" sounds intuitive -- isolated, self-contained, easily testable pieces of code, with well-defined inputs and outputs. Then you could build a complex program by stringing these bubbles together (in theory, anyway).

Then TFS mentions something as banal as "wrapping long lines of code"....and my bubble bursts.

Re:bubbles = isolation (5, Insightful)

Anonymous Coward | more than 4 years ago | (#31429450)

Initially, the idea of "code bubbles" sounds intuitive -- isolated, self-contained, easily testable pieces of code, with well-defined inputs and outputs. Then you could build a complex program by stringing these bubbles together (in theory, anyway).

Perhaps we could call such a pieces of code "functions" instead.

Re:bubbles = isolation (0)

Anonymous Coward | more than 4 years ago | (#31430122)

Except a bubble (as I understand it) spans multiple classes. For example, if you'd have a design pattern, those usually span multiple classes (either because of inheritance or because of classes that cooperate). The concept sounds like a good thing to try out to me (though I have to admit I lack sufficient experience to say anything about how useful it will actually be). It sounds like a middle-way between packages (break up the code in large fragments) and classes (break up the code in small bits).

Re:bubbles = isolation (3, Funny)

Dishwasha (125561) | more than 4 years ago | (#31430292)

I just checked on Wikipedia [] and I couldn't find a picture of a function, could you draw me one please so I can see how to fill my bath tub with them?

Re:bubbles = isolation (4, Insightful)

ottothecow (600101) | more than 4 years ago | (#31429476)

I like the idea at least as I understand it from the summary.

Might just be more handy as a display mode than an entire paradigm but I can see how it would be nice if you could display functions together from different files.

If you are working on one function that is in file3.c that has to interact with functions in file7.c and file3.c, why not be able to display them all as if they are in the same file (when they will eventually get compiled together anyways). The code already exists in most IDEs to collapse functions, so why not extend that to being able to mash up all the collapsed functions from every file. Then you can display the ones you want to see as if they were all in the same file.

Keeping stuff in separate files and including them is a good organization technique and helps with multiple people working on a project (and you can substitute different files for different platforms, etc.) but I can see where this would be useful if instead of flipping between 5 open files, the IDE could display just the portions you need. Bonus points if the IDE can do this automatically in a semi intelligent manner--like show the collapsed version of functions that might be relevant based on some criteria and then allow you to expand them if you like.

Ctrl-X 2 (1)

PaulBu (473180) | more than 4 years ago | (#31429828)

What, do you mean that your new-fanged IDE does not allow you to split a single window, forcing you to have multiple windows and having to switch between them using your mouse?

And, as someone pointed out above, it sounds suspiciously like what Smalltalk and Lisp developers had back in 80s... :)

Paul B.

Re:bubbles = isolation (4, Insightful)

sirius_bbr (562544) | more than 4 years ago | (#31429924)

I think this kind of IDE would be very usefull during code-maintenance, especially when the code you maintain is written by you (which is often the case).

When developing new code, the bubble-concept could be too confusing, because it seems to hide the overall structure of the code.
But during maintenance, when hunting bugs, I often don't want to see the whole picture (and hence the whole complexity), but am much more interested in smaller sections of a program, and the relations between them. The bubble concept would really help.

Re:bubbles = isolation (0)

Anonymous Coward | more than 4 years ago | (#31430352)

It's called crappy code (or lack of documentation) if external function calls need it's code referenced when used.

I find it helpful to think function names twice, and after few times more, before releasing api to other co-workers. For clear code keep functions simple, let them do what name says and only that, and finally keep parameters predictable around code.

Re:bubbles = isolation (5, Insightful)

l3v1 (787564) | more than 4 years ago | (#31429530)

isolated, self-contained, easily testable pieces of code

And I'd add small and short to that list. There's no way this bubble concept would be useable with code fragments longer than a few lines, and even those need to be short since wrapping would destroy the usability of the whole thing. Also, in the sample video, when they had to scroll the screen because of the many bubbles, well, there it became a lost cause for me. Realistically, from code dealing with more than helloworlds that I've seen and written, this thing would be a real dealbreaker. I can't think how so much fragmentation can help you in the long run. Having self-contained small pieces of code that do one thing - that is useful -, I'd say those are hard to find. Managing tens of thousands of lines of code this way, I'd go crazy very quickly.

Re:bubbles = isolation (1)

zero0ne (1309517) | more than 4 years ago | (#31429684)

But in 6 years we will have the AMD holodeck.

(my vision is like the computer room the kid in "Gamer" had)

Imagine coding on a screen like that with this IDE...

Re:bubbles = isolation (1)

suomynonAyletamitlU (1618513) | more than 4 years ago | (#31430036)

I agree that their effort shouldn't be based on the "make it look good with rounded bubbles that you can move anywhere on the screen, because THAT is what programmers lack" that the video shows. That's retarded.

However, my first thought when I read the title of this was that, for example when debugging, the IDE would put together a fake "file" for your editing purposes that contains all the relevant functions / code segments, with simple breaks that showed where one file ended and the next started. This might even be multi-column, with each "bubble" being movable between columns, so that you could compare side-by-side.

You could of course switch tabs to the actual files if you needed to, for editing C macros or things that seem unrelated to the IDE, and it wouldn't be hard to have it jump to the line you already have selected in the "bubble" view.

Re:bubbles = isolation (0)

Anonymous Coward | more than 4 years ago | (#31430126)

And I'd add small and short to that list.

No you won't - this is a Java IDE. Java + "small and short" = FILE_NOT_FOUND.

Does it work for a new project (1)

vivin (671928) | more than 4 years ago | (#31430414)

From what I see, it looks pretty good for working with an already existing project. It would help if they talked about starting a project from scratch using this IDE. Either way looks like something worth trying out. To all the people who say this looks like a terrible idea, I think that's rather subjective; It looks like a matter of taste (emacs vs. vi, eclipse vs. netbeans). I think it would help from a maintenance perspective (fixing bugs) or even if you're adding stuff to an existing codebase. I'd like to try this out anyway.

Re:Does it work for a new project (1)

asylumx (881307) | more than 4 years ago | (#31430642)

Yes actually I thought the same thing -- that this looks far more useful in maintaining existing code than in creating new code. I can think of many instances where I could have used something like this. Eclipse's "Open Call Hierarchy" is close, and alt+leftarrow in eclipse is also useful in seeing where you've been. However, you generally can't see all the actual code on the screen at the same time, you have to jump back and forth.

I also really like how they used this concept in their debugger. Bravo for being able to keep old data on-screen for reference/comparison later on.

Re:bubbles = isolation (1)

Dracolytch (714699) | more than 4 years ago | (#31430720)

From what I see this appears to be more useful for code editing versus code authoring...

When you're maintaining 10,000 lines of code, you're usually focused on a few dozen lines of code, usually broken into a couple of places... Finding that 50 lines of code, and navigating between the places you care about, can be a significant portion of the task. This appears to have a much superior means of finding those lines of code I care about, and maintaining the context between them to edit faster.

As for code authoring? That could be a real headache (literally)


Re:bubbles = isolation (2, Insightful)

Galestar (1473827) | more than 4 years ago | (#31429590)

Then TFS mentions something as banal as "wrapping long lines of code"....and my bubble bursts.

What's wrong with that? Manually wrapping long lines of code is only done to prevent having to scroll horizontally while reading the code. These days, the number of characters that can fit in the code window can differ significantly between devs. I use a 28" widescreen at 1900x1200 - I can fit a hell of a lot more characters in my code window than can a dev with 19" non-wide with w/e low resolution he decides to use. With manual wrapping, if I write the code, he has to scroll. If he writes the code, I do not get to take advantage of my added screen real-estate. As long as the automatic wrapping has a half-decent indentation style, I would love to see this in any IDE.

Re:bubbles = isolation (1)

bishiraver (707931) | more than 4 years ago | (#31429978)

Typically, the only time you have (or should have) lines that cannot be intuitively line-broken and indented is if you're writing mindfuckingly verbose code like

SuperSpaceMapStrategyFactory<SubLightIonEngineTypeManager<MediumPoweredIonEngine>> marsRocketEnterplanetaryEngine = new SuperSpaceMapStrategyFactory<SubLightIonEngineTypeManager<MediumPoweredIonEngine>>(new RocketEnginePattern(engineDiameter,engineForce));

Which, I suppose, you only really get if you use Java anyway. Otherwise 80 columns is more than enough space for anyone.

Re:bubbles = isolation (1)

SQLGuru (980662) | more than 4 years ago | (#31430374)

You can keep your resolution but go vertical. You get to see more without scrolling and without making him scroll as much. Win/win.

Besides, most web designers like to force width their web pages so that it looks "exactly like the photoshop comp, down to the pixel" (stupid pretentious pricks, that one pixel difference you see in IE vs FF can't be helped).

Re:bubbles = isolation (2, Insightful)

phantomfive (622387) | more than 4 years ago | (#31429746)

It is a good start of an idea. The problem with coding is that the logical structure isn't really related to the visual structure of code on a page. Logically, with code, you have a bunch of bubbles with lines connecting them together in various ways. You can't really see this structure visually, if you want to see how things are linked together you have to read the code and figure out what calls what (or use one of the various search mechanisms, but that still boils down to reading). So the idea of being able to see the links between different parts of your code is a good one. A good portion of my comments are dedicated to helping future programmers understand the overall structure of my code, so being able to visualize it will make that much easier.

You can always automatically generate a UML map, but the problem is a UML map doesn't show which links are more important, and which groupings of code are most important. This is something you have to use comments for. If this tool could somehow do that, and could be saved in a format that could be shared with other programmers, it would be very useful. Otherwise it is not too much more efficient than the techniques I've developed for dealing with regular text files.

A similar situation is this: when I first learned to use emacs, I thought auto-indent was the most amazing thing ever. It solved one of the major problems of my coding life, indentation (obviously I was not a very experienced programmer at the time). Emacs made it easy to re-indent a section if I forgot the brace on my 'for' loop. When I read a review by a guy who didn't like emacs for totally different reasons, I couldn't understand why he was ignoring the obvious greatnesses of auto-indent. Now I realize that actually he had developed technique for dealing with indentation, so it really wasn't a problem to him like it was to me. That is how new tools often are.

Re:bubbles = isolation (1)

guruevi (827432) | more than 4 years ago | (#31429984)

Congratulations, you've just defined Objective-C/Smalltalk/PHP Classes & Functions and probably a host of other so-called 'object-oriented' languages.

This IDE just seems to make OO simpler by diagramming your program ala Visio instead of coding the interactions.

Re:bubbles = isolation (1)

ianare (1132971) | more than 4 years ago | (#31430110)

Yes, what if there was a "isolated, self-contained, easily testable pieces of code, with well-defined inputs and outputs", many of which could be assembled together to form a complete application, but modular enough to stand on their own and be used in other applications. For ease of use we could put these things, 'objects' if you will, into a single container, like a single 'file' in a 'folder' of many such 'objects' for example. This would simplify access and editing.

Nah, the idea could never work. How would one know how and where these things interact with each other? We would need to create a new language from the ground up that makes use of them, in order to properly track their behavior. Then find a way of showing that interaction graphically to the programmer. The shear scale of such an endeavor makes it one of those pie-in-the-sky concepts.

OK, now back to work : I'm building a multithreaded back-end business software program using Vi.

Re:bubbles = isolation (0)

Anonymous Coward | more than 4 years ago | (#31430132)

Rob Malda's tranny died under mysterious circumsta (-1, Offtopic)

Anonymous Coward | more than 4 years ago | (#31429308)

Rob Malda's tranny died under mysterious circumstances

New details about Rob Malda's past may come out in the divorce proceedings with his wife of 8 years, Kathleen. Page 6 speculates that she may fight the prenup, citing Malda’s infidelity with various street trannies.

In 2007, Malda was caught by Dexter police with a transvestite hooker in his car. He told his wife that he “stopped to help a person crying.” Several other hookers sold tales of Malda’s solicitation to the tabloids, and all of them were convinced to recant, with one exception:
Paul Barresi, a private detective who claims he was hired for damage control by Malda when the scandal broke, tells Page Six: “I called [Malda attorney] Marty ‘Bull Dog’ Singer and told him I could round up all the transsexuals alleging sexual dalliances with Malda.” And they would all recant their stories.

“In less than 10 days,” Barresi says, “I got them all to sign sworn, videotaped depositions, stating it wasn’t Malda himself, but rather a look-alike, who they’d encountered - with the exception of Suiuli.” In 2008, she fell to her death from her Dexter roof.

Atisone Suiuli was the tranny found in Malda’s car in 2007. After being caught by police, she had proof that she was with Malda and wouldn’t change her story. How convenient for him that she died soon afterwards.

Re:Rob Malda's tranny died under mysterious circum (0)

Anonymous Coward | more than 4 years ago | (#31429512)

Thank you for the ho hum rip off of a poorly written story about Eddie Murphy killing a hooker...

Soo much space required. (3, Insightful)

coolsnowmen (695297) | more than 4 years ago | (#31429350)

I'm going to need a bigger screen.

Re:Soo much space required. (2, Informative)

patro (104336) | more than 4 years ago | (#31429798)

I watched the video in 1080p and the text was pretty much unreadable. One would need either a huge screen or have to live with constant panning.

Re:Soo much space required. (0)

Anonymous Coward | more than 4 years ago | (#31430100)

I'm going to need a bigger screen.

Problem Solved, Viewsonic VP2290b monitor, 3840x2400.

Re:Soo much space required. (1)

IamTheRealMike (537420) | more than 4 years ago | (#31430218)

And how much space is wasted on your screen currently due to most lines being shorter than N characters? I use a single emacs window stretched across dual screens, and Google imposes an 80 column limit on its C++ code so with a slightly larger font this means I can fill the screen with code. But still, often some of that code is just guff that happens to surround the function I'm interested in. The CodeBubbles idea looks really nice and I can't wait to try it out for myself.

Re:Soo much space required. (1)

BikeHelmet (1437881) | more than 4 years ago | (#31430406)

This should actually work remarkably well. Several years ago I wrote something similar, although much more primitive. I called them boxes, and it was for working with multiple HTML/css/js files at once. No syntax highlighting, and none of this advanced stuff - it was just a notepad replacement, since Windows lacked grid alignment for windows. I did add the option to open files by clicking on (for example) a script or link tag, and the ability to move/resize boxes freely, but that was it.

This thing is impressive. I've got a huge monitor, too - I'd love to try it once it matures and is available. Plus, now I'm more into Java than Javascript. This kind of layout suits me far more than Eclipse.

What rethinking? (1, Redundant)

Accidental Angel (2899) | more than 4 years ago | (#31429356)

It looks like the Smalltalk GUI to me.

On the fence (1)

binarylarry (1338699) | more than 4 years ago | (#31429410)

I think this would be a cool tool for evaluating how an application is executed, as well as visualizing call sites and application traversal.

But I think it would be a major pain in the ass for most development purposes.

Re:On the fence (1)

philipborlin (629841) | more than 4 years ago | (#31429708)

This seems like a superior way to debug code. I especially like the way the inspections stay persistent and the way you are looking at a path of code instead of some call stack list. I don't know how well this would work for new development though.

Where have I seen something like this? (1)

140Mandak262Jamuna (970587) | more than 4 years ago | (#31429414)

Small pieces that do one thing, but that thing well, they interact with other pieces in a standardized way... I know I have seen this before. Let me awk my brain. I am greppping through my memory.

Oh goodie (3, Insightful)

aztektum (170569) | more than 4 years ago | (#31429422)

More UI elements to click-n-drag

As if having a couple dozen windows open and trying to organize them wasn't fun enough.

Re:Oh goodie (1)

copponex (13876) | more than 4 years ago | (#31429744)

The point is that you replace the windows with another GUI concept, called bubbles. Did you watch the video?

Maybe you have time to read the first two paragraphs:

Developers spend significant time reading and navigating code fragments spread across multiple locations. The file-based nature of contemporary IDEs makes it prohibitively difficult to create and maintain a simultaneous view of such fragments. We propose a novel user interface metaphor for code understanding and maintanence based on collections of lightweight, editable fragments called bubbles, which form concurrently visible working sets.

The essential goal of this project is to make it easier for developers to see many fragments of code (or other information) at once without having to navigate back and forth. Each of these fragments is shown in a bubble.

Re:Oh goodie (0)

Anonymous Coward | more than 4 years ago | (#31430058)

Developers spend significant time reading and navigating code fragments spread across multiple locations.

So we decided to put every function into its own fragment to make the problem even worse!

Re:Oh goodie (0)

Anonymous Coward | more than 4 years ago | (#31430038)

But this way, atleast you have your dozen windows located inside one bigger window.

Screen Size (4, Interesting)

pavon (30274) | more than 4 years ago | (#31429458)

The demo made this look pretty nice for tracing functionality through multiple classes/method calls. It annoys me that most IDEs make it harder to view code side by side than Emacs did 15 years ago. That said, it appears that you either need a really huge monitor, or be comfortable reading really small text, for this system to work they way they demonstrate.

Re:Screen Size (1)

heson (915298) | more than 4 years ago | (#31429534)

I think the ide works well for students debugging their tiny hello world -projects (or maybe junior programmers in someone elses spaghetti code), but serious professionals can visualize more than the code visible on the tiny bubble desktop in their head. There were some nifty features, but I consider it a toy for the most part.

Re:Screen Size (1)

ClosedSource (238333) | more than 4 years ago | (#31429614)

"serious professionals can visualize more than the code visible on the tiny bubble desktop in their head"

I always wondered how short order cooks could keep track of all the various foods they were cooking with different start times and different cooking times. Now I know they were "serious professionals".

Re:Screen Size (1)

ottothecow (600101) | more than 4 years ago | (#31429792)

I wonder about that too but I would imagine that it has more to do with the fact that well trained cooks are not taught to cook things for XX minutes but rather learn to cook by feel. Especially if you cook the same things many times a day, you can probably tell by looking/smelling/listening/prodding when it is done.

Re:Screen Size (1)

BikeHelmet (1437881) | more than 4 years ago | (#31430498)

Serious professional or not - anyone should be able to keep a thousand lines in their head, and write relatively bug free code around that. Maybe even 15000 lines without making mistakes.

But projects that a "serious professional" will be working on could be far far larger than that. Many people on slashdot have worked on projects having hundreds of thousands to millions of lines of code. Visualization skills be damned, if looking up code (which will have to be done constantly) is a PITA.

Re:Screen Size (1)

pavon (30274) | more than 4 years ago | (#31429842)

I envy you if your jobs have led you to think that only junior programmers have to deal with other people's spaghetti code. In my opinion any project big enough to be considered a "serious professional" project is big enough to have had at least one lousy developer that left their turds in it.

Re:Screen Size (0)

Anonymous Coward | more than 4 years ago | (#31429912)

most IDEs make it harder to view code side by side than Emacs did 15 years ago.

Exactly. End of story.

Is it really the case? (1)

PaulBu (473180) | more than 4 years ago | (#31429930)

I was *jokingly* asking if this is the case in my previous post (, but you seem to confirm this. Wow, stunned...

Paul B.

Re:Screen Size (1)

BikeHelmet (1437881) | more than 4 years ago | (#31430428)

Good thing you can pick up monitors for $99 these days!

Or huge ones for a bit more. I got a 2048x1152 Samsung 2343BWX for $170 CAD.

Mylyn in Eclipse (3, Informative)

MyForest (597329) | more than 4 years ago | (#31429472)

I've recently been using Mylyn [] to give me a focussed view on the code I'm working on. I love the way it automatically adds things to the context as I click around.

Then of course there's the rather gorgeous "Run unit tests in context [] " to give me feedback on the things I've been tinkering with.

Solution in the search of problem. (0, Redundant)

anonymousNR (1254032) | more than 4 years ago | (#31429478)

Developers spend significant time reading and navigating code fragments spread across multiple locations. The file-based nature of contemporary IDEs makes it prohibitively difficult to create and maintain a simultaneous view of such fragments. We propose a novel user interface metaphor for code understanding and maintanence based on collections of lightweight, editable fragments called bubbles, which form concurrently visible working sets.

I agree with Developers spending time reading and navigating code fragments but isn't that part of the job ? I think its called debugging ,locating problem, identifying it in the code and fixing it, if it takes navigating or standing on his head he will do it.

rofl java (-1, Flamebait)

Anonymous Coward | more than 4 years ago | (#31429482)

java != coding

Re:rofl java (0)

Anonymous Coward | more than 4 years ago | (#31429596)

says a guy who can't even write a double-linked list in Z80 assembly.

Gonna need a bigger monitor... (0)

Anonymous Coward | more than 4 years ago | (#31429492)

Well, it'd give me a business case for a few of those huge 2560x1600 monitors I've been hankering for. More seriously, F3 and ctrl-shift-G are very commonly hammered buttons in my usage of Eclipse, so maintaining context as you flow through might well aid productivity.

Debugging and documentation (3, Interesting)

beakerMeep (716990) | more than 4 years ago | (#31429494)

This looks nice as a way of exploring, debugging, and documenting code especially. I like how you can save layouts by date. But I feel like I would want to step back into eclipse to do the writing. I would be nice if they made a way to integrate with other IDEs.

Re:Debugging and documentation (1) (1284676) | more than 4 years ago | (#31429696)

I think so too. The demo looks very smooth and it could be nice to explore large project done by somebody else, but to use it for development? No thanks. I rarely find myself needing to look at more than two files at once. And, I like larger fonts.

Re:Debugging and documentation (0)

Anonymous Coward | more than 4 years ago | (#31429700)

Yes, the usage scenario you've painted here is a lot like what I'm thinking as well.

Besides, it looks quite similar to the work Ilfak's done with IDA Pro 5.

Re:Debugging and documentation (1)

MemoryDragon (544441) | more than 4 years ago | (#31430114)

A good uml plugin can almost do the same...
Problem is there are no good uml plugins :-)

It's a good idea. (1)

Anonymous Coward | more than 4 years ago | (#31429498)

I think it's brilliant. I don't care if somebody did it somewhere else before and deserves all the credit--that's beside the point. I would definitely like to use an IDE like this.

It would probably encourage more refactoring and smaller function sizes. The windowed IDE puts a bias on keeping code all together in one place, because of the small-but-present difficulty in switching to other files.

love it - i had already "dreamt this up" w/hope (1)

happyjack27 (1219574) | more than 4 years ago | (#31429524)

and my hopes have been fulfilled.

XEmacs binding... (4, Funny)

fahrbot-bot (874524) | more than 4 years ago | (#31429544)

M-C-x fuck-up-my-screen

cant help it.. (1)

zcold (916632) | more than 4 years ago | (#31429564)

I know I know, but I cant help but laugh at the person video explaining code bubbles....Its just ssssooo sssuper fantastic! I like the idea tho. Its very interesting.. Though I have no plans on learning a new IDE.

Looks promising... (2, Interesting)

johnlcallaway (165670) | more than 4 years ago | (#31429580)

I do mostly maintenance programming (by choice .. I'm good at fixing code I know nothing about, I like it, it keeps from from being pigeonholed, and there is a lot less competition). So I spend a lot of time hopping around code I know nothing about. I also spend a lot of time 'going backwards' through programs, since sometimes all I have is an error message and it's easier than trying to start at Main. This type of interface would be very beneficial in my type of work.

Even writing code from scratch, I rarely program 'top down', but group methods in the file based on some vague grouping concept, like all setters/getters together, methods that are called somewhere around methods that are calling them. It's really not necessary for me to 'know' where in the file they are, as long as I can get to them, open, do whatever, then close them.

I think that as long as I can open a 'bubble' and have complete access to all my code via scrolling, this would work fine. I would only need to open bubbles as I need to then.

Besides .. what would happen to those bubbles if some braces got out of alignment. You would have to have pure code scrolling to be able to fix something like that.

Excellent for Students (1)

JW CS (1593833) | more than 4 years ago | (#31429608)

Based only on the video, this looks like it could be very useful for students working with smaller Java assignments. The interface looks intuitive, and seems to be designed for people who like to visualize the flow of their code. The debugger also looks more intuitive than many of the ones I've seen. However, I shudder to think how messy the interface could get if you were working with a large project.

codebase awareness (1)

Alban (86010) | more than 4 years ago | (#31429612)

There is something to be said about knowing the structure of your codebase. I already see intellisense users jumping around and editing code from locations they have no idea about, this will be even worse. It really pays off to understand the file/directory/package structure of your codebase, as opposed to jumping to unknown locations, making an edit and bailing out. Intellisense/ctags are great when they extend your knowledge of the codebase, but they shouldn't be a substitute for having some amount of awareness.

snippets might be useful for better diffs (1)

Vadim Grinshpun (31) | more than 4 years ago | (#31429664)

This reminds me of an idea I had some time ago, which might be an application for something like that (I've not read the article yet, so maybe they;re doing something different; but this might be interesting anyway :)

When refactoring code, it's not atypical to move whole snippets of code around. Reviewing the results of such a change (i.e., doing a diff between the versions) is usually nightmarish, since every diff tool I've ever seen is inherently line- or block-of-lines-oriented, and cannot recognize the simple (for a human) case of "I moved this function above that other function".

If the diff tool (and/or the related version control tool?) could be sufficiently language-aware, it might be able to recognize certain semantic units (functions, scope blocks, etc), and try to keep track of them. If this could be done, a diff output could actually be much more meaningful than what we get these days.

Step by step, Java reinvents Smalltalk... (5, Interesting)

Paul Fernhout (109597) | more than 4 years ago | (#31429692)

See the Smalltalk browser: []

Now if only Java had Smalltalk's blocks.

And Smalltalk's more descriptive message passing syntax of "Foo x: 10 y: 20". instead of "new Foo(10, 20);"

And Smalltalk's extendable control syntax...

And Smalltalk's "doesNotUnderstand" concept for proxying.

And Smalltalk's become: method.

And Smalltalk's ability to rethrow exceptions...

And Smalltalk's multi-generational garbage collector...

And so on...

One step at a time...

If only the ParcPlace suits had not been so greedy when Sun wanted to use Smalltalk in set top devices, and instead Sun turned to a Frankenstein "Plan B". []
        "When I became V.P. of Development at ParcPlace-Digitalk in 1996, Bill Lyons (then CEO) told me the same story about Sun and VW. According to Bill, at some point in the early '90's when Adele was still CEO, Sun approached ParcPlace for a license to use VW (probably ObjectWorks at the time) in some set top box project they were working on. Sun wanted to use a commercially viable OO language with a proven track record. At the time ParcPlace was licensing Smalltalk for >$100 a copy. Given the volume that Sun was quoting, PP gave Sun a firm quote on the order of $100/copy. Sun was willing to pay at most $9-10/copy for the Smalltalk licenses. Sun was not willing to go higher and PP was unwilling to go lower, so nothing ever happened and Sun went its own way with its own internally developed language (Oak...Java). The initial development of Oak might well have predated the discussions between Sun and PP, but it was PP's unwillingness to go lower on the price of Smalltalk that gave Oak its green light within Sun (according to Bill anyway). Bill went on to lament that had PP played its cards right, Smalltalk would have been the language used by Sun and the language that would have ruled the Internet. Obviously, you can take that with a grain of salt. I don't know if Bill's story to me was true (he certainly seemed to think it was), but it might be confirmable by Adele. If it is true, it is merely another sad story of what might have been and how close Smalltalk might have come to universal acceptance."

How much people forget...

Of course, fifteen years later, Java is not that bad... Most of the bugs are out. There are some good libraries. There is a better garbage collector... And so on...

Re:Step by step, Java reinvents Smalltalk... (1)

MemoryDragon (544441) | more than 4 years ago | (#31430166)

Parcplace killed the entire Smalltalk market with the Digitalk Fiasco...
And yes greed and internal corporate quarelling basically did it!

Re:Step by step, Java reinvents Smalltalk... (1)

hfranz (101040) | more than 4 years ago | (#31430580)

Thats why I am looking at Scala right now. More flexible syntax, multi-paradigm, compiles to java or .net byte code.

What a giant failure (2, Insightful)

Chemisor (97276) | more than 4 years ago | (#31429698)

Any UI design that forces me to use the mouse is automatically a failure. Any method of information display that uses only a small fraction of the available display space to display tiny windows and forces me to resize them or scroll them is also automatically a failure. A method that combines both, must then be a gigantic failure.

Re:What a giant failure (1)

presidenteloco (659168) | more than 4 years ago | (#31429844)

As for the mouse, get a mac laptop and use the trackpad. Not a big issue.

The thing is about letting you understand context quickly. The context comprehension is vital to dong an insightful code addition or fix.

It is also good at showing the narrative aspect of code stories, which interleave through the single file-based view of the code.
These code stories are essential to understanding the essential behaviors of the code you are adding to or modifying.

Works for me.

That said, the more automatic layout, the better.

Re:What a giant failure (3, Insightful)

MagikSlinger (259969) | more than 4 years ago | (#31429878)

Speak for yourself. Some of us like the mouse and window for code editing.

Re:What a giant failure (2, Funny)

Just Some Guy (3352) | more than 4 years ago | (#31430702)

Some of us like the mouse and window for code editing.

Some of us probably like getting punched in the nuts, but that doesn't make it reasonable or painless.

It's all about the context switches. When you're typing along productively, then have to stop to get the mouse, find the pointer on the screen, get it to where you want it, perform whatever action, then pop back to the keyboard to continue, you've had to bounce your attention across several distinct actions. That just isn't productive.

Re:What a giant failure (1)

martas (1439879) | more than 4 years ago | (#31429998)

are you using lynx right now, by any chance?

Re:What a giant failure (4, Insightful)

stoanhart (876182) | more than 4 years ago | (#31430034)

What a closed-minded and overly general statement!

I certainly agree that often a keyboard-only approach and minimal screen "wastage" is great - I am an emacs fan after all. However, there are always exceptions and if we don't explore new ideas we won't find better ways of doing things. How can you call it an automatic giant failure when you haven't even tried it yet.

Your complaint about not using all available screen space for what you want to see doesn't even make sense in this context! Why would you want a single bubble/code fragment to take up the entire screen? That's contrary to the point! The idea here is to be able to quickly trace a complex program by seeing only the code that represents the function being called at any point, rather than the whole irrelevant file. And while there should surely be a keyboard method to navigate the bubbles (arrow keys would work marvelously here), a mouse is an excellent way to navigate a large 2D surface.

Re:What a giant failure (1)

MindStalker (22827) | more than 4 years ago | (#31430404)

Agreed/Disagreed. I think this would be amazing for code reading/debugging/getting familiar with code. Actual coding? Yea, it doesn't seem very conducive to a lot of typing, but then again a lot of coding nowadays is about putting pieces together, so this makes sense. As long as there is a way to quickly switch to a more traditional view when you need it, it would be a huge win.

But, does it have... (3, Interesting)

narooze (845310) | more than 4 years ago | (#31429738)

But, does it have a good text editor [] ?

2nd goal of a Java developer achieved.... (4, Funny)

croftj (2359) | more than 4 years ago | (#31429750)

I figured out just recently that the first goal of any true Java developer is to write an abstraction layer/framework to abstract previous abstraction layers/frameworks written before them.

Now, this week, I learn the 2nd goal. Write a way cool looking but really very complex development environment to help you muddle one's way through the myriad of abstraction layers already written.

All of this just to help overcome the basics such as overloading operators.

In all seriousness, this seems to show too little information with too much space in between. My screen real estate is vary valuable. Not to be wasted with pretty colored borders and arrows and such.


Re:2nd goal of a Java developer achieved.... (1)

rombertw (1520489) | more than 4 years ago | (#31430312)

There is no operator overloading in Java.

In fact, there's much less magic in Java than in more hip languages, and that's a very good thing in my book.


Re:2nd goal of a Java developer achieved.... (1)

alexj33 (968322) | more than 4 years ago | (#31430522)

In any case, croftj is dead on correct about an overload (no pun intended) of abstraction in the java community.

Good gravy, can't anyone even write a decent Java app anymore without having to learn half a dozen frameworks?

U have screen wide enough to fix bugs in bubbles? (2, Insightful)

roman_mir (125474) | more than 4 years ago | (#31429770)

opening methods side by side? I just wish I had 200" wide screen, or maybe I don't. 'Bubbles do not overlap but push each other out of the way' - they expand. Have you seen what a map like that looks like? How about 5meters x 5 meters of space that you would need to debug a business or a system level problem? Oh yeah, you just 'pan over'. So how the hell is that different from opening separate files? I know how, opened files are obvious but something you need to move around virtual screen is not immediately obvious. Where was that file that was open? Oh yeah, 35" up and 23" left. But of-course, you can zoom the screen in and out, all you have to do is remember what all those minuscule pictures have in them there and then 'you can continue working'. You have 'miniature maps' of the entire workspace. God, how many times I had to work with tools that did this, it was never any help. The 'miniature map' is a terrible idea for text boxes, it's not apparent, like a file list, what's in any of those text boxes.

Bubbles expand as you type into them and push other bubbles out of the way. Sounds wonderful, the entire screen is jumping around as you type.

The developer's screen in the video looks like a mess and a mess at very high resolution. Minority report interface style mess.

Code 'group information is persisted automatically'. Some XML meta files are created. When working in a team, do you check these into source control? What happens when files that used to be in your 'bubble' are changed/renamed/removed by other coders in the project?

Tasks are grouped by date? Revisiting sets of bubbles by their dates, hmmm. Doesn't sound right. Will you remember to revisit some bubble set a week from now? How many bubble sets will you create in that time? Will you remember all these bubbles?

It's a nightmare, colorful, messy, visually heavy nightmare. This will probably sell well as a 'new coding paradigm' to CTOs and such.

I liked two features: 1. searching for path between functions. They promise to find the shortest path (hope they don't have to find the shortest path between functions for some projects I had to witness) and display alternative paths as well. 2. having output from 2 separate debug sessions opened at the same time. I would give that a try but most likely this will not cause any real improvement, I already manage to work without that by remembering the previous debug output or sometimes, when it's too big copying it into a file.

Looks like a solution in search for a problem that has maybe one feature that is worth looking into. Good work.

Re:U have screen wide enough to fix bugs in bubble (1)

roman_mir (125474) | more than 4 years ago | (#31429886)

oh, and forgot to mention. This: searching for path between functions. - I could use that but never as it is shown in that interface, by drawing lines between methods in boxes. Never. However, give me a search like dialog, where I can specify one and other methods, and show me all the connections between the methods and we are talking something useful.

Re:U have screen wide enough to fix bugs in bubble (1)

MemoryDragon (544441) | more than 4 years ago | (#31430190)

Actually I would like this as extension to an existing ide (Eclipse, Intellij) just another way of code navigation and structure detection which can be used optionally, I would never enforce the users to use that.
Thats also why the smalltalk editors sucked compared to any modern IDE, they enforce the 3 way view instead of giving the user the option to use this view.

So what does it do that I can't do in vim or emacs (0)

Anonymous Coward | more than 4 years ago | (#31429830)

I do everything in vim and regularly split the window so I can view functions in different files. I can adjust the size of the splits and quickly cycle through them all from the comfort of my keyboard. I have search at my fingertips, and the ability to set a mark and immediately return to it. I'm going to assume that emacs does all of this too.

It seems like the only thing this adds is an explicit notion of fragments, which I work with implicitly on a daily basis, all without having to reinvent how my code is organized.

The tools should let you work with whatever paradigm you wish, not dictate it to you.

I'll improve on your methods! (0)

Anonymous Coward | more than 4 years ago | (#31429840)

The narrator sounds like Strong Sad.

Haskell not Java (1)

Great Big Bird (1751616) | more than 4 years ago | (#31429948)

I think this idea might work best with a functional language like Haskell. But I can't imagine this being good for Java or any other object oriented language.

~/emacs& (0)

Anonymous Coward | more than 4 years ago | (#31429970)

Still the best/fastest way to code.

Emacs has been able to do this for ages ... (2, Funny)

ThomasB1 (1722382) | more than 4 years ago | (#31430002)

... I just haven't figured out the shortcut to open this view yet.

Neat! I'd really like to try that out. However... (1)

rhythmx (744978) | more than 4 years ago | (#31430022)

I'm not so keen on my IDE being reliant on all those static code analysis tools to determine your code's structure. For the most part they find all your methods just fine, but so many times they fall short, especially when you are not using Java.

VisualAge? (1)

Dunx (23729) | more than 4 years ago | (#31430168)

This sounds an awful lot like what VisualAge had in the late 90s. That mutated into Eclipse of course.

Re:VisualAge? (1)

Guillermito (187510) | more than 4 years ago | (#31430308)

Indeed. Early versions of Eclipse had an icon in the toolbar to switch between a complete file view and an "only the method you are working on" view. I suspect that feature was introduced to allow a smooth transition from VisualAge. I don't think that icon is so prominent on current Eclipse incarnations, but I wouldn't be surprised if it is still there, buried somewhere.

But... (0)

Anonymous Coward | more than 4 years ago | (#31430180)

But... I don't want to wrap lines. :(

Tiled window managers an vi called (0)

Anonymous Coward | more than 4 years ago | (#31430326)

And they want their UI back.

Not keen on the interface (1)

e2d2 (115622) | more than 4 years ago | (#31430328)

I'm not really loving the interface but the idea of using snippets needs to be expanded to include code others have written and tagged with meta data. I don't know how many times I've had to disturb others simply to ask "have you ever written code to do x?". It would be nice if I could search code snippets using meta data added by the developer or maybe from the code itself using reflection. Sure would be handy. Right now it's fairly clunky, search google, send emails, ask around. Then find that code and incorporate it using cut/paste.

Large Display (0)

Anonymous Coward | more than 4 years ago | (#31430478)

Interestingly, I believe that the current "classic" IDE is not much more than an extension of VT -based editors... extended more and more to support GUI's, naturally, but still limited displays. This code snippet editing is not new, either... many IDEs support viewing code at the method level. What's new with this... it really takes good advantage of very large resolution displays. I code at 1900x1200 resolution, now, and really have to finagle the display to make efficient use of it while editing a code file. Worse, it's a much more active thought process to split the display over multiple separate documents. I could easily imagine code bubbles becoming the wave of the future as displays grow beyond 1900x1200 res.

There's nothing fundamental about files. (2, Insightful)

hey! (33014) | more than 4 years ago | (#31430604)

From the operating system's standpoint, a file is the atomic unit of document management.

From a computer language standpoint, a file is an atomic unit of parsing.

From a programming standpoint, both these concepts have utility, but neither is particularly fundamental.

That's one of the things that makes literate programming possible.

That said, I'm not exactly thrilled by the bubble concept. It's one more place to store vague ideas and associations that will be incomprehensible a few weeks later. It's not bad like the attempts at "graphical programming" languages twenty years ago or so, but I don't see that its really better than code folding, or even as good. What a programmer has to do is to express himself clearly. Anything which helps that is good. Anything that doesn't is meh.

Also, I can't see using the system shown on a laptop. It might be usable on a 24" monitor, but not a 15".

Load More Comments
Slashdot Login

Need an Account?

Forgot your password?