Slashdot Mirror
Code Bubbles — Rethinking the IDE's User Interface
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."
Welcome to the 1970s. Squeak is one of the better implementations these days.
It looks like those (incredibly crappy) multi window IDEs of ten years ago. The name is cute though.
I'm going to need a bigger screen.
More UI elements to click-n-drag
As if having a couple dozen windows open and trying to organize them wasn't fun enough.
No sig for you!!
Perhaps we could call such a pieces of code "functions" instead.
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.
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.
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.
Bottles.
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.
meep
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.
I am putting myself to the fullest possible use, which is all I can think that any conscious entity can ever hope to do.
M-C-x fuck-up-my-screen
It must have been something you assimilated. . . .
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.
.. 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.
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
I rarely read replies, it's my opinion and if you thought about your opinion a little more, I'm OK with that.
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.
AccountKiller
See the Smalltalk browser:
http://onsmalltalk.com/on-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".
http://fargoagile.com/joomla/content/view/15/26/
"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...
A 21st century issue: the irony of technologies of abundance in the hands of those still thinking in terms of scarcity.
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.
But, does it have a good text editor?
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.
Qxe4
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.
-joe
-- Many men would appreciate a woman's mind more if they could fondle it
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.
You can't handle the truth.
Wanted:
Java developer with 40 years experience in Code Bubbling concepts.
5 years experience with the Code Bubble IDE.
When Fascism comes to America, it will call itself Anti-Fascism, and tell you to give up your guns.
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.
this sig has intentionally been left blank
... I just haven't figured out the shortcut to open this view yet.
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?
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".
Post may contain irony: discontinue use if experiencing mood swings, nausea or elevated blood pressure.
Yep, it's still there...go to Window -> Customize Perspective -> Tool Bar Visibility -> Editor Presentation
Check "Show Source of Selected Element Only" to add it to your toolbar.
"Slow down, Cowboy! It has been 3 years, 7 months and 26 days since you last successfully posted a comment."
Too bad that you have to have an unused partition on your drive to use this thing.
--
No files for you!
From a coder's perspective it looks pretty useful/usable. You often find yourself going back to alter something you've worked on before, and that something is spread out over 5 different places none of them in the same class/file/whatnot. If you built a bubble when you went in the first time, this would make that much easier to find all the parts again, especially since it has often been months since you last touched that code.
Then again, the last thing we need is to give Java coders a way to build even more complex class hierarchies.
Someone had to do it.
Beware the IDEs of March
I eat only the real part of complex carbohydrates.
Java + "small and short" = FILE_NOT_FOUND.
SyntaxError at Line:1 Column:25. Attempted write in left hand expression.
But... the future refused to change.
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.
Wait... are you by chance a US Patent Clerk?
In most programming languages this unit of code containing multiple classes is called a "file". I suppose it might be useful to have a Java preprocessor stage that was able to split up a multi-class file before feeding it to the compiler, to get round the strange "one class per file" limitation that Java's designers have seen fit to lumber us with, but I don't quite see why we'd need a whole new IDE and new terminology for something so simple.
When I read your post I thought it was strange how I hadn't noticed it. Then I realized: NoScript. It really makes the Web suck less.
Dilbert RSS feed
Actually, as I watched the video, the one thing I kept thinking was how nice it would be to use my current (1920x1200) screen efficiently for programming.
The typical Microsoft/Eclipse/whatever GUI today is horribly wasteful: vast areas are wasted on window dressing, toolbars, menus, scrollbars, title bars, line number margins, breakpoint margins, bookmark margins... I'm lucky if more than 1/2 of the pixels on my screen are actually showing me code at any given time, and the moment you mention compiling or debugging anything you're lucky if it's over 1/3 of the pixels.
Moreover, as others have noted, typical code formatting conventions today are wasteful as well. Any arbitrary limit on line width belongs in another century, and IME just results in developers who have a good reason to write a relatively long line messing around with awkward formatting hacks or truncating identifiers in order to obey the letter of the law. Equally, there is no point having lines that average perhaps half that length filling all 1920 pixels of my widescreen monitor's width.
There were plenty of ideas in the presentation that I thought had potential, though many of them have been tried by others before as well. Of all of those ideas, the one thing I wish every IDE would do tomorrow is let me open lots of smaller windows as I navigate my code, organise the windows automatically, and hide all the other clutter unless I actually want it. The Code Bubbles IDE seems to do a decent job of that.
If you disagree, post your argument. (-1, Overrated) isn't your personal censorship tool for views you don't like.