Hacker News new | past | comments | ask | show | jobs | submit login
New IDE: code bubbles (brown.edu)
414 points by maxharris on Mar 10, 2010 | hide | past | favorite | 219 comments

I like the concepts of the bubbles and the fact that it show call execution so well instead of one file at a time. That's really cool, but what I find so amazing is that since they built on top of Eclipse they got much further towards a usable system like having an integrated debugger was a nice surprise to me. 10-20 years ago the gap between an academic project and a finished product would have been much wider. Not to mention they got to explore more ground with the concept. Just shows how open source software enables innovation better.

I feel like the response has been fairly lukewarm, but to me this is some really nice (dare I say game-changing) stuff. Mindmap + IDE = great. Why? I have written in a variety of languages, and my number one complaint, whether it be with eclipse, textmate, vim, emacs, whatever, is the clumsiness of going from one file to another and then back to the original. Further, outside of actual development, when debugging, I really like to have all the different pieces open at once. This is a nice way for this to happen and is pretty slick with the different gui movement options. I, like other posters, would be really psyched if you could have some kind of MVC opener which would automagically open all the code files using a certain view. That would save a lot of time shuffling, and then save a lot of time by having them all displayed simultaneously. Anyway, I'm probably over reacting, but after years of having to go back to the mouse everytime i need to look at a new file or struggling to figure out in which square i put which file, this is definitely, in my opinion, a step in right direction.

my number one complaint, whether it be with eclipse, textmate, vim, emacs, whatever, is the clumsiness of going from one file to another and then back to the original

Emacs has a stack for this. Jump to related definition with M-., jump back to where you were before with M-∗. One keystroke is not exactly "clumsy", IMHO.

I, like other posters, would be really psyched if you could have some kind of MVC opener which would automagically open all the code files using a certain view.

I just open all files in the project with `eproject-open-all-project-files`. Then I can iswitchb between them. (Of course, there are lots of extensions that don't require you to have the files open to easily navigate to them; eproject, anything, ido, etc.)

Have a look at the 'Leo' editor, it has views on your source using 'cloned' nodes. It even allows you to group all the code around a bug and a fix together, document the whole thing and never move any of the original code around.

It's a pretty neat literate programming tool.

Leo is really nice and I've used it on real projects to refactor and study my architecture.

I'd actually say that Leo is horrible except for the one feature that makes it amazing (outlines). I find myself wanting to implement outlines in Vim but knowing I never will.

That's a fair assessment too. I don't use Leo for the general-purpose work and new code because it gets in the way when you know what you want to write. But it does work well if you need to learn what a large, spread out body of code is doing. Just realigning the position of code helps to spot some previously hidden repetition.

I would probably use it more if I wrote some scripts to autogen the outlines for entire codebases.

Take a look at Code Browser: http://code-browser.sf.net too - it does outlining in a minimalistic way that I really like.

For those who like leo/literate programming, have a look at code-browser:


More powerful overall. It implements elastic tabstops too! Little unknown gem. good for outlining a book/paper also.


Without downplaying the possible effect of the presented technology, you really should not need to poke through to find stuff or use the mouse to move around...

Vim (or Emacs) along with ctags == awesome. Go to any definition, open file if it was not yet open. Buffer stacks, split windows.

Wow, ctags. I've been a vim user for a while but haven't been using ctags! Now I shall use it forevermore.

I also like using tabs, so I found the following mapping to make tag lookups open in a new tab instead of a new buffer:

  map \gt :tab split<CR>:exec("tag ".expand("<cword>"))<CR>
It has a few kinks, but it works well and I think it complements my \tt, \tn, \tp commands. (Tabnew, tabnext, tabprev.)

I think there's some really interesting stuff here that should be leveraged. What I like best is that it really focuses your mind on the task at hand. You don't spend a lot of time looking through large amounts of code just to find a few things.

I wouldn't like the UI directly as presented, but there's certainly a starting point there.

Really though, don't know what kind of programmer would accept line wrap on code. Urf.

> Really though, don't know what kind of programmer would accept line wrap on code. Urf.

I'd happily accept syntactically- and semantically-aware line wrap, if someone could do it and get it right. Combine that with elastic tabs that actually work, add a standard set of layout rules that gives good results, and provide bullets to shoot anyone who thinks coding standards should be about whether the space goes before or after that `*` when declaring a pointer, and I'm sold. :-)

> my number one complaint, whether it be with eclipse, textmate, vim, emacs, whatever, is the clumsiness of going from one file to another and then back to the original.

Yes, that was something bugged me for a long time so I wrote an Emacs package to fix it. http://breadcrumbemacs.sourceforge.net/

I'm curious about what exactly didn't you like about moving between files in vim?

CTRL-^ just toggles back and forth, with ctags you get one-keystroke movement up and down the function call stack, and you can jump to various buffers with ":b partial_filename", or ":b<number>" if you remember the specific number, or ":blast".

In emacs, going back to the previous file is simply C-x b RET...

As an emacs user, I find this entertaining. You are correct in that once you know how to use emacs it's trivial. However, anyone that doesn't know the emacs key bindings will see that it's "simply hitting something that looks like 4 random keystrokes to any non-emacs user."

That is a very interesting approach - instead of just presenting files, this IDE is already abstracting out some of the semantic structure for you and presenting code based on its relationships. It's meeting you halfway. And it keeps track of things the way you work - by explicitly acknowledging the task structure of the work, it's again meeting you halfway.

This is a really promising start. Very cool.

One extremely annoying bit watching the video is that for an IDE manipulating text files it requires that your hand never leave the mouse. Every single operation it looks like requires that you right click, click to activate, click to drop down, click to open. Even the 'insta-search' box requires a click. Someone should buy a one button mouse and install it on their computer or just take the mouse away completely. A mouse has a place, but it shouldn't be the primary means of interacting with something that is text.

This was my exact impression; I hate leaving the keyboard when I'm writing or reading code. To simulate some of the functionality of codebubble in vim, I :vsp the same file and scroll up/down to the method I want.

I have, however, come to realize that navigation through a large project with keys alone is suboptimal. One typo in a nav command and you have to press at least four or five more keys. With the mouse, you're less likely to make such mistakes and your retry time would also be low. It'd be like trying to browse the web using the keyboard alone... even I, a hardcore vim user, found firefox/vimperator underwhelming to say the least.

What would be awesome is if they made some sort of hybrid superintelligent keyboard where the whole keyboard surface could also act as sort of a multi-touchpad. As a compromise, I've found that the thinkpad-style pointing stick in the middle of the keyboard does a fair job.

There used to be a keyboard like that, called FingerWorks. Was acquired by Apple and was never heard of again. http://en.wikipedia.org/wiki/FingerWorks

FingerWorks technology became the iPhone touchscreen.

This is exactly why I love the "Open File in Project" functionality that exists in some editors/IDEs (e.g., SlickEdit). It lets you type the filename, and does a "fuzzy search" match on it.

Practically, this means that whatever file you think of, you can type any part of its name at any time to get to it. Once I got used to working this way, I stopped using the project tree-view: it's just much slower.

For those of you using Visual Studio, there is an addon called StudioTools that adds this functionality: http://submain.com/products/studiotools.aspx

Highly recommended, they both have a smart open file that lets you start typing a filename, and smart goto, which lets you start typing a class or method name. Makes navigation so much faster!

