你会使用“代码泡泡”吗？
我读过这个问题提到Code Bubbles 我看过他们的视频演示。
这段视频令人印象深刻，看起来确实有点未来感，但显然它有点真实。
但这让我不断思考......开发人员真的会使用这样的工具吗？
作为开发人员，我们习惯于处理代码文件，以一种或另一种方式将它们组织在目录中，一些常见的 IDE（对于那些拥有它们的语言）。
正如他们所建议的那样，使用 Code Bubbles 之类的东西将是一个巨大的飞跃。
我个人不确定我是否可以在这样的环境中工作......虽然我认为我只需要一些调整......但我真的没有看到我的头脑解决它的问题。
您对此有何看法？
I've read this question mentioning Code Bubbles 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?
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（16）
我会毫不犹豫地使用它。无论如何，我一直想这样工作。
当我第一次创建它们时，我只考虑目录结构：此后我总是想通过思路而不是文件来工作。
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.
对于像 C# 和 Java 这样的语言，代码文件和块（方法等）的实际组织相当严格（在 Java 中比 C# 更是如此），那么提供新颖的代码“视图”的东西可能会起作用。您可以允许该工具使用每个文件一个类、按可见性排序的方法或您想要的任何编码标准来组织代码，并且该工具可以以这样的方式处理这一切，以便有人仍然可以过来查看“原始代码”。 ” 文件并理解这一切。
对于像 C++ 这样的语言来说，这将是一个问题，在 C++ 中你基本上可以做任何你喜欢做的事情......
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...
以这种方式思考...什么会更容易：
(1.) 拥有代码气泡，您可以在其中查看在一个同步视图中相互调用的一系列函数
- 或 -
(2.) 不断地制表符在单个文本编辑器中，在这些函数之间来回切换，分布在 6 或 7 个源代码文件中？
我会使用代码气泡吗？如果 MS 在未来几年内没有推出与 VS 相当的产品，我可能会突然对成为一名 Java 开发人员产生浓厚的兴趣。
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!
真正的程序员使用文本编辑器。 :)
不，说真的，我喜欢 Code Bubbles，但要我切换，需要的不仅仅是一个新的 GUI。
将代码气泡链接在一起并将它们作为一个组移动的想法似乎有点愚蠢，并且在大多数实际场景中可能没有用。
然而，我认为所有程序员都应该以图形方式看到他们的应用程序在屏幕上占用的空间，而不是像文件中的行一样占用（不太可见的）空间。仅就这一点而言，我认为它作为演示工具很有用，即使不是作为编程环境。
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.
对于那些感兴趣的人来说，微软研究院也在为 Visual Studio 做类似的事情。它被称为代码画布。
您可以在此处了解更多信息并观看视频： http://blogs.msdn.com/b/kaelr/archive/2009/03/26/code-canvas.aspx
关于原来的问题，我一发现Code就注册了测试版气泡。我认为它有一些非常好的想法，并且想尝试一下。即使事实证明它并不像他们声称的那么有用，我相信其中一些概念将会发展到被许多程序员使用。
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.
我一定会下载它并在可用时尝试使用它。这看起来是一个很棒的想法，可以加快调试、代码审查和某些类型的开发速度。此外，代码气泡常见问题解答表示它们支持将整个文件视为大的、可滚动的气泡 - 因此您可以在需要时打破气泡隐喻。
可能我脑子里最大的问题是我认为除了 Java 之外不支持任何东西。我大部分时间都花在 C 上，如果他们希望这个想法真正起飞，多语言支持至关重要。
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.
我认为它看起来不错，但对我来说，它看起来在调试/单步执行代码时更有用。不用 IDE 打开整个代码文件，只创建一个小代码气泡，这有点酷。
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.
我认为 Code Bubbles 为整个 GUI 桌面隐喻开辟了思路，而不仅仅是编程。
我们所做的很多事情都是分层的。想象一下编写一个项目文档。它有标题吗？副标题？想象一下构建目录 (ToC)，然后单击每个标题/副标题以获得一个单独的窗口，您可以在其中放置内容。您可以在不同的气泡中同时打开多个小节。您始终可以分屏现代文字处理器来完成同样的事情，但我希望能够将这些部分移到单独的窗口中，这样我就可以按照我想要的方式排列它们，而不是仅仅依靠应用程序来为我“平铺”子窗口。 Code-Bubbles-as-desktop 可以实现这一点。
想象一下，您正在协作处理该文档。您单击目录中的小标题并开始处理它。其他人点击另一个并开始处理它。您可以使用传统锁定来避免其他人干扰您正在做的事情，反之亦然。是的，我知道 EtherPad。我用过。这让我发疯。
我一直在考虑做一个基于 wiki 的文档/程序组合系统，您可以在主文档中创建标题，每个标题都链接到这些标题的实际内容。不同的部分会出现在不同的窗口中，您可以根据需要进行排列。可以说，Code-Bubbles-as-desktop 是一个更优雅的解决方案。
显然，这可以通过编程来完成，因为程序只不过是一个复杂、非常精确的文档，并且目标受众非常挑剔。程序通常是非常分层的。目前，当我编程时，我使用 Vim 或 Eclipse。它们都能够“折叠”我没有查看的代码部分，从而为我提供高级概述和实际代码的混合。在代码气泡中可以通过一个气泡显示方法定义和其他气泡包含方法内容来完成同样的任务。在将其提供给编译器之前，所有这些都将被“编织”在一起。
另外，当我编程时，我通常通过在注释中放入高级伪代码来“充实”方法或函数，然后遍历并填写实现每段伪代码的程序代码。这些伪代码注释可以提供目录片段，从而打开气泡来保存实际代码。系统需要将各个部分“编织”到主文档中。无论您使用哪种编程语言，这都会起作用。
我对文学编程的兴趣是否足够明显？
让我们将其提升到一个新的水平。您正在使用平板电脑或上网本。您可以使用的屏幕空间要少得多。哦，天哪，看看那个；气泡都比较小。使用顶部的“上下文栏”找到您要查找的气泡，气泡可以占据整个屏幕。现在，您可以编写在较小的、尺寸受限的设备上运行的文档（包括程序）。
这可能是一厢情愿的想法，但我认为这可能是一个重要的新范例，不仅适用于编程，而且适用于整个 GUI。我肯定会用它。
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.
我认为您的工作流程（以及前期的学习曲线）的变化不会像最初看起来那么大：如果您（正确）使用 Eclipse，那么您已经在使用 Open Type（按名称）、Open Call Hierarchy 进行导航，开放类型层次结构、开放声明等。折叠的代码块似乎也是代码泡沫的前兆。
我同意 Codeka 的观点，即它可能只适用于“严格组织”的语言，如 Java，而不适用于 Perl 等语言，Perl 为程序员提供了更多的自由来安排事情（以牺牲他所获得的工具支持为代价）。可以期待）。
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).
我可以看到自己尝试在这样的环境中工作，因为我总是使用我的 IDE 进行开发，我的桌子上有一些文件以及一些不同的记事本/vim 打开的文件，其中包含不同的代码片段和不同部分的代码/软件的想法。我并不是说界面必须像 Code Bubbles 一样精确，而是说要能够理解这个想法。
......但我需要真正测试它并感受它。我认为以某种方式将 Bubbles 和传统 IDE 结合起来才是正确的选择。
事实是：看到人们发明一些东西试图改进我们的工作开发方式真的很有趣（例如 Zen Coding 在 Web 开发中，只是举个例子），而且，即使这种方法失败了，一些想法也可以借鉴到其他方法项目。
说真的，我期望将来发生的事情是有一天我将使用键盘和响应式多点触控界面，在 ide 上拖动项目和代码段，同时用我的双手进行设计和编程在屏幕和键盘上绘图：类似于用于编程的 iPad。
（youtube 上有一些关于这个 Code Bubbles 视频的非常好的评论，最好去看看）。
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).
我不能说我是否会长期坚持下去，但我当然愿意在那种环境中工作几个月。
这里有一些非常有趣的 GUI 想法 - 这是一个鼓舞人心的视频。
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.
一段时间以来，我对“代码泡沫”的兴趣比对新概念的兴趣还要兴奋。多年来，我一直在等待代码社区开始考虑代码数据库，而不是代码文件。我认为文件隐喻削弱了我们的思维，并以错误的方式影响了我们的工具。
例如，为什么会有单元测试是否应该与生产代码放在同一个文件中的问题？当然，它们是在一起的，但我们通常将它们分开，因为我们不希望将测试打包到 .jar 中。我们让构建工具迫使我们在这些称为文件的人为工件之间切换。代码泡沫是否是一个更好的隐喻还有待观察，但任何能让我们摆脱文件隐喻的东西都一定是一件好事。
我刚刚发现了 Code Bubbles，并对发现测试版感到欣喜若狂。我迫不及待地想亲眼目睹这一点。
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.
演示给我的印象是，我可以看到这种方法对于大型程序有何用处。然而，在我以编程为生的 14 年里，我只写过一次这么大的程序（又继承了几次）。
那是我 22 岁的时候，我很遗憾在接下来的六年里让它变得如此单一，直到它退役。这是一个持续存在的维护问题，因为除了我之外没有人真正理解整个事情。
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.