Code Bubbles — Rethinking the IDE's User Interface 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."
Sounds like Smalltalk's code browser. (Score:5, Insightful)
Welcome to the 1970s. Squeak [squeak.org] is one of the better implementations these days.
Re: (Score:2)
What HR Wants... (Score:5, Funny)
Wanted:
Java developer with 40 years experience in Code Bubbling concepts.
5 years experience with the Code Bubble IDE.
Re:What HR Wants... (Score:4, Funny)
You forgot being 20 years old, single, and having already raised children to adulthood.
Re: (Score:2)
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...
Re: (Score:2)
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)
Re: (Score:2)
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 (Score:2)
Then TFS mentions something as banal as "wrapping long lines of code"....and my bubble bursts.
Re:bubbles = isolation (Score:5, Insightful)
Perhaps we could call such a pieces of code "functions" instead.
Re: (Score:3, Funny)
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?
Re: (Score:3, Funny)
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 m
Re: (Score:3, Insightful)
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.
Re:bubbles = isolation (Score:5, Insightful)
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 (Score:2)
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 (Score:5, Insightful)
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: (Score:2)
Re: (Score:2)
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
Re: (Score:2)
It may be crappy, but it's everywhere. This is the whole reason .NET Reflector is so popular.
Re:bubbles = isolation (Score:5, Insightful)
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.
Does it work for a new project (Score:2)
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
Re: (Score:2)
I also really like how they used this concept in their debugger. Bra
Re: (Score:2)
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
Re: (Score:2)
Re: (Score:2)
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
Re: (Score:2)
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
Re: (Score:2)
Re: (Score:2)
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:3, Funny)
Java + "small and short" = FILE_NOT_FOUND.
SyntaxError at Line:1 Column:25. Attempted write in left hand expression.
Re: (Score:2, Insightful)
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
Re: (Score:2)
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
Which, I suppose, you only really get if you use Java anyway. Otherwis
Re: (Score:2)
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)
Re: (Score:2)
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: (Score:2)
Re: (Score:2)
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
Soo much space required. (Score:4, Insightful)
I'm going to need a bigger screen.
Re: (Score:3, Informative)
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)
Re: (Score:2)
Re: (Score:2)
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
But at least now we can use those wide screens (Score:4, Interesting)
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.
On the fence (Score:2)
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.
Where have I seen something like this? (Score:2)
Oh goodie (Score:4, Insightful)
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: (Score:2)
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)
If your editor does not already let you do this, why haven't you upgraded to Emacs yet?
Re: (Score:3, Informative)
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.
Re: (Score:2)
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)
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.
Is it really the case? (Score:2)
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.
Re: (Score:2)
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.
Re: (Score:2)
"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: (Score:2)
Re: (Score:2)
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: (Score:3, Informative)
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.
Most people would not be able to keep more than 9 lines clearly discernible in their heads. This is why our brains naturally go through the process of recoding. No one thinks of 1000 lines of code as individual lines, we think of them as the concept they cover. But this is why object oriented design can into being in the first place, it's a form of recoding.
This code bubbles thing is really just another realization of Miller's magic number. That's not to say it's not a good thing, just saying it's not a
Re: (Score:2)
The point is that for a good short order cook, real-time skills are fundamental, for a professional software developer, they're not.
Re: (Score:2)
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.
Mylyn in Eclipse (Score:3, Informative)
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.
OT: God Damn Twitter Shit (Score:2)
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)
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.
Debugging and documentation (Score:4, Interesting)
Re: (Score:2)
A good uml plugin can almost do the same... :-)
Problem is there are no good uml plugins
Re: (Score:2)
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.
XEmacs binding... (Score:5, Funny)
Looks promising... (Score:3, Interesting)
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
codebase awareness (Score:2)
snippets might be useful for better diffs (Score:2)
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
Step by step, Java reinvents Smalltalk... (Score:5, Interesting)
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...
Re: (Score:2)
Parcplace killed the entire Smalltalk market with the Digitalk Fiasco...
And yes greed and internal corporate quarelling basically did it!
Re: (Score:2)
I agree, Scala is a great step forward, as are many other JVM languages, Jython, JRuby, Kawa, Clojure, and so on...
http://www.is-research.de/info/vmlanguages/ [is-research.de]
http://en.wikipedia.org/wiki/List_of_JVM_languages [wikipedia.org]
It's too bad Sun did not focus on making a universal VM from the start... Or that the Smalltalk people did not embrace other languages...
More more comments by me on that general issue:
"[Edu-sig] Freedom: some Smalltalk history and Python implications"
What a giant failure (Score:2, Insightful)
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: (Score:2)
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
Re:What a giant failure (Score:4, Insightful)
Re: (Score:3, Funny)
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)
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
Re: (Score:2)
I only cut and paste code I found on the 'net, you insensitive clod!
Re: (Score:2)
Re:What a giant failure (Score:5, Insightful)
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 (Score:4, Informative)
And hey... If you watched the whole video, you'd discover: They do have ways of navigating the space via keyboard.
I'm more a .NET guy these days, but I'd love to try this. Even if the whole thing isn't a slam-dunk, I think there are valuable and useful concepts here that can be useful elsewhere.
~D
Re: (Score:2)
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)
2nd goal of a Java developer achieved.... (Score:4, Funny)
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
U have screen wide enough to fix bugs in bubbles? (Score:3, Insightful)
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: (Score:2)
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: (Score:2)
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.
Re: (Score:2)
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
Emacs has been able to do this for ages ... (Score:2, Funny)
Neat! I'd really like to try that out. However... (Score:2)
VisualAge? (Score:2)
This sounds an awful lot like what VisualAge had in the late 90s. That mutated into Eclipse of course.
Re: (Score:2)
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)
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.
Not keen on the interface (Score:2)
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
There's nothing fundamental about files. (Score:3, Insightful)
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".
since it is not based on files (Score:3, Funny)
Too bad that you have to have an unused partition on your drive to use this thing.
--
No files for you!
Fundamentalist (Score:2)
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.
Re: (Score:2)
Literate Programming (Score:2)
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
Shakespeare said it (Score:5, Funny)
Re: (Score:3, Funny)
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?