Vim has a good plugin for this, FuzzyFileFinder. See http://stackoverflow.com/questions/1894614/vim-fuzzyfinder-u... for instructions on how to set it up.

Ctrl-Shift-t for similar behavior for "Open Type" in Eclipse, also Ctrl-o is handy for a popup outline for autocomplete navigation to methods/members (if you have huge bloated Java files for example).

Agreed. The keyboard shortcut in Eclipse (at least in C/C++ mode, not sure if that changes for other languages) is Ctrl-Shift-R.

Good support for keyboard navigation combined with some amount of smartness about the AST can work wonders, though. Most modern Java IDEs do a fair job of this.

The plan9 folks would disagree quite vehemently. We are used to keyboard operations being more efficient for most tasks, but the keyboard operation for "go to the file over there, the one 3 links over semi-related to this one" may be slower than just clicking.

Yes, but there is a big difference between typing part of the file or function name and typing a full path. Search-based semi-global matching is a really fast way to navigate.

Later on in the video they showed some examples of keyboard shortcuts, so there are some in there, but I agree, it's not entirely clear whether or not mouse-free code sessions are possible.

To some extent you'll need mouse-interaction, for dragging things and clearly visual stuff like that (nobody likes to position things with the keyboard, or at least they shouldn't), but they should really do their best to add keyboard hooks to almost everything that they can, definitely.

It may not be useful when you're trying to bang out new modules but for me the majority of my debugging is done by looking through the code... not much typing going on.

How about a SmartNav head tracker plus footpedal switches for the mouse buttons? A Unicomp EnduraPro keyboard with pointer stick would be cheaper, though, and that's not a cheap keyboard.

Programming hasn't been about files for a long time now. That's the reason that we have IDEs in the first place, and why I cringe when people talk about writing code in a text editor.

Any IDE worth its salt will do all the things in that video, except for the little draggable bubbles.

In other words: All the things in that video ... except for the things the video was about.

The video highlighted an annoying feature of Squeak Smalltalk, where you get tiny little views of individual methods in their own window, which seems like a good idea until you actually try to do something complicated using it. It's pretty to watch though.

The cool things there, in my opinion, were the code navigation pieces. Those are the things I actually think work better with tabbed files.

In other news, yikes! I seem to have started an IDE vs. Text Editor flamewar. Sorry about that.

Those bubbles would have been a nightmare if they didn't relate to each other in such a clean way

They have some great grouping features - snapping, colouring, pushing, connections with lines, naming groups.

You get most of the same functionality by saving off Smalltalk images with meaningfully arranged windows. (Yes you can do it with debug sessions too.) But you have to keep track of the relationships yourself. The lines and groupings are genius.

This stuff is awesome. First time I've been this impressed by an IDE outside of Smalltalk, Self, or Symbolics, Lisp.

I also appreciated the fact that it linked called functions to their definition. g] is great in Vim, but it is easy to get a little lost in the navigation stack. Having g] intelligently pop out a new buffer window ala :vsplit would be a great start.

Awesome UX ideas to possibly implement in iPad app.

I cringe when people talk about writing code in a text editor

Yeah, because we have to type M-. to navigate to the related code.

(Also, insert rant about how "UNIX is my IDE".)

Emacs is a text editor in the same way the space shuttle is a vehicle.

Can your emacs editor construct hyperlinked call graphs showing all callers and callees of a given function? Will this call graph generation remain up to date as I edit files?

Can Emacs give me a hyper-linked list of all usages of a given symbol and do it properly(lexical scope, etc.), not just doing a simple symbol search?

Can I edit my code in emacs, have a background compiler compile the file on the fly, and also provide error feedback, hilighting the problem lines with a tagged failure reason and also providing a hyper-linked list in another window as well? Last I checked, the best I could do would be to kick off a compile manually and navigate the errors as a linked list.

How's emacs' refactoring support? Judging by the following stackoverflow post, it's pretty poor: http://stackoverflow.com/questions/673554/how-can-i-refactor....

How's Emacs' keyword completion? Last I checked, it was just a hacky dictionary look-up, whereas an IDE can semantically analyze the source to provide intelligent suggestions.

Even if you can get Vim or Emacs to do some of the above, it usually isn't as easy to use or as useful as an IDE. For instance, I know you can get call graph support in Vim using cctree.vim, but it relies on cscope, which requires refreshing the database manually, is slow to load, and tends to generate incomplete tag sets.

IDE's are, well, better integrated, and so can do many things a lot better than looser environments like Emacs and Vim. Their UI's tend to be a lot more powerful because they are not designed to be run on windowless environments. Personally, for small projects I use Vim and for large projects I use an IDE with a Vim emulation plugin like Netbean's JVI plugin.

> Can your emacs editor construct hyperlinked call graphs showing all callers and callees of a given function? Will this call graph generation remain up to date as I edit files?

Yes. You're looking for Cedet. Can your IDE read my mail?

> Can Emacs give me a hyper-linked list of all usages of a given symbol and do it properly(lexical scope, etc.), not just doing a simple symbol search?

Yes. You're looking for Cedet. Can your IDE integrate with your calendar?

> Can I edit my code in emacs, have a background compiler compile the file on the fly, and also provide error feedback, hilighting the problem lines

Yes. You're looking for `flymake-mode`. Can your IDE email who created the error using version control information?

> How's emacs' refactoring support? Judging by the following stackoverflow post

Stackoverflow gives retarded answers sometimes. The next best suggestion on that page is correct. Cedet is great.

> How's Emacs' keyword completion?

It's fine. You can complete symbols sensitively, and complete filenames or email addresses from anywhere. Having multiple completion systems is very useful. How's your IDE's ability to complete those things?

> Even if you can get Vim or Emacs to do some of the above, it usually isn't as easy to use or as useful as an IDE.

You don't need to be so hostile. Emacs does these things just fine, and has for a long time. Emacs also does my time tracking, outlining, and email. Your IDE won't do any of those things, and you don't expect it to because you think those tasks are best left to other parts of your operating system.

The thing you're missing is that for Emacs users, Emacs is the operating system. I dual boot into Firefox sometimes.

I apologize if people thought I was hostile. I thought I was just making an argument by pointing out several examples of things text editors like Emacs don't normally do that IDE's do well. You've proven me wrong, at least for the case of C/C++. I would still argue that Emacs itself is not an IDE. It's just an editor with a turing-complete scripting engine. However, you could definitely convince me that Emacs+CEDET is an IDE, and I'm glad you pointed it out for me.

I would be interested in seeing similar environments for C#/Java as well as for dynamic languages like ruby/python/php, which IDEs have also been handling very well lately. I've also noticed in general that it's difficult to make an IDE for c/c++ that works better than editors. They compile slowly, The macro system severely complicates quick parsing, C++'s grammar in particular is very difficult to parse and analyze, the languages do not make run-time loading of code easy, and they don't provide much in the way of RTTI. In short, they are not very IDE-friendly languages. Java and C# are the perfect IDE languages, and dynamic languages suffer from not providing enough static information.

> I would still argue that Emacs itself is not an IDE. ... Emacs+CEDET is an IDE. It's just an editor with a turing-complete scripting engine.

This isn't helpful.

First of all, Emacs is an excellent IDE for Lisp and has a built-in debugger, sensitive completion and automatic documentation, while Visual Studio can't do any of those things you thought were important until you install Visual C/C++.

Is Visual Studio "just" a editor with a plugin system?

Why are you so interested in giving emacs such a negative label?

