Would you use Code Bubbles? [closed]
I've read this question mentioning Code Bubbles开发者_StackOverflow中文版 and I've watched their video presentation.
The video is impressive, and does seem a little bit futuristic, but apparently it's somewhat real.
But that kept me thinking... Would a developer really use such tool?
We, as developers, are used to deal with code files, organizing them in directories, in one way or another, some common IDE (for those language that has them).
It would be a great leap to use something like Code Bubbles, as they propose.
I, personally, am not sure if I could work in such environment... although I think I would just need some adjusting... but I really don't see my mind working out the kinks of it.
What are your thoughts on this?
I would use it in a heartbeat. I always want to work that way anyways.
I only think about things in terms of a directory structure when I first create them: after that I always want to work by train-of-thought rather than by file.
For languages like C# and Java where the actual organisation of code files and blocks (methods, etc) is fairly rigid (even more so in Java than C#) then something that provides a novel "view" of the code could probably work. You could allow the tool to organise your code with one class per file, methods sorted by visibility, or whatever coding standard you wanted, and the tool could handle it all in such a way that someone could still come along and look at the "raw" files and make sense of it all.
It would be a problem for a language like C++ where you can basically do whatever you like...
Think about it this way... What would be easier:
(1.) To have code bubbles in which you can view a chain of functions that are called from each other all in one simultaneous view
-OR-
(2.) Constantly tab back-and-forth between those functions, spread across 6 or 7 source code files, in a single text editor?
Would I use code bubbles? If MS doesn't come out with a VS equivalent in the next few years, I might suddenly develop a very keen interest in becoming a Java developer.
I thought it was an impressively innovative concept, I can't wait to try it out!
Apart from the brilliant idea to see code independently from the files it is stored in, the thing I found the most interesting was the "minimap"-like bar that showed a miniature of your bubble layout and let you instantly scroll or position your "desktop" over a particular area.
This is the way virtual desktops should be implemented on a operating-system level!
Real programmers use text editors. :)
No seriously, I like Code Bubbles, but it takes a lot more than a new GUI for me to switch.
The idea of linking code bubbles together and moving them as a group seems a little silly and probably not useful in most practical scenarios.
I think all programmers, however, would be well-served to graphically see their applications take up space on the screen, rather than taking up (less-visible) space as lines in a file. For that alone, I think it's useful as a presentation tool, if not as a programming environment.
For those of you who are interested, Microsoft Research is also doing something similar for Visual Studio. It is called Code Canvas.
You can learn more and see a video here: http://blogs.msdn.com/b/kaelr/archive/2009/03/26/code-canvas.aspx
Regarding the original question, I signed up for the beta as soon as I found out about Code Bubbles. I think it has some really good ideas and would like to try it out. Even if it turns out not be as useful as they claim, I'm sure some of those concepts will evolve to be used by many programmers.
I'll definitely download it and try to use it when it's available. It looks like a neat idea that could speed debugging, code reviews, and some types of development. Also, the code bubbles FAQ said they support viewing whole files as large, scrollable bubbles - so you can break out if the bubble metaphor when needed.
Probably the biggest issue off the top of my head is I don't think there's support for anything but Java. I spent most of my time in C, and multiple language support is critical if they want this idea to really take off.
I would use code bubbles for many reasons, but one that really jazzed me is the debugging. I like the idea that when you step into a function it opens a new bubble for that function, so you can review the code that called the function and the same time see the function its self, i think that's good productivity.
Gath
Absolutely! The file structure doesn't affect the bubble view so you could technically use traditional means to organize the projects source files. Where this really helps is navigating already entrenched code. A must for learning someone else's code. It also lends itself well to keeping the code clean--many small and concise objects and functions.
I think it looks nice, but to me, it looks like it would be more useful when debugging/stepping into code. Not having the IDE open up the entire code file and just creating a little code bubble is kind of cool.
I think Code Bubbles opens up ideas for the whole GUI desktop metaphor, not just programming.
Much of what we do is hierarchical. Imagine writing a project document. Does it have headings? Subheadings? Imagine building the Table of Contents (ToC), then clicking on each heading/subheading to get a separate window where you put the content. You could have multiple subsections open at the same time, in different bubbles. You can always split-screen a modern word processor to accomplish the same thing, but I'd like to be able to move the parts out to separate windows so I can arrange them the way I want, instead of just relying on the app to "tile" the sub-windows for me. Code-Bubbles-as-desktop would allow that.
Imagine that you are working, collaboratively, on that document. You click a subhead in the ToC and start working on it. Someone else clicks on another one and starts working on it. You can use traditional locking to avoid having someone else mess with what you're doing and vice versa. Yes, I know about EtherPad. I've used it. It drives me nuts.
I've been thinking about doing a wiki-based document/program composition system, where you create headings in the main document, each of them links to the actual content for those headings. Different parts would come up in different windows, which you could arrange as you see fit. Code-Bubbles-as-desktop is, arguably, a more elegant solution.
Obviously, this can be done with programming, as a program is little more than a complex, very precise document, with an extremely nit-picky target audience. Programs are, typically, extremely hierarchical. As it stands, when I'm programing, I'm using either Vim or Eclipse. Both of them have the ability to "collapse" sections of code I'm not looking at, giving me a mix of high-level overview and actual code. The same would be accomplished in Code Bubbles by having one bubble showing your method definitions and other bubbles containing the method contents. All of them would be "woven" back together before feeding it to the compiler.
Also, when I'm programming, I typically "flesh out" a method or function by putting in high-level pseudocode in comments, then going through and filling in the program code which implements each piece of pseudocode. Those pseudocode comments could provide the ToC pieces, which would open bubbles to hold the actual code. The system would need to "weave" the pieces together into the main document. That would work, regardless of what programming language you are using.
Is my interest in Literate Programming coming through clearly enough?
Let's take this to the next level. You are using a tablet or netbook. You have a lot less screen real estate to work with. Oh, gee, look at that; the bubbles are all relatively small. Use the "context bar" across the top to find the bubble you're looking for and the bubble can take over the screen. Now, you have a way to compose documents (including programs) which works on smaller, size-constrained devices.
It's probably wishful thinking, but I'm thinking this could be a significant new paradigm, not just for programming but for the whole GUI. I would certainly use it.
I think the changes to your workflow (and thus the learning curve upfront) would not be so big as it initially appears: If you are using Eclipse (properly), you are already navigating using Open Type (by name), Open Call Hierarchy, Open Type Hierarchy, Open Declaration, and so on. Collapsed code blocks also seems to be somewhat of a precursor to code bubbles.
I agree with Codeka that it would probably only work for "strictly organized" languages like Java, and not so well for things like Perl, which give more freedom to the programmer how he wants to arrange things (at the expense of the tool support he can expect).
I can see myself trying to work in such environment since I always develop using my IDE, some papers on my desk and some different notepad/vim opened files with different snippets and thoughts of different sections of code/software. I'm not saying the interface has to be exaclty like Code Bubbles, but something that gets the idea.
...but I need to really test it, and feel it. I think a mix of Bubbles and a traditional IDE in some way is the way to go.
Fact is: it's really interesting to see people inventing things trying to improve our development way of working (like Zen Coding in web development, just to give an example), and, even if this approach fails, some ideas can be borrowed to other projects.
Seriously, what I'm expecting to happen in the future is the day I'm going to use a keyboard and a responsive multitouch interface, dragging items and sections of code across an ide, designing and programming at the same time using my hands for drawing in a screen and my keyboard: something like an iPad for programming.
(There are some really good comments about this Code Bubbles video on youtube, it's a good idea to check it out).
I can't say whether I'd stick with it in the long term, but I'd certainly like to spend a few months working in that environment.
There are some really interesting GUI ideas here - it's an inspiring video.
I'm more excited about Code Bubbles than I have been about a new concept in a while. For some years now, I've been waiting for the code community to start thinking of code databases, not code files. I think the file metaphor has crippled our thinking and influenced our tools in the wrong way.
For example, why is there even a question of whether unit tests should go in the same file as the production code? Of course they go together, but we usually make them separate because we don't want the tests to be packaged into the .jar. We are letting the build tools force us to bounce between these contrived artifacts called files. Whether Code Bubbles is a better metaphor remains to be seen, but anything that breaks us free from the file metaphor has to be a good thing.
I've just discovered Code Bubbles and was ecstatic to discover the beta. I can't wait to see this for myself.
My impression from the demo was that I could see how that approach would be useful for large programs. However, in the 14 years I've been programming for a living, I've only written a program that large once (inherited a couple more).
That was when I was 22, and I regretted making it so monolithic for the next six years until it was retired. It was a constant maintenance problem, because no one but me ever really understood the whole thing.
加载中,请稍侯......
精彩评论