Forgot your password?
typodupeerror
GUI Java Programming User Journal

Code Bubbles — Rethinking the IDE's User Interface 198

Posted by timothy
from the don't-get-distracted-now dept.
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."
This discussion has been archived. No new comments can be posted.

Code Bubbles — Rethinking the IDE's User Interface

Comments Filter:
  • by Anonymous Coward on Wednesday March 10, 2010 @02:57PM (#31429294)

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

    • Indeed, welcome to the '70s, but the Newspeak code browser these days is a lot nicer than Squeak / Pharo's approach.
    • by sycodon (149926) on Wednesday March 10, 2010 @03:43PM (#31429904)

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

      • by ultranova (717540) on Wednesday March 10, 2010 @05:23PM (#31431170)

        You forgot being 20 years old, single, and having already raised children to adulthood.

        • by mikael_j (106439)

          And you forgot about the master's degree in Computer Science with a specialization in financial processing algorithms for currency exchange trading and their implementation in autonomous combat vehicles.

          Ok, I haven't seen anything that extreme but it's pretty funny to read articles in trade magazines where some hiring manager whines about there being no developers available on the job market at the same time as they have ads out with requirements not far off from the above...

    • It is the same to Smalltalk code browser as Emacs is to Notepad. The most basic concept may be the same, but just watch that video to the very end...

  • Deja vu (Score:2, Insightful)

    by ascari (1400977)
    It looks like those (incredibly crappy) multi window IDEs of ten years ago. The name is cute though.
  • 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.

    • by Anonymous Coward on Wednesday March 10, 2010 @03:11PM (#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: (Score:3, Funny)

        by Dishwasha (125561)

        I just checked on Wikipedia [wikipedia.org] 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?

    • by ottothecow (600101) <ottothecow@gma i l . com> on Wednesday March 10, 2010 @03:12PM (#31429476) Homepage
      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.

      • 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.

      • by sirius_bbr (562544) on Wednesday March 10, 2010 @03:44PM (#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.

        • +1 If I had mod points. This is exactly where this would be helpful, in my case following code written years before I worked here trying to track down some bug.
      • by pclminion (145572)

        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

        If file3.c and file7.c are typically edited in concert, this is a sign that their functionality might better belong in a single file. If file3.c simply USES file7.c, then there is normally no reason to look at the code inside file7.c. You are trying to use a code editing tool to solve something which is fundamentally a design i

    • by l3v1 (787564) on Wednesday March 10, 2010 @03:17PM (#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.
      • 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

        • by asylumx (881307)
          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. Bra
      • 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 auth

      • Most of the development I do is on a dual screen (at work) or three screen (at home) workstation. I'd have no problems spreading that workspace out. I think it would be great for debugging like in the video, but I wouldn't want to write new code in that interface. Make this a plugin for eclipse that lets me open this as a view for debugging and I'd use it in a heartbeat.
        • Just looked at the beta signup and

          Code Bubbles is built on top of Eclipse so it can open/work with any existing Eclipse project. In addition, you can leave Eclipse running in the background so that if you need to use an Eclipse plugin you can simply flip back to Eclipse to perform a checkin, for example.

          I'm going to have to give it a try

      • 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.

        I noticed the same thing, but then perhaps it's actually good if IDE forces the coder to write short, clear methods, rather than multi-page monstrosities.

        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.

        Looking at the video, I'd say that I don't see this thing being convenient for writing large amounts of new code, for precisely this reason. However, this approach sounds very handy for a typical bug fixing session, or adding minor functionality, where the biggest part of the challenge is finding out what and where to change, and the actual code to be type

      • by fbjon (692006)
        AFAIK, this is about viewing and working with code. Not managing the code in the actual files. Also, there's nothing wrong with a scrolling workspace, where scrolling is easy like Photoshop or Google Earth.
      • by beelsebob (529313)

        To be fair, that's partly a good thing. Functions longer than a few lines are typically a good indication that some refactoring is needed.

    • Re: (Score:2, Insightful)

      by Galestar (1473827)

      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 d

      • 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. Otherwis

      • by SQLGuru (980662)

        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: (Score:3, Insightful)

      by phantomfive (622387)
      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 bei
    • by guruevi (827432)

      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.

      • by fbjon (692006)
        The IDE doesn't code interactions, the programmer does by way of the diagrammed view that the IDE presents.
    • by ianare (1132971)

      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 wo

  • by coolsnowmen (695297) on Wednesday March 10, 2010 @03:03PM (#31429350)

    I'm going to need a bigger screen.

    • Re: (Score:3, Informative)

      by patro (104336)

      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: (Score:3, Insightful)

        by Unoti (731964)
        You're right. But 1920x1080, with 2 or 3 monitors isn't unreasonably expensive to get. And it's getting cheaper with each passing month. I've got my main monitor at 1980x1080, plus 2 monitors on the sides of that slightly smaller. It's cost effective and reasonable to get multiple monitors. It's harder to use the screen real estate effectively than it is to get the real estate.
    • 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.
    • 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 impres

    • by Anonymous Brave Guy (457657) on Wednesday March 10, 2010 @08:50PM (#31433230)

      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.

  • 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.

  • 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 (Score:4, Insightful)

    by aztektum (170569) on Wednesday March 10, 2010 @03:09PM (#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.

    • by copponex (13876)

      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: (Score:2, Funny)

        by Mr. Slippery (47854)

        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.

        If your editor does not already let you do this, why haven't you upgraded to Emacs yet?

    • Re: (Score:3, Informative)

      by evil_aar0n (1001515)

      I used to be really anal about how many windows I had open and how they were positioned, simply to avoid the problem of clutter and trying to find what window I wanted. Then I started using a Mac, with Expose, and now I have windows opened all over the place and don't care. Finding the one I want is either F8, F9 or F10 away. I don't know how I functioned without Expose, before.

      • by beelsebob (529313)

        Even as a mac user for life, who had windows dotted around all over the place even before expose I *still* don't understand how I functioned without it.

  • Screen Size (Score:5, Interesting)

    by pavon (30274) on Wednesday March 10, 2010 @03:11PM (#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.

    • I was *jokingly* asking if this is the case in my previous post (http://developers.slashdot.org/comments.pl?sid=1578224&cid=31429828), but you seem to confirm this. Wow, stunned...

      Paul B.

    • 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 (Score:3, Informative)

    by MyForest (597329) <David@MyForest.Com> on Wednesday March 10, 2010 @03:12PM (#31429472) Homepage

    I've recently been using Mylyn [eclipse.org] 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 [ibm.com]" to give me feedback on the things I've been tinkering with.

    • I tried to read the summary page to see what Mylyn was, but couldn't get halfway through it as my focus was constantly pulled away by that piece-of-shit zero-value-added twitter feed they have on the screen. What the fuck is wrong with web developers these days that they would think this is a good idea?

      • Re: (Score:3, Informative)

        by icebraining (1313345)

        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.

  • by beakerMeep (716990) on Wednesday March 10, 2010 @03:14PM (#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.
    • A good uml plugin can almost do the same...
      Problem is there are no good uml plugins :-)

    • It's built on top of Eclipse, so I imagine that there's a pretty straightforward way to switch back to the standard eclipse view. We'll see - I signed up for the beta.

  • by fahrbot-bot (874524) on Wednesday March 10, 2010 @03:18PM (#31429544)
    M-C-x fuck-up-my-screen
  • Looks promising... (Score:3, Interesting)

    by johnlcallaway (165670) on Wednesday March 10, 2010 @03:22PM (#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.
  • 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
  • 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

  • by Paul Fernhout (109597) on Wednesday March 10, 2010 @03:29PM (#31429692) Homepage

    See the Smalltalk browser:
        http://onsmalltalk.com/on-the-smalltalk-browser [onsmalltalk.com]

    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/ [fargoagile.com]
            "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...

  • by Chemisor (97276)

    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.

    • 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 b

    • by MagikSlinger (259969) on Wednesday March 10, 2010 @03:42PM (#31429878) Homepage Journal
      Speak for yourself. Some of us like the mouse and window for code editing.
      • Re: (Score:3, Funny)

        by Just Some Guy (3352)

        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: (Score:3, Insightful)

          by Coryoth (254751)

          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.

          I think that really depends on what sort of coding you're doing. Now I have no idea what your work is like, but I find that the amount of time I spend continuously pounding out code on the keyboard is pretty limited -- I spend far more time reading code then writing, and far more time thinking than reading -- so context switches are pretty cheap, especially when you can grab the mouse and move it to where you need while reading or thinking. But as I say, that's one type of coding; I have seen code that has

        • 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.

          I only cut and paste code I found on the 'net, you insensitive clod!

    • by martas (1439879)
      are you using lynx right now, by any chance?
    • by stoanhart (876182) on Wednesday March 10, 2010 @03:54PM (#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.
    • 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... (Score:3, Interesting)

    by narooze (845310) on Wednesday March 10, 2010 @03:32PM (#31429738)
    But, does it have a good text editor [vim.org]?
  • by croftj (2359) on Wednesday March 10, 2010 @03:33PM (#31429750) Homepage

    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

  • by roman_mir (125474) on Wednesday March 10, 2010 @03:35PM (#31429770) Homepage Journal

    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.

    • by roman_mir (125474)

      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.

    • 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.

    • by SimonInOz (579741)

      One of the cheapest ways to improve programmer productivity is to get more screen area. Currently you can get 2 large LCD screens for less than $500. And there is your screen space. It works in Windows or Linux (Ubuntu certainly does a decent job), with Eclipse.
      And if you haven't already done this for yourself and all your developers you are wasting time and money. You do need a passable graphics card or two, but nothing too exotic - code development is not graphics intensive like gaming.

      And next - four scr

  • ... I just haven't figured out the shortcut to open this view yet.
  • 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.
  • This sounds an awful lot like what VisualAge had in the late 90s. That mutated into Eclipse of course.

    • 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.

      • Re: (Score:3, Informative)

        by mfnickster (182520)

        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.

  • 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 in

  • by hey! (33014) on Wednesday March 10, 2010 @04:38PM (#31430604) Homepage Journal

    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".

  • by mestar (121800) on Wednesday March 10, 2010 @05:17PM (#31431098)

    Too bad that you have to have an unused partition on your drive to use this thing.

    --
    No files for you!

  • Call me a fundamentalist, but the last thing I want from an IDE is to further obscure the way code relates to files. When programming, I want to know what I am doing. I want to know how the project is structured, I want to know how I can do things _without_ the software that I happen to be using at the moment. That way, I can switch software at some point, and/or automate things.

    That said, I am all for innovation, and I'm also all for innovation in IDEs. I'm curious to see how this goes.

    • I think it may work for Java, since in my experience Java forces a certain layout on your files/classes. However, I don't like the way the bubbles work and will continue to not use it.
  • This sounds very much like http://en.wikipedia.org/wiki/Literate_programming/ [wikipedia.org], as introduced by Knuth.

    I looked at using Tangle and Weave for C development a long time ago, but found that it was a pretty difficult paradigm to get used to.

    FYI, TeX and Metafont were both written using Tangle and Weave. Pretty impressive to read the source code, which had both code and documentation intermixed. It was a novel way (as in innovative, and as in a book :-) )to develop a complex application; I believe that Knuth e

  • by Megahard (1053072) on Wednesday March 10, 2010 @06:02PM (#31431688)
    Beware the IDEs of March

Nothing is impossible for the man who doesn't have to do it himself. -- A.H. Weiler

Working...