> I would be interested in seeing similar environments for C#/Java as well as for dynamic languages like ruby/python/php, which IDEs have also been handling very well lately.

For python, there's Ropemacs: http://rope.sourceforge.net/ropemacs.html

For perl, there's Sepia: http://cpansearch.perl.org/src/SEANO/Sepia-0.97/Sepia.html

I don't program in C# or Java or Ruby or PHP regularly so I don't know about them off the top of my head.

Where you went wrong was in realizing that Emacs isn't a text-editor. Emacs is a text-based IDE.

Emacs is a scripting environment shell that comes with an editor. It's probably closer in philosophy to one of the old single-user operating systems that microcomputers used to come with.

GUI based IDEs are flexible and have large communities too! > Yes. You're looking for Cedet. Can your IDE read my mail? Yes. At least, it can read my mail. For yours I'd have to know more info. :)

> Can your IDE integrate with your calendar? Yes. > Can your IDE email who created the error using version control information? I don't know. But I'll give it a qualified yes bes cause this is generally handled by the build script, which is IDE-agnostic. > How's emacs' refactoring support? Judging by the following stackoverflow post Stackoverflow gives retarded answers sometimes. The next best suggestion on that page is correct. Cedet is great. > How's Emacs' keyword completion? It's fine. You can complete symbols sensitively, and complete filenames or email addresses from anywhere. Having multiple completion systems is very useful. How's your IDE's ability to complete those things? I don't see anything, so perhaps they don't exist.

But this is silly. We're developers. Using IDEs designed to be extensible. There is very little we couldn't do if we wanted to. Emacs has been around forever, and it has tons of stuff available for it. It also favors a different working style than something more GUI-based, which some prefer and some don't.

There are tons of great tools out there. It's a great time to be a developer. > Even if you can get Vim or Emacs to do some of the above, it usually isn't as easy to use or as useful as an IDE. You don't need to be so hostile. Emacs does these things just fine, and has for a long time. Emacs also does my time tracking, outlining, and email. Your IDE won't do any of those things, and you don't expect it to because you think those tasks are best left to other parts of your operating system. The thing you're missing is that for Emacs users, Emacs is the operating system. I dual boot into Firefox sometimes.

Wow what what a rant.

- I think that different languages (and programmers) suit themselves to different balances of the IDE/Editor combination. I agree with your post, inasmuch as I find writing Java outside of an IDE like Eclipse limits you greatly. It sounds like you write Java a lot.

- OTOH, I find writing C/C++ in Emacs with cscope/etags/make support and some custom keystrokes, and functions for common Unix calls, is about as good as any IDE can get you for those languages (although I admit that I've only had limited C++ IDE experience, using Visual Studio.)

Yes, you have to do custom configuring to get Emacs working well. So, it's a small amount of extra upfront work over Eclipse. The upside is that you get to customize it however you want. In Eclipse I'm still using most of the default configuration, for the simple reason that it works "well enough"

I find writing Erlang in Emacs erlang-mode is fine as well, mostly because the language doesn't encourage me to create the kind of horrible architectural behemoths that you _need_ an IDE to manage.

The difference between Language-oriented and IDE-oriented approaches to programming was laid out really well in a recent blog post that made it to HN, but I can't find it with a quick google - sorry.

As an emacs user, you may find Distel very useful for Erlang. It connects to a running node and leverages the code reflection capabilities in Erlang, so you get who_calls, symbolic debugging, process listing, M-., etc..

Yeah, Distel's one of those things I keep bragging about to my vi-using coworkers, and have yet to actually try out myself. ;).

Thanks for the tip.

Emacs can do whatever you want. If it doesn't, it can be added. In fact, Emacs is an IDE...

It's just not a mouse-based IDE. Mouse clicking makes my hands hurt much faster than using the keyboard. I also find it annoying to switch from mouse<->keyboard, so I don't want a UI that relies on constant mousing.

"Emacs can do whatever you want."

Saying "Emacs can do whatever you want" is like saying "your computer can do anything you want." Sure it can, so long as you're willing to write the code to make it go. But my time is finite; I cannot be bothered to re-build environments that have already been implemented elsewhere.

The difference is just that for your IDE, someone had already written the code necessary to make it do what you want. That's not because the IDE is an IDE and Emacs is Emacs, it's just because someone happened to write that code for Emacs. My point was that this has nothing to do with Emacs vs IDEs.

It's true that some things are lacking, so it's too bad that whoever wrote the code that does your high-level syntactic analysis didn't make it independent enough that it could be used in other places than whatever IDE you were referring to.

In the 30+ years Emacs has been around people have written a huge amount of Emacs Lisp that does pretty much everything you can think of. Almost every feature from other editors and IDEs has been implemented in Emacs. I like Lisp but rarely write very much Emacs Lisp, and when I do it's usually an extension of some code someone else started. There aren't a lot of new ideas and when an Emacs user sees one he implements it for Emacs.

You may say this, but I don't see semantic member or statement completion for any language. I don't see "go to definition" or "find all references." Frankly, although cc-mode is fantastic for indentation and stuff, it offers a small fraction of the features of Eclipse or NetBeans.

Yes, I've used ctags and I've used etags. They tend to be interesting approximations but are never 100% reliable. They don't do a deep sematic analysis of my program. (For example, they don't understand C macros.) They don't update as I type.

The closest I've ever seen has been the "Semantic Bovinator" thingy. I have never managed to get it to run, nor has anybody I've seen try. You experience may be different, of course. (I realize that by posting this I'm inviting a raft of people to post and say "It works for me!" :) )

I don't see "go to definition" or "find all references."

SLIME has this in Emacs for Common Lisp and perhaps other languages that work with SLIME.

I'm on a non-multitasking phone now so you'll have to do the googling yourself.

I said, "Almost every feature ...", and you probably found a few it lacks. I'm not talking in absolutes as that rarely produces an interesting discussion. Thus I don't really see your point, if anything you helped to prove mine, as hundreds or thousands of other features are available out-of-the-box or on Emacs wiki, github, etc. Additionally I don't understand why one needs IDE support for something `grep -Hn` can do, but to each his own.

We might use different technologies. I mostly write Objective-C, Ruby, Python, C, JavaScript, and recently some Objective-J and Erlang. Now and then I write Lisp (CL, Emacs), Scheme, Haskell, x86 assembly, and PHP. The only one of those I don't write in Emacs is Obj-C.

Other editors or IDEs may be better at certain tasks, just as Emacs has unparalleled Lisp support with SLIME. When there is clearly a best tool in one field then people tend to use that tool, if the payoff is worth it. Except for pg and a few others, people generally write Lisp in Emacs. I write Cocoa and Cocoa Touch apps in Xcode and IB. I'm pragmatic about it. But when I tried to use Eclipse for Mojo (webOS) because Palm recommended Eclipse + Mojo plugin, it ended up being more productive for me to extend an existing Mojo mode for Emacs[1] to have even more features[2] than the Eclipse plugin (or any of the others, Komodo, etc). Similarly if I were doing Java I would at least look into IntelliJ IDEA or Eclipse.

[1] http://www.emacswiki.org/emacs/MojoSdk and http://github.com/samsonjs/mojo.el

[2] http://www.webos-internals.org/wiki/Comparison_of_Editors (temporarily down)

"Go to definition" is 'gd' in vim. If vim has it, emacs certainly does.

Perhaps vim and emacs don't do everything you want. But also, perhaps you don't know their capabilities as well as you think you do?

cscope is quite a bit better than ctags, and is insanely fast on modern hardware. It integrates in vim (and probably emacs) and does fully analyze C, including "calls" and "called by" info. It appears to be useful for C++ and Java as well: http://cscope.sourceforge.net/

That said, I use vim for C, but I still use Eclipse for Java and C++/Qt.

Respectfully, I think you're avoiding the main point of the post to which you replied.

Good keyboard navigation in an editor is valuable, and many IDEs have poor support for it. On this we can probably all agree.

But as I read it, the grandparent post was about functionality. Modern IDEs have a level of semantic awareness that generic editors like Emacs don't, at least not without a prohibitive amount of effort to implement it. As a text editor, Emacs is very powerful. As a code editor, it lacks support for even basic semantic analysis, which means such tricks as it does have are naive operations based on text matching. In a world where even entry-level IDEs have support for basic refactoring, auto-completion and code navigation, Emacs is the dinosaur that hasn't seen the asteroid yet: awesome raw power but completely unaware of the bigger picture.

I think it depends on what language you're using at the time. If I'm using a static language I'll give an IDE a try. Otherwise I use Emacs.

" As a code editor, it lacks support for even basic semantic analysis"

Not strictly speaking true: http://cedet.sourceforge.net/semantic.shtml

The flip side of this is: Emacs was invented around the time I was born, and could be used to edit the languages that were available at the time. It can still be used to edit those languages, as well as the hundreds (thousands?) of languages that exist today. I won't be surprised if it's around in 10 or 20 years more, and still able to edit every language under the sun at that point.

Emacs may have a shallower understanding of languages than an IDE, but the breadth of languages it understands is pretty amazing.

Sure, but when you're working on a project that uses only a few languages, specialised tools are always going to be much more effective, and you just update the tools as you update your choice of language(s). Jack of all trades is master of none, as the saying goes.

In many ways I'd love the luxury of writing code in just a few languages. The reality is though, at justin.tv, I've needed to write code in (at least) 7 different languages over the past 2.5 years. I would not have liked to learn 7 different IDEs on top of learning new languages. (We don't tend to gratuitously start using new languages - it's just often a requirement as a project gets more ambitious and wants to do more things and reach more targets).

I sympathise with you on the polylingual tendencies. I'm currently working on something for one client that uses several different programming languages plus the usual web-related stuff all on the same project (and with perfectly legitimate reasons, not just because of historical baggage).

Still, I think this raises an interesting question: is it more beneficial to choose exactly the right language for each project in isolation, or to adopt a "good enough" general purpose language that can be learned in more depth by the development team, and used together with comprehensive library support and a strong and familiar IDE?

They're not. Most of your time is still spent editing text. Or if it isn't, you're not getting enough done. Any deficiencies in semantic understanding (that's what your brain is for, remember?) are made up for by the sheer speed a proficient user (and fast typist) can get out of a good editor. And while you only use one environment at a time, you probably use several over your career. I've used the same environment quite effectively across 4 platform changes. Can the IDE people say that?

Eclipse is a step in the right direction in terms of openness and universality. But the editing experience still sucks. And it's harder to extend and customize than it should be.

There may come a day when there's an IDE that a) has a great editing experience b) is fast, flexible, and universal, and c) offer not just crutches and marginal improvements, but radical, order-of-magnitude improvements to the way we interact with software. It's not today. But the linked research project actually has some promise.

> Most of your time is still spent editing text. Or if it isn't, you're not getting enough done.

Are you sure? I would expect that the process of physically typing in the changes you want to make takes only a fairly small amount of time, certainly much less than understanding the code that will be changed or designing the new part.

However, the typing is just mechanical grunt-work that tends to distract from other areas. If it can be automated with good refactoring tools and the like and so minimize the distraction to the developer's thought process then so much the better.

That is my biggest problem with vim/emacs - they can edit the code well, but they have no real notion of syntax. You can do refactoring based on their lexers and a lot of regex, but it's just not what you really want.

I would really like to see Yi step up at some point and solve the problem here. It's already got proper incremental parsing with a proper syntax tree. When people add advanced language-specific modes to it, it might be the first "proper" refactoring vim/emacs like text-only IDE.

You are right, my comment about mousing referred to the bubbles in the movie, which seems to be all about clicking and dragging. There's no reason any IDE can't put in keyboard shortcuts, but it's going to be hard with the bubbles.

I also find it annoying to switch from mouse<->keyboard, so I don't want a UI that relies on constant keyboarding.

"Emacs can do whatever you want. If it doesn't, it can be added...."

Um no. But if so, then someone better start busting a lisp to get emacs to make cute little bubbles. I'd love to see that.

They'd just be text-based little bubbles...

geocar's response is pretty good, but I am going to disagree on some points.

Hyperlinked call graphs: nope. Never needed it, don't know how to generate them for any language I use. Emacs can't do it, but neither can anything else. Write the code to do the work, and Emacs will support it in about 30 seconds.

All use of a given symbol: same problem. The static analysis for this is Really Hard, and it would provide me with near-zero value.

Background compilation: yup. Supported by pretty much every mode.

Refactoring: I've used Eclipse, but I've never had good luck with its refactoring tools. The automated refactorings are almost what I want, but since exactly what I want is so simple, I just do it manually. If you are renaming your classes everyday and you have to change the name in 1000 files, you have two problems that can't be solved by an IDE.

Keyword completion: excellent. I was using Eclipse today, and there is a noticeable delay between when I press M-/ and when the keyword was completed. I eventually learned to not use that feature, because I can type faster than the auto-completion can "intelligently select" the right keyword.

Emacs is instantaneous, and right as often as anything else. And I can expand things other than symbols, like long words in the documentation, or filenames in string literals, etc.

As for integration, I find Emacs to be quite well integrated for the work I do. A few weeks ago, I was writing a Haskell app for use on Windows. I was really not looking forward to it, until I realized that all the Haskell functionality works perfectly on Windows. I never needed to leave Emacs; I could test my code (interactively or automatically) from the GHCi REPL and I could build binaries and docs with M-x compile. Of course, it's just one keystroke to move to compilation errors (in both cases). If I needed to poke around in a shell, I just used Eshell, which works the same on every platform. Everything you need to do is tightly integrated and very fast.

Working with Perl is just as nice; one keystroke runs the test suite in a nearby eshell, another just runs the tests that pertain to the current file. Anything I want to do is usually one or two keys away, and a shell to do something complicated is just as easy to get to. (For me, C-x C-x switches between the shell and the most-recently-used buffer. Fast!)

Their UI's tend to be a lot more powerful because they are not designed to be run on windowless environments.

Not true. But one thing that's nice about Emacs is that you can run Emacs in the background and connect to it multiple times. If your X session dies, no information is lost. If you are poking around in a shell, you just "emacsclient -t file" (which I alias to "ec file") and you are instantly working with that file in your normal Emacs session.

for large projects I use an IDE with a Vim emulation plugin

That means you are probably unaware of about 90% of Vim's features. I've watched many experienced Vim users try to use various vi emulation plugins for Eclipse, and there is always a lot of cursing involved. They eventually just invoke Eclipse functions from vim instead.

The underlying theme here is that IDEs make tasks that you perform once or twice a week really simple. The "traditional editors" don't do much about that; instead they make the things you do 10,000 times a day really really simple.

(One other thing I notice is that IDE users tend to ignore features that Vim and Emacs have and dismiss them as unnecessary, while Emacs/Vim users steal the good features from IDEs as often as possible.)

In conclusion, you don't know much about Emacs.

I learned to program on vim originally, and I've also worked for over a year on a C team that used vim exclusively. I'd like to think that I know most of its important features, and I know what I'm giving up when I using an emulator. I've also looked into the running vim with headless Eclipse, so I know the tradeoffs there as well.

You're right that I don't know a lot about Emacs. In this thread in particular I've learned about CEDET and flymake-mode, which seem to apply to C/C++ and maybe Java and C# to some extent and add a lot of useful IDE-like features.

Yes, it's equally hard to operate.


I can see grandma not using it, but anyone on this site ought to be able to figure out the basics in short order.

Of course, no one ever truly masters it - I'm always learning cool new things. But that's part of what makes it so great.

But unfortunately, very few IDE users are aware of this.

It's also based on technology that's ancient compared to everything else around it. (Not that ancient is a bad thing, go unix!)

Unrelated but interesting out of 130 space flights 2 resulted in the destruction of the vehicle.

Yeah, dynamic customization and extension is quite antiquated. Modern IDEs should only be customizable by writing 5000 different classes, recompiling, and restarting the IDE. Tools should only be built by dedicated tool-builders, not by your average programmer!

Nice troll though, I will give you that.

IDE's can be neat, but plenty of people seem to use them as crutches to keep on walking through minefields of APIs.

Since the IDE remembers all your parameter sequences and types there is also less incentive for developers of APIs to think ahead of time and plan their interface so it is consistent and easy to remember.

I'd like to have a dollar for every time I've seen a NullPointerException on some line that was constructed by someone who loves the list of methods that automagically pops up for the dot operator:


If only there was some combinator for sequencing computations... then you could write:

   foo >>= bar >>= baz >>= quux
and there would never be a NullPointerException, because the >>= function could react appropriately when null was encountered!

You win at the "Most Subtle Haskell Reference" in this conversation.

Since I don't know haskell, I'll throw out that groovy does this too.


What other languages have this kind of shortcut?

Since coffeescript was mentioned, the Ruby andand library is also frequently mentioned when this comes up. (I only ruby for Rake).

  $ irb
  >> def nil.method_missing *args
  >>   nil   
  >>   end 
  => nil
  >> a = nil
  => nil
  >> a.b.c.d
  => nil

You know what's even better? When someone who writes that style of code (in C++, no less!) knows that one of the intermediate values could be null, so they use a set of macros involving setjmp and longjmp, and trap SIGFPE, all to implement a fragile sort of try/catch for null de-references.

Clever? Insane? Horribly un-portable and prone to breakage depending on compiler, libc, and OS versions? All of the above!

(And yes, I have seen this coding style used in multiple projects at a major corporation. It was a favorite of a coder-turned manager, which means it tended to sneak in on any project he supervised.)

Clever? Insane? Horribly un-portable and prone to breakage depending on compiler, libc, and OS versions? All of the above!

Yeah, you already said it was C++.

And thus, the Maybe monad was born.

Try catching a block that does that is actually less code than a long set of conditionals. Granted it's basically saying:

  if (foo != null) if (bar.bar() != null) if (foo.bar().baz() != null) {
  worked = true;
  if (false == worked ) {/*to do*/}
But, staying on the happy path until you can demo something is often useful. I think the problem is how you transition from demo to production worthy code.

if (foo!=null && (a = foo.bar()) && a != null && ...

a = foo.bar() will always evaluate to true as the assignment shouldn't ever fail. Of course, in compiled languages I'm sure there will need to be a declaration of 'a' but if there is a possibility to reuse temp variables then could work.

However, if you are coding in C/C++ (and to a similar extent Java, there really is no way around it.

This could be an example of why hybrid functional, imperative, and object oriented languages are becoming popular because the programmer can pick the paradigm that most suits the problem.

That's not the same since you are executing the bar method multiple times.

If you really want to get picky, return foo.bar().baz().qux() * 2;

Could become:

  Bar bar = foo.bar();
  if(bar == null) handleBarNull();
  else { 
     Baz baz = bar.baz();
     if(baz == null) handleBazNull();
     else { 
        //(assuming qux is a value)
        return baz.qux() * 2;

That might be the correct way to write that code if the situation is not recoverable.

Say you have

    public int doubleFooBarBazQux(Foo foo) {
      return foo.bar().baz().qux() * 2;
That might throw a NPE, but what's the alternative?

I typed this into Eclipse, and it's super-awesome-excellent auto-code-writer decided that it should be:

   public int doubleFooBarBazQux(Foo foo) throws NullPointerException {
     try {
        return foo.bar().baz().qux() * 2;
     catch(NullPointerException e){
        throw new NullPointerException(e.getMessage());
If only there was a right-click option for "improve quality"...

Yeah, the generated code is asinine, but what would you prefer? "Improve quality" in this case would just leave out the try/catch altogether. Is there another behavior that would be better, given that we know nothing about foo, bar, baz, or qux?

You'd be starting the 'Pohl foundation for old programmers' from the proceeds before long, I gather.

Code like that is really common, and, unfortunately, so are blank 'catch' sections.

Meh .. by the time Eclipse boots up, and by the time you load your project in Eclipse, I'm already in-the-flow with tickets read / 5 files open / the project running on my localhost.

Besides, it's not like it's a primitive environment ... when I want some API discovery/learning or when I want to do some debugging (or both) ... I open up an interactive shell.

I have Textmate-like snippets setup in my Emacs, and for CRUD-stuff I bet I'm ten times more efficient than you (and adding new snippets is a piece of cake ... not to mention that we share them company wide because they are text-files in our SVN).

When wanting "rename" refactoring, commands with grep/find/sed are already hardwired in my brain.

And nothing beats editors like Vim/Emacs on pure text-editing efficiency. Also, good luck using your favorite IDE when trying out a new language ;)

So you can cringe all you want, some of us are quite happy with just text-editors.

With those great IDE, you can do everything, but not editing effectivly :p

I've been using C# and thus Visual Studio Express over my usual python/vi setup, and Visual Studio practically forces the line of reasoning that results in code bubbles on you. It has a good start on navigation, but I'm finding setting up split panes in Visual Studio (same file or not) is quite cumbersome and not designed for quick edits. I can quickly put two functions side-by-side in vim, but the setup cost in Visual Studio feels much higher.

VS2010 made some improvements to this (RC is available here: http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx). Now you can tear off tabs from the main window and place them on another screen, or tile them on the same screen. Also, now there's functionality to split a file into two viewing panes.

It's odd that it's so rare in software to find window widgets that push each other out of the way instead of overlapping.

I'm thinking of the gazillion pallettes in Adobe CS that always occlude each other. You'd think they'd have figured that out by now.

That's why I prefer Wmii, Ion2 and similar window managers. They really manage my windows, ensuring that they don't overlap and use the screen effectively.

In contrast, most other window managers just enable you to fiddle with the windows yourself, and that's all they do for you. You keep moving and resizing them, one by one, steadily. That's very annoying.

(In fact, I don't even have a desktop image, because most of the time, the desktop isn't visible anyway. I don't want to look at my desktop, I want to use that space for the application I'm working with!)

Visual Studio sort of does this. When you drag one pane over another, the default is to have the panes be tiled or tabbed (depending on where you drag it). It's all very intuitive too, with the arrows to guide you through what you're doing. Visual Studio's window management is totally awesome and one of my favorite features.

Nice. When do you suppose they will support editing code? You know, features we've learned to expect from IntelliJ and Eclipse?

I don't get it? I edit a lot of code in it?

Does it work well with multiple monitors yet?

Visual Studio 2010 RC just came out this week and it touts multiple monitor support and other very shiny features. The official release is on March 22; they're not called M$ for nothing =P http://www.microsoft.com/visualstudio/en-us/products/2010/de... [microsoft.com]

I was watching a channel9 video where one of the devs claimed multiple-monitor support in 2010 was improved. I'm not sure how, or even what needs improving for that matter (I use VS across two monitors.)

VS2010 let you have 2 files open. In VS2008 you cannot have 2 sources code file open in each of your screen. Only one (of course you can put other windows to other screen but not multiple code windows).

Oh! I've never tried that. That explains it. I only put panels on my 2nd monitor.

i end up running multiple instances typically, as opposed to a single one over multiple monitors.

I never even thought of that. Any examples of software that does this?

Any tiling window manager will have a mode, usually the default, where no windows will be occluded. Instead, all screen space is divided among them according to some algorithm.


Indeed. Remember that overlapping windows was a tech demo to show how powerful the graphics processing was. It was never intended to actually be a production feature.

Thank god for tiling window managers. Xmonad, we salute you. You are the best.

Wmii and Ion2 are also very nice tiling window managers.

Pallets have been able to snap together to the side of the screen since at least CS3, though I only had issues with < CS1 just after changing main monitor resolution...

I see how useful it could be, but I wonder if it would be good for me. So far I've tried to run in exactly the opposite direction:

1. not using mouse at all

2. concentrating on what needs to be done to what object... not where

I'm a heavy Vim user, so I'm relying on ctags / incremental searching / positions stack for a lot of work. This goes exactly the other way - click your way through to the point you want to get to.

On the other hand, I'd probably prefer to fix bugs in this environment instead of in Vim, because it gives a lot more context and freedom. It looks good for... let's say "exploratory programming".

Maybe it's time to think 2 different IDEs - for "writing code" and for "modifying code"?

But to your #2 - that seems to me to be exactly what this IDE is doing. That's the way I see it, anyway.

It's better than normal eclipse for sure - you get the arrow link between related methods, etc.

What I meant is that in Vim I go to a name in ctags. That's what happens - whether I'm in the same file, or different, or I looked at that tag before. Type in tag name -> go - that's all that happens.

With code bubbles, I could have the bubble already open, but just off the screen. Or maybe it's open in another dependency. Or maybe it's not open at all. I have to look at the screen, localise the bubble, make a decision and then do the action (either click existing bubble, or open a new one). Of course it's too early to criticise it, without testing beforehand. But it definitely got my attention, as something I tried to avoid. Having one good way to access stuff == less thinking.

Let's say that Vim is stateless, but bubbles are stateful :)

It should be possible to add equivalent keyboard shortcuts to Code Bubbles, so that finding a nearby bubble could be accomplished by ESC,/tagname or something.

I would agree. This seems to be exactly what this IDE is for. I wouldn't dare do any serious code-creating in an environment where I have to do that many key-clicks, but if I'm tracing through code and trying to find exactly where a bug is, I could either open about a zillion split panes in emacs/Netbeans, or I could have all the relevant code open at once, and only the relevant code open. That is where this IDE overlay(?) (it's part of Eclipse, right?) shines.

The thing that makes Vim Vim is just that its modal and has keyboard access for everything. You can get as fast on this as Vim if the right model is applied to the keyboard. Just look at Vimperator.

Guys, we need a better way for exploring big open source projects (like Android, for example), preferably online. Google Code Search is pretty good, but I think there is so much more that can be done.

The most striking thing is how few people here have addressed this point. Everyone seems to be living in a fantasy land where "learning APIs" is as hairy as it gets. I've messed with portions of the Linux Kernel, Chromium, Mozilla, and Coda Filesystem codebases. In each occasion, tools like code-search (provided by lxr.linux.no, mxr.mozilla.org, Google COde, and even `find . | xargs grep`) have been invaluable in getting anything done.

Chromium, Mozilla, and the Linux Kernel were unpleasant, but manageable with the existing tools, because of the incredibly strict guidelines imposed upon contributors as far as code style and other things. On the flip side, the Coda Filesystem, which has grown as the result of many relatively disjoint Ph.D. research projects) requires a whole lot of help and handholding from the guys who have put a decade into it already. I can only imagine private code bases being a LOT worse.

An IDE that makes semantic relationships more obvious to the new guys would do a lot to ramp new people up faster and would really be a huge benefit from a community standpoint as well as just being generally helpful to existing developers.

That said, this is a good first step, and not necessarily perfect. It kind of looks like a toy now, so managing screen real-estate better would be the next big step, I think.

Do you find that "find . | xargs grep" is more useful than "grep -HnR" in some way?

I recommend setting up cscope for hacking the kernel. I haven't done any kernel hacking for a while, but when I did I found cscope (and vim+cscope) very helpful. Since it's database-driven and designed to run on systems from the 80s, it's still extremely fast.

This is awesome!

I'm kind of a weird mixed-bread developer. I'm now a heavy Vim user, but was once a heavy IntelliJ IDEA user. I'm also currently a heavy Resharper user at work. I understand the importance of really solid, visual tools, but I also understand the importance of simplicity and flexibility. There is a middle ground, I know it.

As an aside, I think that the GUI toolkit confusion is one of the biggest blockers to this sort of innovation. Terminal emulation is just the lowest common denominator. HTML/JS/CSS is the closest thing we have towards a portable, successful GUI toolkit. And it's simply still not quite ready to fight the advanced desktop graphics battle necessary for this sort of new bread of tools.

2 things

1. /Way/ too much mouse-action for coding in my opinion

2. I saw no mention of the best killer feature I can see for this, which is allowing refactoring and restructuring of code by extract bubbles, moving them around, popping bubbles... I've been wanting to perform refactorings in a visible fashion for quite some time now.

nice. i can see myself using this for django projects (a bubble for the urls.py, another for the view and another for the template)

Your wish might come true (author of pfaide(pfaide.com) here). I'm so intrigued by the idea I wanna drop everything at hand and take a grab at this ;)

I'm thinking this won't work so well for dynamic languages. The demo video is using a Java project.

Get any of the better Lisp or Smalltalk environments - they will do all that and more.

Because not declaring the type of variables makes code not work with bubbles?

I think that because not having typing information makes it more difficult for the IDE to help you out.

Slime makes a lot of this navigation possible; I don't think dynamicness has anything to do with it.

It seems like what would be hard is dot-oriented method invocation ala python and ruby. There's been some work at figuring that out using static code analysis, but it's a lot less ready.

The demo is relying heavily on code navigation features that are only available to static language IDEs such as "Open Declaration", "Find All References", code completion, navigating object hierarchies, code outlines, inline docs, and other fancy code traversal techniques.

Take a look at Squeak. The Smalltalk folks have been doing this for a long time with the GUI utilities. SLIME is another dynamic environment that knows and can tell You much about itself.

This information comes from actually running the code.

Not that this is a bad thing, though. People seem really afraid of having the code they just wrote be executed, but I think this is an unfounded fear. And, as SLIME shows, you get great information from running the code; much better than mere static analysis.

I was about to ask, "Why don't they just run the code, and provide something like reverse debugging or VM state snapshots to explore different code paths?" but it seems that's already been covered.

These things are possible in dynamic languages with static analysis, it's just not as easy. (Oh, and if you write code that's unreadable, then the static analysis fails. But most people don't do that.)

Then where are the Python/Ruby/PHP/Perl IDEs with these features?

It's hard, and people are lazy. Getting this information out of Java is Really Really Easy, so it's been done.

Personally, I have all the pieces together for doing this with Perl, but I have not put it together into anything coherent because it's largely useless. An occasionally-updated tags table is really all I need, so I can't get motivated to make "Eclipse for Perl".

Maybe someone else that sees the value in these tools will do it. Let me know what information you're interested in, and I will show you how to implement it.

For Python Netbeans/WingIDE/PyCharm do this good enough.

Reminds me of Smalltalk...

Specifically Squeak... I wonder if it is built with Squeak?

Eclipse was originally built in smalltalk…

No, Eclipse.

It is an Eclipse plugin, yes, but it could still be written in Squeak?

The original version of eclipse was written in smalltalk…

Hmmm. I assume you're referring to VisualAge. It's a bit of a stretch to call that "the original version of Eclipse". A predecessor, yes - but the only thing the two have in common is that they were both IDEs.

Note: requires monitor with 2560 x 1600 resolution.

1920x1200, actually. And that is not too uncommon; I've had my monitor at home for 5 years and it's that resolution.

I'd highly recommend any serious programmer with a screen smaller than 1920x1200, to upgrade... and get two of them while they're at it. After some time with that setup, it becomes painful to get back to something smaller.

I've tried 3 screens (in: square, wide, square configuration) for a while. I wouldn't say no, if anyone gave me that again, but I didn't notice any significant improvement over 2 screens.

I've written lots of good code on my 9" eeepc, and didn't really hate the experience that much. Conversely, I have 2 19" monitors at work, and don't really find it productive at all. (We are asking for 2x 30", which should help.)

The difference is that I use Linux/xmonad on my eeepc, and Windows XP at work. A good window manager will make your computing experience 1000x more enjoyable than a new monitor will.

(As I mentioned above, I have a 24" monitor at home and use xmonad with that. Needless to say, that is the best environment of the three.)

[edit: fixed link]

This approach might be conducive to RFS 5: Development on Handhelds (http://ycombinator.com/rfs5.html).

Bubbles - smaller chunks of information more suitable for a small display

Arranged in a spatial layout - fits with the spatial, panning style of the iPhone UI.

The main benefit of this IDE, compared to terminal stalwarts vim and emacs, is the effective use of a large, high-resolution screen. The color-coding and context grouping is really slick; IMO vim gets a bit visually confusing if you split windows more than twice.

My main gripe about this system would be the normal one of moving back and forth between the keyboard and mouse. Also I wonder how sluggish it gets if you have multiple workspaces and debugger sessions open.

The alt+drag static call graph was another cool feature.

Ultimately, the best tool is the one you know best. Any IDE will have a very tough time competing with 30-odd years of developers perfecting all the small stuff in vim and emacs.

Wow, I've been dreaming of being able to do exactly this for a long time, but I didn't think I'd ever see it implemented.

I have an unfinished project where I was attempting something similar - I am going to throw it up on google code now and I guess put up a demo in case anyone is interested in the code. It's all just simple javascript/jquery proof of concept. You can see it here http://www.churchofturing.com/dragedit/dragedit.html and google code is http://dragedit.googlecode.com

Nice stuff! I just played around with it for a bit and it seems you have the basis of something interesting there, now for an application!

thanks - I am always hesitant to release projects where I know it is only a quarter of the way there. But what good does it do just having it sit on my hard drive? hah. There are some key bindings working ctrl+space creates a new editing pane, ctrl+arrow keys should let you move between panes - however I wrote this so long ago that I did not know ctrl+space brings up a menu on mac. hah. The other key bindings do not seem to work on my mac either. If I get some time this weekend I think I will polish this up, get saving/loading/exporting working etc.

I've had this idea for a while and maybe this can be a part of implementing it:

A website where programmers can contribute 'widgets' which can be mashed together to create applications. Widgets would be written in python, and would have access to a bunch of underlying services and to other widgets.

You'd use an interface like what you have here as the 'ide' to create the bits and pieces of code that go in to making a component, and then a similar interface to combine components in to working websites.

The end result would be hosted on the same service, either using your own URL or using a subdomain of the service.

It sounds like a large amount of work though, to get that up and running, especially the security angle is a complicated one.

This is the IDE I didn't know I was missing. Navigating around the code is undoubtedly the highest overhead task I do. This IDE seems like it fixes that problem.

The smart tiling and interaction of "bubbles", beyond just IDE-centric actions, most intrigued me. I'm reminded, of all things, of playing with the Acme editor. The overarching task bar with nameable, savable, and shareable sessions was nice, too.

Such things strike me as generalizable beyond just IDEs.

Interesting idea. Drawing a line between two procedures to find the shortest call path between them could save time navigating an unfamiliar codebase.

Edit: Also interesting - storing an old debug session with state and being able to visually compare that with a debug session made after code changes.

Regardless of anyone's opinions of this particular IDE / workflow it's been clear for a while that the future of developer tools will almost certainly include:

- IDEs that take advantage of greater knowledge of code than just a simple organization of text files (e.g. reflection, call stacks, static and dynamic analysis, etc.)

- Tying bug-tracking, automated testing, and source control together in a coherent way.

- Generally merging the developer workflow into a seamless experience instead of a disjoint series of steps across N sets of distinct tools.

Already we're seeing plenty of movement in this direction, with things like visual studio's intellisense, more in-IDE unit test tools, and the plethora of refactoring tools out there.

The days of IDEs that do little more than compile and keep track of collections of files for you are numbered.

I thought this was a really interesting idea. In uni (college) I became pretty dependent on Mind Maps (using FreeMind) for planning essays. Laying all the relevant concepts and relationships out visually worked really well for me.

From that angle, I think anything that helps programmers visualize the structure of their software is a good thing. I think any half-decent programmer is good at maintaining these kind of relationship graphs in their head, anyhow. But that's no reason why tooling can't make that even better. There's potential for a programmer to visualise the structure of their program, beyond what they can hold in their head.

I also like that this idea encourages good overall design, short logically arranged methods, and neatly compartmentalises "workspaces" in a visual way.

I have a few criticisms, though:

- Nowhere near enough keyboard-driving for my liking. :).

- It'd be great if zooming out could transform the representation a bit, so instead of ant-size pieces of code the user could work with only the higher-level abstractions between the bubbles they've laid out. I see this happening from the "groups" and "workspaces", but not being inferred from the code itself.

- Is there some other way to show bubbles that were opened independently, but are actually related in the code? Apart from drawing a specific line and seeing the call graph (which is neat, btw.)

- I'm concerned about what happens when a single workspace gets bigger than a single window.

- What happens when design (as it often needs to) breaks through neatly defined abstractions, and lines start needing to be drawn all over the place. Can Code Bubbles represent this without driving the programmer insane, and (also) can it represent this in a way which encourages the programmer to see better ways to refactor?

- Arbitrary areas and names, in a flat namespace on a flat 2D plane, with no relationships between them, is nice and simple. However, it seems like it would limit you when working with big projects and lots of different, but related, spaces.

This is very interesting. To me it looks like it creates a hybrid interface experience in between traditional programming and visual programming languages such as Prograph.


Its refreshing to see new ideas being implemented well. What makes this particularly interesting is the panning desktop metaphor (which seems to be getting more and more popular) and is quite appropriate for multi-touch screens (think ipad).

It would be most interesting to see this idea extended in this manner, and possibly alter it so coding can be done differently. One possible way might be to have a collection of functions available, then link them together to create new functions. In most cases, this could be done using relatively few commands, so could be done on a touch-only screen.

I love Eclipse for enabling stuff like this.

What I like about Bubbles is that it manages to visualize the program more like how I think graphically. I've never been a text programmer. I see the code in a visual way in my head, far from typing on a keyboard. About the opposite of Emacs/Vim. I seldom remembers the names of classes and methods, but where they are in a code landscape where the code almost have different kind of colours and textures. Negative space and beautifulness of code is important to me, and it has nothing to do with the text itself. The less I need to use a keyboard the better.

This reminds me of the software that comes with the lego robotics sets.

Yeah. good for learning how to program, but silly afterwards.

Maybe dumb Microsoft MDI concept will stop to haunt us now. Each IDE for last 15 years has same set of functions, and they are vastly insufficient. Shit that happens in your typical program is really much harder to observe then it should be.

Program is interconnected mutating tree. Why the hell we are looking at its latest snapshot through set of flat files showing encoded parts of these trees grouped chaotically?

On the other hand, why anyone who tries to actually show trees forces me to enter 2+(2*5) as five nodes without using my keyboard?

Neat concept, the problem I see immediately as it assumes I am coding in Java. This would be fine if you worked in only one language. I work in several languages within an average day.

Hopefully the interface points are well-defined enough that you wouldn't need a view like this over the entire set of projects.

Reminds me of Squeak, first, because of the white->blue gradients. Second, this is like the Canon Cat/Archy (Raskin interfaces), where you have tons of room, and you just demarcate segments you want to look at.

What was striking for me was the "capture my workspace and send in email" feature. Couple this with the Omniscient Debugger (http://www.lambdacs.com/debugger/), and you've got me sold. Oh, but I'm a Ruby programmer.

I've wondered for a long time why debuggers don't all have a "back" feature. Small controls on what's saved / how much memory can be used seem to me to be easy to add to any debugger. Just save memory states and rewind, the whole thing can be implemented with a stack. If someone knows a good reason, I'd be interested.

You've ended up adding more things for me to read / look into. I love programming... there's no way I can keep up with it all, so there's always something interesting.

GDB 7 has supported going in reverse for few months now: http://www.gnu.org/software/gdb/news/reversible.html

Whoa. This looks kind of amazing! It's almost like an evolution of the Smalltalk browser approach, but in a direction I would not have expected. I think I like it!

Hopefully this will make working on the Gridspy project easier. Typically I have 3 IDEs open - my Firmware IDE, Eclipse + Visual Studio.

In Eclipse I am editing a twisted project (usually 3 different files at once but only 2 methods from each) and a Django project (probably about 10 files to juggle there).

In Visual studio, I tend to have another 10 files open (the firmware builds to Win32 too).

God it would be awesome to have all that on one monitor in little bubbles.

I really like this, although is views seem to lend themselves very much to functional programming as the bubbles in the demo only show the methods of a class and obtaining a view of a class as a whole does not seem to be inherent to the IDE. With functional programming you only care about the functions so maybe that would be an ideal target for this IDE

There are a LOT of good ideas in there. Will definitely have to watch / possibly extend this...

* saves for later

Did this vaguely remind anyone else of Hugh Jackman's virus writing "IDE" in Swordfish: http://www.youtube.com/watch?v=AUJFOuHIS4Q

And on that note, how come all academic screencasts are so monotonous?

This is one of the first things I've seen—for any language—that could be more useful and powerful than Smalltalk environments. The most useful feature IMHO is the chaining but having find references and the like in there is extremely attractive.

I'd like to see a mini map view, like in StarCraft, where you could select an area to instantly pan to that set of bubbles.

edit: ohh the top bar acts like that. Kinda cool. Very biased against vertical scrolling, which might be bad for certain kinds of files.

It has a mini map on the top of the screen.

Looks good. It's so rare to see any real innovation in development IDEs. I also like the idea of colour coding bubbles or attaching icons to them, and being able to arrange them in chronological order.

Looks pretty cool actually. There are often times when I need to see a little bit of code from a number of files, to trace what's happening. Anyone care to make an emacs mode for this?:-)

Now if somebody just plugged this into Emacs, or just got me an extensible (Lisp-based) bubble system with SLIME so that I can connect to a Clojure environment and inspect my code…

For everyone who has worked on a project with multiple directories, files, people and technology this looks really promising (if not awesome).

Looks like something that should be implemented as a plugin for Eclipse or Visual Studio. Kind of interesting, though.

I guess that is why it is an eclipse plugin.

Pity it doesn't interoperate with all eclipse-compatible languages (just yet). I'd love to use it to work with Python.

I'm sure there's an emacs mode for that ;)

this sort of thing would be awesome for boosting developer productivity if they have 3 24" monitors ... nowadays it's quite affordable to buy 3 24" monitors (at ~$300 a piece), and when they're all linked-up horizontally, an IDE like this one could truly kick butt

Seems the next logical progression of the LXR. I'd love to see the linux kernel in this.

Very cool. This is closer to how I envision my ideal IDE.

I don't think there's any reason to put the default video embed at 1080p. Just wasted a lot of my bandwidth, honestly; I didn't make it full-screen or anything and would have been fine with 360/480p

It's great they put it up that way as that seems to be the native resolution the demo was recorded at. That way, you get the optimum display quality of the text. Since most of the screen stays the same much of the time, it isn't that much of a bandwidth waster after all even at the higher resolution.

I think they're trying to reduce the impact of the superhuman levels of concentration displayed by the uberhackers. I don't like it.

I disagree, they're augmenting the current impact of a super-human level of concentration displayed by an "uberhacker" by giving the fruits of that capacity to everyone. Automating a super-human level of concentration in one part of the development process will free up brain cycles for use elsewhere. The best developers won't instantly cease to be the best developers because of a mind-mapping IDE.

The second sentence of my earlier post was my idea of comedy.

now apple should sue them - they inveted it first - no doubt ;)

C-x 2 C-x 3

Without screenshots / explanation / some more content, you're not very informative... (edit: I know it's emacs, but without explanations it's like saying C-x M-c M-butterflies)

Emacs ism

First split the screen horizontally, then split the current panel vertically.

Not the same thing, at all.

Alright, I confess to being a little glib; however, I'm merely suggesting another way that people already commonly "see many fragments of code (or other information) at once without having to navigate back and forth."'

It's not nearly as slick as code bubbles, but it does work for many of the use cases suggested above.

Slickness is an underrated quality of good user interfaces.

Indeed, programming is more about conceptual understanding than typing speed. I see bubbles as being more useful for understanding how an entire code base fits together than emacs buffers and windows.

Though, if we had a desktop that is infinitely expandable, then emacs, and any other windowed application for that matter, could be put to the same use. Really, bubbles is best as a general workflow paradigm, of which programming is a sub problem.

... by users that have managed to master entirely text-based editors like emacs or vi to a degree that allows them to still be as productive as their brethren who moved on to slicker IDEs :)

Not even kind of the same thing.

But very close (conceptually) to `find-tag-other-window`, except with fewer pretty colors.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact