Code Bubbles — Rethinking the IDE's User Interface

kang327 writes "As Java developers we are used to the familiar file-based user interface that is used by all of the major IDEs. A team at Brown University has developed an IDE for Java called Code Bubbles that makes a fairly radical departure from current IDEs — it is based on fragments instead of files. The idea is that you can see many different pieces of code at once. Fragments can form groups, have automatic layout assistance, wrap long lines based on syntax, and exist in a virtual workspace that you can pan. A video shows reading and editing code, opening different kinds of info such as Javadocs, bug reports and notes, annotating and sharing workspaces, and debugging with bubbles. They report on several user studies that show the system increases performance for the tasks studied, and also that professional developers were enthusiastic about using it. There is also a Beta that you can sign up for."

Comments

Sounds like Smalltalk's code browser.

[Anonymous Coward]

Welcome to the 1970s. Squeak is one of the better implementations these days.

Re:Sounds like Smalltalk's code browser.

[TheRaven64]

Indeed, welcome to the '70s, but the Newspeak code browser these days is a lot nicer than Squeak / Pharo's approach.

Re:Sounds like Smalltalk's code browser.

[Anonymous Coward]

I don't know about smalltalk, but there's a family resemblance -- it reminds me a bit of Self with the Kansas desktop. It's not bad, but I really do prefer browsing with trees and keyboard controlled "quick open" popups. I'm just not productive with mouse-centric interfaces.

Re:Sounds like Smalltalk's code browser.

[shutdown -p now]

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

Re:Sounds like Smalltalk's code browser.

[Anonymous Coward]

I prefer the Cincom Smalltalk flavor personally... more utilitarian, but also more robust.

http://www.cincomsmalltalk.com/main/products/visualworks/visualworks-overview/

Average method size of just over 6 lines.

Deja vu

[ascari]

It looks like those (incredibly crappy) multi window IDEs of ten years ago. The name is cute though.

Re:Deja vu

[Anonymous Coward]

Sounds like APL (1960s) and the earliest version of MS-DOS (1980s): "workspace" == "ALL your files in a single directory".

Can I version-control bubbles (or the code fragments associated with them)? No, I didn't think so.

Plus, you're still working in Java.

But if I did write in Java, I'd totally sign up for the beta! I'd impress the hell out of my boss with all the cool-looking, click-fucking-around.

Re:Deja vu

[K. S. Kyosuke]

Can I version-control bubbles (or the code fragments associated with them)? No, I didn't think so.

What prevents you from doing so? Since when do diffs and versions work only with small files and not with large ones?

Re:Deja vu

[ubersoldat2k7]

It's built on top of Eclipse, so all other tools like version control should work. Anyway, I do work with Java and yes I did sign up to the Beta. I don't see anywhere about license or source code. Let's hope when this guy is done with his thesis releases the beast.

bubbles = isolation

[caffeinemessiah]

Initially, the idea of "code bubbles" sounds intuitive -- isolated, self-contained, easily testable pieces of code, with well-defined inputs and outputs. Then you could build a complex program by stringing these bubbles together (in theory, anyway).

Then TFS mentions something as banal as "wrapping long lines of code"....and my bubble bursts.

Re:bubbles = isolation

[Anonymous Coward]

Initially, the idea of "code bubbles" sounds intuitive -- isolated, self-contained, easily testable pieces of code, with well-defined inputs and outputs. Then you could build a complex program by stringing these bubbles together (in theory, anyway).

Perhaps we could call such a pieces of code "functions" instead.

Re:bubbles = isolation

[ottothecow]

I like the idea at least as I understand it from the summary.

Might just be more handy as a display mode than an entire paradigm but I can see how it would be nice if you could display functions together from different files.

If you are working on one function that is in file3.c that has to interact with functions in file7.c and file3.c, why not be able to display them all as if they are in the same file (when they will eventually get compiled together anyways). The code already exists in most IDEs to collapse functions, so why not extend that to being able to mash up all the collapsed functions from every file. Then you can display the ones you want to see as if they were all in the same file.

Keeping stuff in separate files and including them is a good organization technique and helps with multiple people working on a project (and you can substitute different files for different platforms, etc.) but I can see where this would be useful if instead of flipping between 5 open files, the IDE could display just the portions you need. Bonus points if the IDE can do this automatically in a semi intelligent manner--like show the collapsed version of functions that might be relevant based on some criteria and then allow you to expand them if you like.

Re:bubbles = isolation

[l3v1]

isolated, self-contained, easily testable pieces of code

And I'd add small and short to that list. There's no way this bubble concept would be useable with code fragments longer than a few lines, and even those need to be short since wrapping would destroy the usability of the whole thing. Also, in the sample video, when they had to scroll the screen because of the many bubbles, well, there it became a lost cause for me. Realistically, from code dealing with more than helloworlds that I've seen and written, this thing would be a real dealbreaker. I can't think how so much fragmentation can help you in the long run. Having self-contained small pieces of code that do one thing - that is useful -, I'd say those are hard to find. Managing tens of thousands of lines of code this way, I'd go crazy very quickly.

Re:bubbles = isolation

[Galestar]

Then TFS mentions something as banal as "wrapping long lines of code"....and my bubble bursts.

What's wrong with that? Manually wrapping long lines of code is only done to prevent having to scroll horizontally while reading the code. These days, the number of characters that can fit in the code window can differ significantly between devs. I use a 28" widescreen at 1900x1200 - I can fit a hell of a lot more characters in my code window than can a dev with 19" non-wide with w/e low resolution he decides to use. With manual wrapping, if I write the code, he has to scroll. If he writes the code, I do not get to take advantage of my added screen real-estate. As long as the automatic wrapping has a half-decent indentation style, I would love to see this in any IDE.

Re:bubbles = isolation

[zero0ne]

But in 6 years we will have the AMD holodeck.

(my vision is like the computer room the kid in "Gamer" had)

Imagine coding on a screen like that with this IDE...

Re:bubbles = isolation

[phantomfive]

It is a good start of an idea. The problem with coding is that the logical structure isn't really related to the visual structure of code on a page. Logically, with code, you have a bunch of bubbles with lines connecting them together in various ways. You can't really see this structure visually, if you want to see how things are linked together you have to read the code and figure out what calls what (or use one of the various search mechanisms, but that still boils down to reading). So the idea of being able to see the links between different parts of your code is a good one. A good portion of my comments are dedicated to helping future programmers understand the overall structure of my code, so being able to visualize it will make that much easier.

You can always automatically generate a UML map, but the problem is a UML map doesn't show which links are more important, and which groupings of code are most important. This is something you have to use comments for. If this tool could somehow do that, and could be saved in a format that could be shared with other programmers, it would be very useful. Otherwise it is not too much more efficient than the techniques I've developed for dealing with regular text files.

A similar situation is this: when I first learned to use emacs, I thought auto-indent was the most amazing thing ever. It solved one of the major problems of my coding life, indentation (obviously I was not a very experienced programmer at the time). Emacs made it easy to re-indent a section if I forgot the brace on my 'for' loop. When I read a review by a guy who didn't like emacs for totally different reasons, I couldn't understand why he was ignoring the obvious greatnesses of auto-indent. Now I realize that actually he had developed technique for dealing with indentation, so it really wasn't a problem to him like it was to me. That is how new tools often are.

Re:bubbles = isolation

[sirius_bbr]

I think this kind of IDE would be very usefull during code-maintenance, especially when the code you maintain is written by you (which is often the case).

When developing new code, the bubble-concept could be too confusing, because it seems to hide the overall structure of the code.
But during maintenance, when hunting bugs, I often don't want to see the whole picture (and hence the whole complexity), but am much more interested in smaller sections of a program, and the relations between them. The bubble concept would really help.

Re:bubbles = isolation

[bishiraver]

Typically, the only time you have (or should have) lines that cannot be intuitively line-broken and indented is if you're writing mindfuckingly verbose code like

SuperSpaceMapStrategyFactory<SubLightIonEngineTypeManager<MediumPoweredIonEngine>> marsRocketEnterplanetaryEngine = new SuperSpaceMapStrategyFactory<SubLightIonEngineTypeManager<MediumPoweredIonEngine>>(new RocketEnginePattern(engineDiameter,engineForce));

Which, I suppose, you only really get if you use Java anyway. Otherwise 80 columns is more than enough space for anyone.

Re:bubbles = isolation

[guruevi]

Congratulations, you've just defined Objective-C/Smalltalk/PHP Classes & Functions and probably a host of other so-called 'object-oriented' languages.

This IDE just seems to make OO simpler by diagramming your program ala Visio instead of coding the interactions.

Re:bubbles = isolation

[suomynonAyletamitlU]

I agree that their effort shouldn't be based on the "make it look good with rounded bubbles that you can move anywhere on the screen, because THAT is what programmers lack" that the video shows. That's retarded.

However, my first thought when I read the title of this was that, for example when debugging, the IDE would put together a fake "file" for your editing purposes that contains all the relevant functions / code segments, with simple breaks that showed where one file ended and the next started. This might even be multi-column, with each "bubble" being movable between columns, so that you could compare side-by-side.

You could of course switch tabs to the actual files if you needed to, for editing C macros or things that seem unrelated to the IDE, and it wouldn't be hard to have it jump to the line you already have selected in the "bubble" view.

Re:bubbles = isolation

[ianare]

Yes, what if there was a "isolated, self-contained, easily testable pieces of code, with well-defined inputs and outputs", many of which could be assembled together to form a complete application, but modular enough to stand on their own and be used in other applications. For ease of use we could put these things, 'objects' if you will, into a single container, like a single 'file' in a 'folder' of many such 'objects' for example. This would simplify access and editing.

Nah, the idea could never work. How would one know how and where these things interact with each other? We would need to create a new language from the ground up that makes use of them, in order to properly track their behavior. Then find a way of showing that interaction graphically to the programmer. The shear scale of such an endeavor makes it one of those pie-in-the-sky concepts.

OK, now back to work : I'm building a multithreaded back-end business software program using Vi.

Re:bubbles = isolation

[Anonymous Coward]

Except a bubble (as I understand it) spans multiple classes. For example, if you'd have a design pattern, those usually span multiple classes (either because of inheritance or because of classes that cooperate). The concept sounds like a good thing to try out to me (though I have to admit I lack sufficient experience to say anything about how useful it will actually be). It sounds like a middle-way between packages (break up the code in large fragments) and classes (break up the code in small bits).

Re:bubbles = isolation

[Anonymous Coward]

And I'd add small and short to that list.

No you won't - this is a Java IDE. Java + "small and short" = FILE_NOT_FOUND.

Re:bubbles = isolation

[Anonymous Coward]

Visual Programming/ Dataflow programming

Re:bubbles = isolation

[Dishwasha]

I just checked on Wikipedia and I couldn't find a picture of a function, could you draw me one please so I can see how to fill my bath tub with them?

Re:bubbles = isolation

[Anonymous Coward]

It's called crappy code (or lack of documentation) if external function calls need it's code referenced when used.

I find it helpful to think function names twice, and after few times more, before releasing api to other co-workers. For clear code keep functions simple, let them do what name says and only that, and finally keep parameters predictable around code.

Re:bubbles = isolation

[SQLGuru]

You can keep your resolution but go vertical. You get to see more without scrolling and without making him scroll as much. Win/win.

Besides, most web designers like to force width their web pages so that it looks "exactly like the photoshop comp, down to the pixel" (stupid pretentious pricks, that one pixel difference you see in IE vs FF can't be helped).

Re:bubbles = isolation

[Dracolytch]

From what I see this appears to be more useful for code editing versus code authoring...

When you're maintaining 10,000 lines of code, you're usually focused on a few dozen lines of code, usually broken into a couple of places... Finding that 50 lines of code, and navigating between the places you care about, can be a significant portion of the task. This appears to have a much superior means of finding those lines of code I care about, and maintaining the context between them to edit faster.

As for code authoring? That could be a real headache (literally)

~D

Re:bubbles = isolation

[TheCycoONE]

It may be crappy, but it's everywhere. This is the whole reason .NET Reflector is so popular.

Re:bubbles = isolation

[cmiller173]

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

Re:bubbles = isolation

[cmiller173]

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

Re:bubbles = isolation

[shutdown -p now]

And I'd add small and short to that list. There's no way this bubble concept would be useable with code fragments longer than a few lines, and even those need to be short since wrapping would destroy the usability of the whole thing.

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

Also, in the sample video, when they had to scroll the screen because of the many bubbles, well, there it became a lost cause for me.

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

Also, in the sample video, when they had to scroll the screen because of the many bubbles, well, there it became a lost cause for me. Realistically, from code dealing with more than helloworlds that I've seen and written, this thing would be a real dealbreaker.

Re:bubbles = isolation

[cmiller173]

Just looked at the beta signup and

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

I'm going to have to give it a try

Re:bubbles = isolation

[Anonymous Coward]

Initially, the idea of "code bubbles" sounds intuitive -- isolated, self-contained, easily testable pieces of code, with well-defined inputs and outputs. Then you could build a complex program by stringing these bubbles together (in theory, anyway).

Perhaps we could call such a pieces of code "functions" instead.

That's a fantastic idea.

I need to patent that!

Re:bubbles = isolation

[skids]

From a coder's perspective it looks pretty useful/usable. You often find yourself going back to alter something you've worked on before, and that something is spread out over 5 different places none of them in the same class/file/whatnot. If you built a bubble when you went in the first time, this would make that much easier to find all the parts again, especially since it has often been months since you last touched that code.

Then again, the last thing we need is to give Java coders a way to build even more complex class hierarchies.

Re:bubbles = isolation

[Requiem18th]

Java + "small and short" = FILE_NOT_FOUND.

SyntaxError at Line:1 Column:25. Attempted write in left hand expression.

Re:bubbles = isolation

[jepaton]

Otherwise 80 columns is more than enough space for anyone.

I wrap as much of my code to 80 columns as possible but I may be doing the wrong thing.

The main problem is that 80 columns can be a fight between meaningful variable/function names and actually getting anything done on a line of code. Just changing a variable name can mean spending time getting everything back under the 80 column self-imposed limit. And that's a problem if you've done A=B+C and can't do much more to shorten the line without using +=. Rigid use of a small column limit may lead to less readable code.

The diff tool is another battle ground: shorter lines help when differencing files (e.g. 3 files side by side) but at the same time a shorter column limit often means more changed lines.

I think that the goal in programming is to write obviously correct code. Whatever achieves this is the right approach. Which is why programmers often can't agree on anything because there isn't one correct approach (except their own!).

Re:bubbles = isolation

[pclminion]

If you are working on one function that is in file3.c that has to interact with functions in file7.c and file3.c, why not be able to display them all as if they are in the same file

If file3.c and file7.c are typically edited in concert, this is a sign that their functionality might better belong in a single file. If file3.c simply USES file7.c, then there is normally no reason to look at the code inside file7.c. You are trying to use a code editing tool to solve something which is fundamentally a design issue. Obviously, separate functionality should exist in separate files. But if file3 and file7 are almost always edited at the same time, their functionality is clearly not "separate."

If you find yourself jumping schizophrenically between source files to accomplish everyday tasks, you should not think "What tool can make this less painful?", you should think "What is wrong with the organization of this code and how can I correct it?"

Re:bubbles = isolation

[fbjon]

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

Re:bubbles = isolation

[fbjon]

The IDE doesn't code interactions, the programmer does by way of the diagrammed view that the IDE presents.

Re:bubbles = isolation

[Haeleth]

In most programming languages this unit of code containing multiple classes is called a "file". I suppose it might be useful to have a Java preprocessor stage that was able to split up a multi-class file before feeding it to the compiler, to get round the strange "one class per file" limitation that Java's designers have seen fit to lumber us with, but I don't quite see why we'd need a whole new IDE and new terminology for something so simple.

Re:bubbles = isolation

[beelsebob]

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

Re:bubbles = isolation

[khayman80]

Keeping stuff in separate files and including them is a good organization technique...

Why? That just means I have to open more files when I want to perform extensive maintenance on the program.

Compiling is definitely faster if you only change 1 out of 100 similarly sized files, but I've chosen to create two main source files: the first is infrequently edited and large (30k lines), while the second is edited dozens of times a day and only has 1k lines. The Makefile compiles the large file into object code which is then linked to the object code from the small file. The large file is thereafter only compiled if the revision date of the large source file is newer than the large object file. Even the compiles for the large file are just ~10 seconds on a netbook if optimization is disabled, and it's not clear that my compile times will grow faster than CPU speeds will. (Especially if parallel g++ ever gets decent.)

I suppose one could say that code segmentation helps to enforce the "few interconnections between functions" principle. (Or whatever it's formally called- the notion that functions should interact in only a few well-defined ways.) This ideal is theoretically attractive, but seems annoying to implement without allowing for occasional exceptions. I don't want to change a useful guideline to a rigid law that will probably just slow me down.

I also write code by myself, so reasons involving programming teams aren't really relevant. A good version control system like Mercurial should minimize these issues anyway.

Are there any real (i.e. productivity, scalability) reasons to abandon this approach and start putting new functions in separate files? I'm not a professional programmer, so I may have missed something that a computer science PhD would consider obvious and compelling...

Re:bubbles = isolation

[fbumg]

That was the first thing I thought of as well. Maybe they will come out with an Eclipse plugin, then I could just switch to that view when needed instead of an entirely new IDE.

Re:bubbles = isolation

[ottothecow]

I was thinking more as a handy reference...I like to look back at things

Think about if maybe it is not your code you are editing--new job, helping an open source project, whatever--when your code calls function1(), it might be nice to know what function1() does as well as what function3() and function4() do when they are called by function1(). I'm envisioning something that brings them all together on your workspace even though they are separated correctly into files of related functions (or incorrectly..maybe the guy before you was crazy and thought functions should be stored alphabetically).

I see it not as a new paradigm for storing code, but a new way to explore and edit code. Quite frankly, on a brand new project with no set standards for what files get what code, it would probably be a worse way to start.

Re:bubbles = isolation

[drewhk]

The problem is that using files allows only one partitioning of code, and many times it would be better to have an arbitrary number of partitions. This is what I like in this IDE concept.

Re:bubbles = isolation

[drewhk]

I think that the problem is that even modern IDEs simply mirror the file structure underneath the code. I like the concept of having one file/class in Java, it makes finding classes very easy. However it is clear that sometimes it is very annoying to have the classes distributed everywhere. In practice it would be nice to have an IDE feature that allows to partition the classes without changing the one file/class convention. I could imagine one partitioning that couples classes with their corresponding test cases. Another partitioning could couple classes in one package. You could create partitions that reflect collaboration between classes, etc.

Re:bubbles = isolation

[ubersoldat2k7]

Yes, you can call them "Methods"... wooow!

Re:bubbles = isolation

[jon3k]

I like the idea of abstracting the physical location of files. You don't care what FILE contains class Foo you just want to access one of it's methods. Being able to group several related code fragments together is really nice. I don't see this as revolutionary just a neat idea.

Re:bubbles = isolation

[Anonymous Coward]

Really? Show me one language standard besides Java that says this.

Re:bubbles = isolation

[JSlope]

Article says it's based on Eclipse and that you can still have your standard Eclipse with it.

Soo much space required.

[coolsnowmen]

I'm going to need a bigger screen.

Re:Soo much space required.

[patro]

I watched the video in 1080p and the text was pretty much unreadable. One would need either a huge screen or have to live with constant panning.

Re:Soo much space required.

[Anonymous Coward]

I'm going to need a bigger screen.

Problem Solved, Viewsonic VP2290b monitor, 3840x2400.

Re:Soo much space required.

[IamTheRealMike]

And how much space is wasted on your screen currently due to most lines being shorter than N characters? I use a single emacs window stretched across dual screens, and Google imposes an 80 column limit on its C++ code so with a slightly larger font this means I can fill the screen with code. But still, often some of that code is just guff that happens to surround the function I'm interested in. The CodeBubbles idea looks really nice and I can't wait to try it out for myself.

Re:Soo much space required.

[BikeHelmet]

This should actually work remarkably well. Several years ago I wrote something similar, although much more primitive. I called them boxes, and it was for working with multiple HTML/css/js files at once. No syntax highlighting, and none of this advanced stuff - it was just a notepad replacement, since Windows lacked grid alignment for windows. I did add the option to open files by clicking on (for example) a script or link tag, and the ability to move/resize boxes freely, but that was it.

This thing is impressive. I've got a huge monitor, too - I'd love to try it once it matures and is available. Plus, now I'm more into Java than Javascript. This kind of layout suits me far more than Eclipse.

Re:Soo much space required.

[Anonymous Coward]

AMD will probably include this project in all of their Eyefinity marketing materials

Re:Soo much space required.

[Unoti]

You're right. But 1920x1080, with 2 or 3 monitors isn't unreasonably expensive to get. And it's getting cheaper with each passing month. I've got my main monitor at 1980x1080, plus 2 monitors on the sides of that slightly smaller. It's cost effective and reasonable to get multiple monitors. It's harder to use the screen real estate effectively than it is to get the real estate.

Re:Soo much space required.

[tepples]

But 1920x1080, with 2 or 3 monitors isn't unreasonably expensive to get.

Provided you're at a desk. I do a lot of my coding on a fairly small laptop.

What rethinking?

[Accidental Angel]

It looks like the Smalltalk GUI to me.

On the fence

[binarylarry]

I think this would be a cool tool for evaluating how an application is executed, as well as visualizing call sites and application traversal.

But I think it would be a major pain in the ass for most development purposes.

Re:On the fence

[philipborlin]

This seems like a superior way to debug code. I especially like the way the inspections stay persistent and the way you are looking at a path of code instead of some call stack list. I don't know how well this would work for new development though.

Where have I seen something like this?

[140Mandak262Jamuna]

Small pieces that do one thing, but that thing well, they interact with other pieces in a standardized way... I know I have seen this before. Let me awk my brain. I am greppping through my memory.

Oh goodie

[aztektum]

More UI elements to click-n-drag

As if having a couple dozen windows open and trying to organize them wasn't fun enough.

Re:Oh goodie

[copponex]

The point is that you replace the windows with another GUI concept, called bubbles. Did you watch the video?

Maybe you have time to read the first two paragraphs:

Developers spend significant time reading and navigating code fragments spread across multiple locations. The file-based nature of contemporary IDEs makes it prohibitively difficult to create and maintain a simultaneous view of such fragments. We propose a novel user interface metaphor for code understanding and maintanence based on collections of lightweight, editable fragments called bubbles, which form concurrently visible working sets.

The essential goal of this project is to make it easier for developers to see many fragments of code (or other information) at once without having to navigate back and forth. Each of these fragments is shown in a bubble.

Re:Oh goodie

[Anonymous Coward]

But this way, atleast you have your dozen windows located inside one bigger window.

Re:Oh goodie

[Anonymous Coward]

Developers spend significant time reading and navigating code fragments spread across multiple locations.

So we decided to put every function into its own fragment to make the problem even worse!

Re:Oh goodie

[evil_aar0n]

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

Re:Oh goodie

[Mr. Slippery]

The essential goal of this project is to make it easier for developers to see many fragments of code (or other information) at once without having to navigate back and forth.

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

Re:Oh goodie

[beelsebob]

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

Re:Oh goodie

[xiong.chiamiov]

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

You still have to visually identify which window in your Expose list you want. That's why I'm a heavy user of virtual desktops (usually have windows across at least 8 of them while I'm coding) and a tiling window manager. I understand that it's not the workflow for a great number of people, but it works really well for me (and I can't stand using a floating wm).

Screen Size

[pavon]

The demo made this look pretty nice for tracing functionality through multiple classes/method calls. It annoys me that most IDEs make it harder to view code side by side than Emacs did 15 years ago. That said, it appears that you either need a really huge monitor, or be comfortable reading really small text, for this system to work they way they demonstrate.

Re:Screen Size

[heson]

I think the ide works well for students debugging their tiny hello world -projects (or maybe junior programmers in someone elses spaghetti code), but serious professionals can visualize more than the code visible on the tiny bubble desktop in their head. There were some nifty features, but I consider it a toy for the most part.

Re:Screen Size

[ClosedSource]

"serious professionals can visualize more than the code visible on the tiny bubble desktop in their head"

I always wondered how short order cooks could keep track of all the various foods they were cooking with different start times and different cooking times. Now I know they were "serious professionals".

Re:Screen Size

[ottothecow]

I wonder about that too but I would imagine that it has more to do with the fact that well trained cooks are not taught to cook things for XX minutes but rather learn to cook by feel. Especially if you cook the same things many times a day, you can probably tell by looking/smelling/listening/prodding when it is done.

Re:Screen Size

[pavon]

I envy you if your jobs have led you to think that only junior programmers have to deal with other people's spaghetti code. In my opinion any project big enough to be considered a "serious professional" project is big enough to have had at least one lousy developer that left their turds in it.

Re:Screen Size

[Anonymous Coward]

most IDEs make it harder to view code side by side than Emacs did 15 years ago.

Exactly. End of story.

Re:Screen Size

[BikeHelmet]

Good thing you can pick up monitors for $99 these days!

Or huge ones for a bit more. I got a 2048x1152 Samsung 2343BWX for $170 CAD.

Re:Screen Size

[BikeHelmet]

Serious professional or not - anyone should be able to keep a thousand lines in their head, and write relatively bug free code around that. Maybe even 15000 lines without making mistakes.

But projects that a "serious professional" will be working on could be far far larger than that. Many people on slashdot have worked on projects having hundreds of thousands to millions of lines of code. Visualization skills be damned, if looking up code (which will have to be done constantly) is a PITA.

Re:Screen Size

[Mr. Slippery]

I always wondered how short order cooks could keep track of all the various foods they were cooking with different start times and different cooking times. Now I know they were "serious professionals".

Yes. A good cook is a serious professional. Why not?

Re:Screen Size

[ClosedSource]

The point is that for a good short order cook, real-time skills are fundamental, for a professional software developer, they're not.

Re:Screen Size

[xero314]

Serious professional or not - anyone should be able to keep a thousand lines in their head, and write relatively bug free code around that. Maybe even 15000 lines without making mistakes.

Most people would not be able to keep more than 9 lines clearly discernible in their heads. This is why our brains naturally go through the process of recoding. No one thinks of 1000 lines of code as individual lines, we think of them as the concept they cover. But this is why object oriented design can into being in the first place, it's a form of recoding.

This code bubbles thing is really just another realization of Miller's magic number. That's not to say it's not a good thing, just saying it's not a new concept just a new implementation.

Re:Screen Size

[bill_mcgonigle]

Even at that a seriously good display is $300. Yet you'd be shocked at how hard it is for some programmers to get their employers to buy them a big monitor. I don't even think it's the price - we used to pay non-inflation-adjusted more than that for a crappy $15" CRT. It's that the programmers can't have a bigger display than their managers and their managers don't need a display that big (big displays are a hindrance for normal office work, once you need to turn your neck).

What's even more shocking is that programmers don't quit those jobs en masse.
   

Mylyn in Eclipse

[MyForest]

I've recently been using Mylyn to give me a focussed view on the code I'm working on. I love the way it automatically adds things to the context as I click around.

Then of course there's the rather gorgeous "Run unit tests in context" to give me feedback on the things I've been tinkering with.

Re:Mylyn in Eclipse

[tthomas48]

Exactly what I thought of. If they could merge this concept with Mylyn it would be amazingly powerful.

Solution in the search of problem.

[anonymousNR]

Developers spend significant time reading and navigating code fragments spread across multiple locations. The file-based nature of contemporary IDEs makes it prohibitively difficult to create and maintain a simultaneous view of such fragments. We propose a novel user interface metaphor for code understanding and maintanence based on collections of lightweight, editable fragments called bubbles, which form concurrently visible working sets.

I agree with Developers spending time reading and navigating code fragments but isn't that part of the job ? I think its called debugging ,locating problem, identifying it in the code and fixing it, if it takes navigating or standing on his head he will do it.

Gonna need a bigger monitor...

[Anonymous Coward]

Well, it'd give me a business case for a few of those huge 2560x1600 monitors I've been hankering for. More seriously, F3 and ctrl-shift-G are very commonly hammered buttons in my usage of Eclipse, so maintaining context as you flow through might well aid productivity.

Debugging and documentation

[beakerMeep]

This looks nice as a way of exploring, debugging, and documenting code especially. I like how you can save layouts by date. But I feel like I would want to step back into eclipse to do the writing. I would be nice if they made a way to integrate with other IDEs.

Re:Debugging and documentation

[home-electro.com]

I think so too. The demo looks very smooth and it could be nice to explore large project done by somebody else, but to use it for development? No thanks. I rarely find myself needing to look at more than two files at once. And, I like larger fonts.

Re:Debugging and documentation

[Anonymous Coward]

Yes, the usage scenario you've painted here is a lot like what I'm thinking as well.

Besides, it looks quite similar to the work Ilfak's done with IDA Pro 5.

http://www.hex-rays.com/idapro/freefiles/ida5preview.htm

Re:Debugging and documentation

[MemoryDragon]

A good uml plugin can almost do the same...
Problem is there are no good uml plugins :-)

Re:Debugging and documentation

[Anonymous Coward]

It is actually based on Eclipse, but I'm not sure can you just add it as an extension/plugin. Looks like they are looking for beta testers.
http://www.cs.brown.edu/people/acb/codebubbles_beta_signup.htm

Re:Debugging and documentation

[wembley fraggle]

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

It's a good idea.

[Anonymous Coward]

I think it's brilliant. I don't care if somebody did it somewhere else before and deserves all the credit--that's beside the point. I would definitely like to use an IDE like this.

It would probably encourage more refactoring and smaller function sizes. The windowed IDE puts a bias on keeping code all together in one place, because of the small-but-present difficulty in switching to other files.

Re:It's a good idea.

[Physics Dude]

I think it's brilliant. I don't care if somebody did it somewhere else before and deserves all the credit--that's beside the point.

Wait... are you by chance a US Patent Clerk?

Re:Rob Malda's tranny died under mysterious circum

[Anonymous Coward]

Thank you for the ho hum rip off of a poorly written story about Eddie Murphy killing a hooker...

love it - i had already "dreamt this up" w/hope

[happyjack27]

and my hopes have been fulfilled.

XEmacs binding...

[fahrbot-bot]

M-C-x fuck-up-my-screen

Re:XEmacs binding...

[swilly]

That is an unfair exaggeration. To run the fuck-up-my-screen function, you only need M-x fuck-up-my-screen. On my emacs install C-M-x maps to eval-defun, which isn't what you want at all (unless you are trying to debug the fuck-up-my-screen function).

Re:XEmacs binding...

[fahrbot-bot]

To run the fuck-up-my-screen function, you only need M-x fuck-up-my-screen. On my emacs install C-M-x maps to eval-defun, ...

All true -- I had happy fingers this morning -- unless, of course, one re-binds the keys... :-)

cant help it..

[zcold]

I know I know, but I cant help but laugh at the person video explaining code bubbles....Its just ssssooo sssuper fantastic! I like the idea tho. Its very interesting.. Though I have no plans on learning a new IDE.

Looks promising...

[johnlcallaway]

I do mostly maintenance programming (by choice .. I'm good at fixing code I know nothing about, I like it, it keeps from from being pigeonholed, and there is a lot less competition). So I spend a lot of time hopping around code I know nothing about. I also spend a lot of time 'going backwards' through programs, since sometimes all I have is an error message and it's easier than trying to start at Main. This type of interface would be very beneficial in my type of work.

Even writing code from scratch, I rarely program 'top down', but group methods in the file based on some vague grouping concept, like all setters/getters together, methods that are called somewhere around methods that are calling them. It's really not necessary for me to 'know' where in the file they are, as long as I can get to them, open, do whatever, then close them.

I think that as long as I can open a 'bubble' and have complete access to all my code via scrolling, this would work fine. I would only need to open bubbles as I need to then.

Besides .. what would happen to those bubbles if some braces got out of alignment. You would have to have pure code scrolling to be able to fix something like that.

Re:rofl java

[Anonymous Coward]

says a guy who can't even write a double-linked list in Z80 assembly.

Excellent for Students

[JW CS]

Based only on the video, this looks like it could be very useful for students working with smaller Java assignments. The interface looks intuitive, and seems to be designed for people who like to visualize the flow of their code. The debugger also looks more intuitive than many of the ones I've seen. However, I shudder to think how messy the interface could get if you were working with a large project.

codebase awareness

[Alban]

There is something to be said about knowing the structure of your codebase. I already see intellisense users jumping around and editing code from locations they have no idea about, this will be even worse. It really pays off to understand the file/directory/package structure of your codebase, as opposed to jumping to unknown locations, making an edit and bailing out. Intellisense/ctags are great when they extend your knowledge of the codebase, but they shouldn't be a substitute for having some amount of awareness.

snippets might be useful for better diffs

[Vadim Grinshpun]

This reminds me of an idea I had some time ago, which might be an application for something like that (I've not read the article yet, so maybe they;re doing something different; but this might be interesting anyway :)

When refactoring code, it's not atypical to move whole snippets of code around. Reviewing the results of such a change (i.e., doing a diff between the versions) is usually nightmarish, since every diff tool I've ever seen is inherently line- or block-of-lines-oriented, and cannot recognize the simple (for a human) case of "I moved this function above that other function".

If the diff tool (and/or the related version control tool?) could be sufficiently language-aware, it might be able to recognize certain semantic units (functions, scope blocks, etc), and try to keep track of them. If this could be done, a diff output could actually be much more meaningful than what we get these days.

Step by step, Java reinvents Smalltalk...

[Paul Fernhout]

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

Now if only Java had Smalltalk's blocks.

And Smalltalk's more descriptive message passing syntax of "Foo x: 10 y: 20". instead of "new Foo(10, 20);"

And Smalltalk's extendable control syntax...

And Smalltalk's "doesNotUnderstand" concept for proxying.

And Smalltalk's become: method.

And Smalltalk's ability to rethrow exceptions...

And Smalltalk's multi-generational garbage collector...

And so on...

One step at a time...

If only the ParcPlace suits had not been so greedy when Sun wanted to use Smalltalk in set top devices, and instead Sun turned to a Frankenstein "Plan B".
    http://fargoagile.com/joomla/content/view/15/26/
        "When I became V.P. of Development at ParcPlace-Digitalk in 1996, Bill Lyons (then CEO) told me the same story about Sun and VW. According to Bill, at some point in the early '90's when Adele was still CEO, Sun approached ParcPlace for a license to use VW (probably ObjectWorks at the time) in some set top box project they were working on. Sun wanted to use a commercially viable OO language with a proven track record. At the time ParcPlace was licensing Smalltalk for >$100 a copy. Given the volume that Sun was quoting, PP gave Sun a firm quote on the order of $100/copy. Sun was willing to pay at most $9-10/copy for the Smalltalk licenses. Sun was not willing to go higher and PP was unwilling to go lower, so nothing ever happened and Sun went its own way with its own internally developed language (Oak...Java). The initial development of Oak might well have predated the discussions between Sun and PP, but it was PP's unwillingness to go lower on the price of Smalltalk that gave Oak its green light within Sun (according to Bill anyway). Bill went on to lament that had PP played its cards right, Smalltalk would have been the language used by Sun and the language that would have ruled the Internet. Obviously, you can take that with a grain of salt. I don't know if Bill's story to me was true (he certainly seemed to think it was), but it might be confirmable by Adele. If it is true, it is merely another sad story of what might have been and how close Smalltalk might have come to universal acceptance."

How much people forget...

Of course, fifteen years later, Java is not that bad... Most of the bugs are out. There are some good libraries. There is a better garbage collector... And so on...

Re:Step by step, Java reinvents Smalltalk...

[MemoryDragon]

Parcplace killed the entire Smalltalk market with the Digitalk Fiasco...
And yes greed and internal corporate quarelling basically did it!

Re:Step by step, Java reinvents Smalltalk...

[hfranz]

Thats why I am looking at Scala right now. More flexible syntax, multi-paradigm, compiles to java or .net byte code.

Re:Step by step, Java reinvents Smalltalk...

[Anonymous Coward]

when you use "doesNotUnderstand" you may as well just have duck typing. Throw any expectations about interface contracts out the window. If you like duck typing, python and ruby are that-a-way, but I'll take even Java's half-assed static model over not having one at all.

become: is anathema to optimization. There's a reason squeak avoids using it as much as possible. Interfaces arguably remove most of the perceived need for become anyway (though I'd say you need structural subtyping to make it really obsolete).

Despite the flaws, I do actually like smalltalk better in many ways, but yeah it was absolutely killed by the suits. I don't think the story is accurate though: Sun already had a very high-performing smalltalk variant of its own, called Self, which ran circles around ParcPlace's smalltalk implementations. In fact, the JIT design of Self came back in the form of the Hotspot JIT for Java. Oh, and Self's UI was a lot like this "bubbles" thing (though I would grant it was otherwise awfully primitive)

Re:Step by step, Java reinvents Smalltalk...

[Paul Fernhout]

I agree, Scala is a great step forward, as are many other JVM languages, Jython, JRuby, Kawa, Clojure, and so on...
http://www.is-research.de/info/vmlanguages/
http://en.wikipedia.org/wiki/List_of_JVM_languages
It's too bad Sun did not focus on making a universal VM from the start... Or that the Smalltalk people did not embrace other languages...

More more comments by me on that general issue:
"[Edu-sig] Freedom: some Smalltalk history and Python implications"
http://www.mail-archive.com/edu-sig@python.org/msg02717.html

And that references my post from 12/28/96 (I'll put here since it is only at archive.org probably):
"Squeak and the Babel of programming languages"
http://web.archive.org/web/19980121002624/http://www.create.ucsb.edu/squeak/9612.html#Letter94
"""
Date: 96 Dec 27 8:13:49 pm
From: Paul Fernhout [old email snipped]
To: squeak@create.ucsb.edu
Subject: Squeak and the Babel of programming languages

Here are some things that could be done with Squeak. Will I do any of them myself? I don't know. At this point, I'm still figuring out what use I want to make of Squeak, and more generally, what Squeak could be all about.

* The main idea

In general, I'd say the world has too many programming languages (and development systems) and too few standard comprehensive libraries (along with their accompanying architectures and program interfaces). So how can Squeak fit into this Babel of programming languages?

* Squeak as a repository of algorithms

One thing I'd like to see in Squeak is a complete set of algorithms and patterns drawn from the published literature. That would possibly encourage Squeak's use in programming education, in rapid prototyping, and as a repository of programming knowledge. Even if people didn't deliver in Squeak, they could begin to rely on it as a source of inspiration and algorithm templates.

* Squeak as the interpreter of choice

The world also has too few tools (like LEX & YACC) for supporting developing application specific languages. I=92d also like to see Squeak with good tools for parsing, interpreting, compiling, and translating - like a TGEN port. If Squeak had such tools, one could consider doing the following.

* Squeak emulating & being emulated in other languages

Squeak is one of only a very few well done, reasonably stable, and completely open development environments in a language that appears to have a strong future (maybe it is the only one?). The fact that Squeak is implemented in Smalltalk is important, because Smalltalk is a self-reflective system. However, this does not mean the Squeak tools (debugger, inspector, class browser) might not be useful for developing in other languages (NewtonScript, Lisp, Basic, C++, Forth, Python, Object Cobol) since languages are something other than their most efficient implementation.

Two Smalltalk companies have moved a bit in this direction. OTI has a product that lets one use their ENVY tools to browse, modify, and recompile C++. ParcPlace has a language parser in its advanced tools kit that lets you create classes which have their methods parsed in another language you define using a simple language specification grammar.

The other side of this language coin is that Squeak has an open VM that does not have to be tied to C. It could theoretically generate a VM in Lisp, Delphi, Forth, NewtonScript, or Assembler.

C is a very common language. So having Squeak make C development easier through browsers, as well as allowing methods with embedded C (like SmalltalkX) is one place to start.

Ideally, one could imagine Sque

Re:Step by step, Java reinvents Smalltalk...

[Anonymous Coward]

No no no no... The C Syntax, for all its warts, has become quite universal.... But certainly, higher order ST concepts in Java would be welcome. Do note that as far as i understand, Bubbles smell like code fragments... Makes me think of Functions+Macros for some reason. There is really not a Language-level feature for something like Bubbles, it's really a refactoring and "UI" concept in the IDE that translates to normal code at the end of the day, kind of like Classes in C With Classes before then became concepts of their own in C++.

On the other hand, we have come a long way to think about software as objects and services, and this seems like a pendulum swing in the other direction to think about independent pieces of unidimensional code (i.e., functions). I'd have to use it for a while to really make up my mind. Coming to conclusions with just a video is not very fair.

- Laurent Hasson

Re:Step by step, Java reinvents Smalltalk...

[Paul Fernhout]

Yes, you have a great point about Self (which would have been licensing cost free in theory...)
    http://en.wikipedia.org/wiki/Self_(programming_language)
"The first public release was in 1990, and the next year the team moved to Sun Microsystems where they continued work on the language. Several new releases followed until falling largely dormant in 1995 with the 4.0 version. The latest 4.3 version was released in 2006 and runs on Mac OS X and Solaris."

I don't know why Sun did not choose that. I'd be curious what David Ungar would say about that?

I met David Ungar once, at OOPSLA-97, but he had a bad cold and so was not that chatty then... I hope he is getting enough vitamin D, as vitamin D deficiency is an occupational hazard of the indoor worker, though I did not know that then either, and it is connected with colds and influenza, as well as many other health issues:
        http://www.vitamindcouncil.org/treatment.shtml
    http://en.wikipedia.org/wiki/Vitamin_D_and_influenza
"A study published in the February 2009 Archives of Internal Medicine involving 1900 adults and children done by the University of Colorado Denver School of Medicine, Massachusetts General Hospital, and Children's Hospital Boston, found that people with the lowest blood vitamin D levels reported having significantly more recent colds or cases of the flu. The risks were even higher for those with chronic respiratory disorders, such as asthma and emphysema. They reported that asthma patients with the lowest vitamin D levels were five times more likely to have had a recent respiratory infection; while among COPD patients, respiratory infections were twice as common among those with vitamin D deficiency. However, the authors stress that the study's results need to be confirmed in clinical trials before vitamin D can be recommended to prevent colds and flu..[4][5]"

Could vitamin D deficiency syndrome explain why we got Java instead of Self? :-(

Beyond the opposite of Not-Invented-Here (A prophet is without honor in his or her own country), perhaps Sun's choice is because Self used an enormous amount of memory for the time, whereas Smalltalk could run on smaller systems (part of that is about the implementation efficiencies of using classes)? VisualWorks was already used in embedded stuff (running Fabs as "ControlWorks") so it would have been a much safer bet in that sense.

And then, if you are going to do a home-brew system, the C syntax is commonplace...

I also have some comments about my own attempts at prototype-based systems, and why classes have some big advantages practically:
    "PataPata critique: the good, the bad, the ugly"
    http://patapata.sourceforge.net/critique.html

Again though, you still have a great point. And NewtonScript, say, was a prototype-based system designed for low memory environments like the Newton, so it was not impossible...

I think most people just don't understand how problematical the C-style syntax is for creating self-documenting easy-to-read code compared to Smalltalk's.

Re:Step by step, Java reinvents Smalltalk...

[pydev]

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

The Smalltalk browser is pretty nice (and Smalltalk is a great programming language). Nevertheless, Smalltalk lacks a facility for linear presentation of code, something like literate programming. That kind of facility really is needed.

Re:Step by step, Java reinvents Smalltalk...

[xiong.chiamiov]

Bill went on to lament that had PP played its cards right, Smalltalk would have been the language used by Sun and the language that would have ruled the Internet.

In case you haven't noticed, the language that rules the internet is not Java, but scripting languages (one of which that is growing particularly rapidly pulls quite a bit from Smalltalk).

Re:Step by step, Java reinvents Smalltalk...

[Paul Fernhout]

Great point.

What a giant failure

[Chemisor]

Any UI design that forces me to use the mouse is automatically a failure. Any method of information display that uses only a small fraction of the available display space to display tiny windows and forces me to resize them or scroll them is also automatically a failure. A method that combines both, must then be a gigantic failure.

Re:What a giant failure

[presidenteloco]

As for the mouse, get a mac laptop and use the trackpad. Not a big issue.

The thing is about letting you understand context quickly. The context comprehension is vital to dong an insightful code addition or fix.

It is also good at showing the narrative aspect of code stories, which interleave through the single file-based view of the code.
These code stories are essential to understanding the essential behaviors of the code you are adding to or modifying.

Works for me.

That said, the more automatic layout, the better.

Re:What a giant failure

[MagikSlinger]

Speak for yourself. Some of us like the mouse and window for code editing.

Re:What a giant failure

[martas]

are you using lynx right now, by any chance?

Re:What a giant failure

[stoanhart]

What a closed-minded and overly general statement!

I certainly agree that often a keyboard-only approach and minimal screen "wastage" is great - I am an emacs fan after all. However, there are always exceptions and if we don't explore new ideas we won't find better ways of doing things. How can you call it an automatic giant failure when you haven't even tried it yet.

Your complaint about not using all available screen space for what you want to see doesn't even make sense in this context! Why would you want a single bubble/code fragment to take up the entire screen? That's contrary to the point! The idea here is to be able to quickly trace a complex program by seeing only the code that represents the function being called at any point, rather than the whole irrelevant file. And while there should surely be a keyboard method to navigate the bubbles (arrow keys would work marvelously here), a mouse is an excellent way to navigate a large 2D surface.

Re:What a giant failure

[MindStalker]

Agreed/Disagreed. I think this would be amazing for code reading/debugging/getting familiar with code. Actual coding? Yea, it doesn't seem very conducive to a lot of typing, but then again a lot of coding nowadays is about putting pieces together, so this makes sense. As long as there is a way to quickly switch to a more traditional view when you need it, it would be a huge win.

Re:What a giant failure

[Just Some Guy]

Some of us like the mouse and window for code editing.

Some of us probably like getting punched in the nuts, but that doesn't make it reasonable or painless.

It's all about the context switches. When you're typing along productively, then have to stop to get the mouse, find the pointer on the screen, get it to where you want it, perform whatever action, then pop back to the keyboard to continue, you've had to bounce your attention across several distinct actions. That just isn't productive.

Re:What a giant failure

[Dracolytch]

And hey... If you watched the whole video, you'd discover: They do have ways of navigating the space via keyboard.

I'm more a .NET guy these days, but I'd love to try this. Even if the whole thing isn't a slam-dunk, I think there are valuable and useful concepts here that can be useful elsewhere.

~D

Re:What a giant failure

[Anonymous Coward]

Any criticism that uses the phrase "automatically a failure" without substantiation is...

Re:What a giant failure

[Coryoth]

It's all about the context switches. When you're typing along productively, then have to stop to get the mouse, find the pointer on the screen, get it to where you want it, perform whatever action, then pop back to the keyboard to continue, you've had to bounce your attention across several distinct actions. That just isn't productive.

I think that really depends on what sort of coding you're doing. Now I have no idea what your work is like, but I find that the amount of time I spend continuously pounding out code on the keyboard is pretty limited -- I spend far more time reading code then writing, and far more time thinking than reading -- so context switches are pretty cheap, especially when you can grab the mouse and move it to where you need while reading or thinking. But as I say, that's one type of coding; I have seen code that has people just pound away at the keyboard without having to stop and read or think about what they're writing. That may well be your situation. It is not the case for everyone.

Re:What a giant failure

[martin-boundary]

It's all about the context switches. When you're typing along productively, then have to stop to get the mouse, find the pointer on the screen, get it to where you want it, perform whatever action, then pop back to the keyboard to continue, you've had to bounce your attention across several distinct actions. That just isn't productive.

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

Re:What a giant failure

[Anonymous Coward]

Yeah no kidding. Hey GP: for a real productivity boost, quit surfing the net and get back to work.

Re:What a giant failure

[xiong.chiamiov]

Speak for yourself. Some of us like the mouse and window for code editing.

I use a laptop for a significant portion of my coding (as I would guess many people do), and going from my vi-keybinded Komodo to Eclipse is painful.

Trackpads have made me appreciate keyboard-controlled window managers, vimperator, and the aforementioned editor so much more.

But, does it have...

[narooze]

But, does it have a good text editor?

2nd goal of a Java developer achieved....

[croftj]

I figured out just recently that the first goal of any true Java developer is to write an abstraction layer/framework to abstract previous abstraction layers/frameworks written before them.

Now, this week, I learn the 2nd goal. Write a way cool looking but really very complex development environment to help you muddle one's way through the myriad of abstraction layers already written.

All of this just to help overcome the basics such as overloading operators.

In all seriousness, this seems to show too little information with too much space in between. My screen real estate is vary valuable. Not to be wasted with pretty colored borders and arrows and such.

-joe

Re:2nd goal of a Java developer achieved....

[rombertw]

There is no operator overloading in Java.

In fact, there's much less magic in Java than in more hip languages, and that's a very good thing in my book.

Robert

Re:2nd goal of a Java developer achieved....

[alexj33]

In any case, croftj is dead on correct about an overload (no pun intended) of abstraction in the java community.

Good gravy, can't anyone even write a decent Java app anymore without having to learn half a dozen frameworks?

Re:2nd goal of a Java developer achieved....

[lucian1900]

The lack of operator overloading makes code needleslly complex. What's simpler: a + b or a.add(b) ? Java is a huge failure with good marketing.

U have screen wide enough to fix bugs in bubbles?

[roman_mir]

opening methods side by side? I just wish I had 200" wide screen, or maybe I don't. 'Bubbles do not overlap but push each other out of the way' - they expand. Have you seen what a map like that looks like? How about 5meters x 5 meters of space that you would need to debug a business or a system level problem? Oh yeah, you just 'pan over'. So how the hell is that different from opening separate files? I know how, opened files are obvious but something you need to move around virtual screen is not immediately obvious. Where was that file that was open? Oh yeah, 35" up and 23" left. But of-course, you can zoom the screen in and out, all you have to do is remember what all those minuscule pictures have in them there and then 'you can continue working'. You have 'miniature maps' of the entire workspace. God, how many times I had to work with tools that did this, it was never any help. The 'miniature map' is a terrible idea for text boxes, it's not apparent, like a file list, what's in any of those text boxes.

Bubbles expand as you type into them and push other bubbles out of the way. Sounds wonderful, the entire screen is jumping around as you type.

The developer's screen in the video looks like a mess and a mess at very high resolution. Minority report interface style mess.

Code 'group information is persisted automatically'. Some XML meta files are created. When working in a team, do you check these into source control? What happens when files that used to be in your 'bubble' are changed/renamed/removed by other coders in the project?

Tasks are grouped by date? Revisiting sets of bubbles by their dates, hmmm. Doesn't sound right. Will you remember to revisit some bubble set a week from now? How many bubble sets will you create in that time? Will you remember all these bubbles?

It's a nightmare, colorful, messy, visually heavy nightmare. This will probably sell well as a 'new coding paradigm' to CTOs and such.

I liked two features: 1. searching for path between functions. They promise to find the shortest path (hope they don't have to find the shortest path between functions for some projects I had to witness) and display alternative paths as well. 2. having output from 2 separate debug sessions opened at the same time. I would give that a try but most likely this will not cause any real improvement, I already manage to work without that by remembering the previous debug output or sometimes, when it's too big copying it into a file.

Looks like a solution in search for a problem that has maybe one feature that is worth looking into. Good work.

Ctrl-X 2

[PaulBu]

What, do you mean that your new-fanged IDE does not allow you to split a single window, forcing you to have multiple windows and having to switch between them using your mouse?

And, as someone pointed out above, it sounds suspiciously like what Smalltalk and Lisp developers had back in 80s... :)

Paul B.

So what does it do that I can't do in vim or emacs

[Anonymous Coward]

I do everything in vim and regularly split the window so I can view functions in different files. I can adjust the size of the splits and quickly cycle through them all from the comfort of my keyboard. I have search at my fingertips, and the ability to set a mark and immediately return to it. I'm going to assume that emacs does all of this too.

It seems like the only thing this adds is an explicit notion of fragments, which I work with implicitly on a daily basis, all without having to reinvent how my code is organized.

The tools should let you work with whatever paradigm you wish, not dictate it to you.

I'll improve on your methods!

[Anonymous Coward]

The narrator sounds like Strong Sad.

Re:U have screen wide enough to fix bugs in bubble

[roman_mir]

oh, and forgot to mention. This: searching for path between functions. - I could use that but never as it is shown in that interface, by drawing lines between methods in boxes. Never. However, give me a search like dialog, where I can specify one and other methods, and show me all the connections between the methods and we are talking something useful.

What HR Wants...

[sycodon]

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

Re:What HR Wants...

[ultranova]

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

Re:What HR Wants...

[Anonymous Coward]

It's funny because it's true. I applied to a job posting last week that asked for 5-10 years experience in Android development.

captcha: newborn

Re:What HR Wants...

[mikael_j]

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

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

Re:What HR Wants...

[Anonymous Coward]

and 5 years experience in applying Cloud Sourced Code Bubbling Concepts to the Cloud

Re:What HR Wants...

[Octorian]

Don't forget... The job is a 6-month contract position based on a $34k (USD) annual salary.

Is it really the case?

[PaulBu]

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

Paul B.

Re:Is it really the case?

[TheLink]

I dunno what the rest are using, but even Notepad++ allows you to view stuff side by side, it's not as cool as bubbles, but you can clone the current view. I believe Kate (KDE) allows it too.

As for running out of screen space when you have lots of windows, I wrote a program (for W2K/XP/win7) to allow people to quickly bind hotkeys to windows. So for example, alt+1 = window #1, alt+2 = window #2 and so on. I haven't done a KDE/Gnome version yet tho.

I'm biased but I prefer it to what Windows 7 does (winkey+<number> is by application and not by window).

To me the recent bunch of GUI designers (whether Linux or Windows) don't seem to be designing GUIs that can _also_ make life easier for experienced users. They're all designing flashy stuff to attract "noob users" (see 10GUI for an example of a fancy flashy but _slow_ GUI- switching from one window to another is slower than alt-tab ;) ). I have nothing against making life easier for new/naive users, but at least provide stuff to help experienced users.

Another example: The "Windows Classic" start menu (Win95 till Win2K default) allowed me to quickly create a folder named "1 Explore" in it, and set up shortcuts in that folder named "1 Explore Desktop", "2 Explore My Documents" etc, so that pressing winkey followed by 1, 1 would "Explore" the Desktop. And winkey, 1, C would Explore the C drive. And you could have winkey, 4 would launch the command prompt, ssh etc.

You can no longer do that with Windows 7. There's that search thingy when you press winkey, but that's slower than what I had before.

Haskell not Java

[Great Big Bird]

I think this idea might work best with a functional language like Haskell. But I can't imagine this being good for Java or any other object oriented language.

~/emacs&

[Anonymous Coward]

Still the best/fastest way to code.

Emacs has been able to do this for ages ...

[ThomasB1]

... I just haven't figured out the shortcut to open this view yet.

Neat! I'd really like to try that out. However...

[rhythmx]

I'm not so keen on my IDE being reliant on all those static code analysis tools to determine your code's structure. For the most part they find all your methods just fine, but so many times they fall short, especially when you are not using Java.

VisualAge?

[Dunx]

This sounds an awful lot like what VisualAge had in the late 90s. That mutated into Eclipse of course.

Re:VisualAge?

[Guillermito]

Indeed. Early versions of Eclipse had an icon in the toolbar to switch between a complete file view and an "only the method you are working on" view. I suspect that feature was introduced to allow a smooth transition from VisualAge. I don't think that icon is so prominent on current Eclipse incarnations, but I wouldn't be surprised if it is still there, buried somewhere.

Re:VisualAge?

[mfnickster]

Yep, it's still there...go to Window -> Customize Perspective -> Tool Bar Visibility -> Editor Presentation

Check "Show Source of Selected Element Only" to add it to your toolbar.

Re:VisualAge?

[Anonymous Coward]

Eclipse never catched up with the possibilities in VisualAge (which is now driven by Instantiations after IBM).

But...

[Anonymous Coward]

But... I don't want to wrap lines. :(

Re:U have screen wide enough to fix bugs in bubble

[MemoryDragon]

Actually I would like this as extension to an existing ide (Eclipse, Intellij) just another way of code navigation and structure detection which can be used optionally, I would never enforce the users to use that.
Thats also why the smalltalk editors sucked compared to any modern IDE, they enforce the 3 way view instead of giving the user the option to use this view.

Tiled window managers an vi called

[Anonymous Coward]

And they want their UI back.

Not keen on the interface

[e2d2]

I'm not really loving the interface but the idea of using snippets needs to be expanded to include code others have written and tagged with meta data. I don't know how many times I've had to disturb others simply to ask "have you ever written code to do x?". It would be nice if I could search code snippets using meta data added by the developer or maybe from the code itself using reflection. Sure would be handy. Right now it's fairly clunky, search google, send emails, ask around. Then find that code and incorporate it using cut/paste.

Does it work for a new project

[vivin]

From what I see, it looks pretty good for working with an already existing project. It would help if they talked about starting a project from scratch using this IDE. Either way looks like something worth trying out. To all the people who say this looks like a terrible idea, I think that's rather subjective; It looks like a matter of taste (emacs vs. vi, eclipse vs. netbeans). I think it would help from a maintenance perspective (fixing bugs) or even if you're adding stuff to an existing codebase. I'd like to try this out anyway.

Re:Does it work for a new project

[asylumx]

Yes actually I thought the same thing -- that this looks far more useful in maintaining existing code than in creating new code. I can think of many instances where I could have used something like this. Eclipse's "Open Call Hierarchy" is close, and alt+leftarrow in eclipse is also useful in seeing where you've been. However, you generally can't see all the actual code on the screen at the same time, you have to jump back and forth.

I also really like how they used this concept in their debugger. Bravo for being able to keep old data on-screen for reference/comparison later on.

Large Display

[Anonymous Coward]

Interestingly, I believe that the current "classic" IDE is not much more than an extension of VT -based editors... extended more and more to support GUI's, naturally, but still limited displays. This code snippet editing is not new, either... many IDEs support viewing code at the method level. What's new with this... it really takes good advantage of very large resolution displays. I code at 1900x1200 resolution, now, and really have to finagle the display to make efficient use of it while editing a code file. Worse, it's a much more active thought process to split the display over multiple separate documents. I could easily imagine code bubbles becoming the wave of the future as displays grow beyond 1900x1200 res.

There's nothing fundamental about files.

[hey!]

From the operating system's standpoint, a file is the atomic unit of document management.

From a computer language standpoint, a file is an atomic unit of parsing.

From a programming standpoint, both these concepts have utility, but neither is particularly fundamental.

That's one of the things that makes literate programming possible.

That said, I'm not exactly thrilled by the bubble concept. It's one more place to store vague ideas and associations that will be incomprehensible a few weeks later. It's not bad like the attempts at "graphical programming" languages twenty years ago or so, but I don't see that its really better than code folding, or even as good. What a programmer has to do is to express himself clearly. Anything which helps that is good. Anything that doesn't is meh.

Also, I can't see using the system shown on a laptop. It might be usable on a 24" monitor, but not a 15".

Re:There's nothing fundamental about files.

[MichaelSmith]

I have actually been surprised at how durable the idea of source code has been. Ever since editors started formatting and highlighting code I have expected code to go into a database as stored instructions.

This is new?

[Anonymous Coward]

Correct me if I'm wrong, but how is this different than multiple editors and multiple cli tools running in different shells? Oh, and I need a bigger screen for this? Won't the screen size needed for this make coding harder on, oh gee I don't know, laptops maybe and netbooks for sure. Nice try.

since it is not based on files

[mestar]

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

--
No files for you!

OT: God Damn Twitter Shit

[pavon]

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

Re:OT: God Damn Twitter Shit

[icebraining]

When I read your post I thought it was strange how I hadn't noticed it. Then I realized: NoScript. It really makes the Web suck less.

Enhancing the IDE vs. enhancing the language

[Anonymous Coward]

I once read somewhere: "In Java, you enhance the IDE. In Python, you enhance the language."

That is so true.

Fundamentalist

[RAMMS EIN]

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

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

Re:Fundamentalist

[TrancePhreak]

I think it may work for Java, since in my experience Java forces a certain layout on your files/classes. However, I don't like the way the bubbles work and will continue to not use it.

Literate Programming

[andawyr]

This sounds very much like http://en.wikipedia.org/wiki/Literate_programming/, as introduced by Knuth.

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

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

Re:Literate Programming

[nschubach]

Actually, it reminds me a lot of a program that came out some 15(?) years ago where you could drop down objects and draw linkage lines between them like you were building a flow chart. It had simple boxes that were named by class and had little nubs that you could connect lines to that stood for the parameters and the return value.

I wish I remember the name of that. I kind of wonder what happened to it.

Bad for coding, good for debugging

[dread]

I absolutely see where this would be useful but it's just another concept that can alleviate some of the burdens of certain parts of our (?) work. For coding, all out, no-holds-barred, i-need-to-get-this-out-of-head coding you need something that is structured around packages and classes/interfaces. Whether you have to create it yourself or you started with UML (you fancy person you) or a whiteboard doesn't matter. You want to write the code, test cases and move on. I am a believer in making mistakes and correcting them rather than overanalyzing at the beginning and that has worked well in all sorts of environments, whether it has been carrier grade telecom stuff or enterprise widget work. Doesn't matter. Get an initial design, hammer in the functionality and iterate. However, in that type of scenario Code Bubbles doesn't really help. Where it does help is in debugging and documenting, I can certainly see how this would be enormously useful in that situation. The problem is that you don't normally shift between IDEs that way. Some do, I don't and even though I don't necessarily kill the people working for me if they do it, it adds a lot of maintenance overhead to deal with dual project structures.

Anyway, if this ever gets into IntelliJ I'll be happy clam I think.

Shakespeare said it

[Megahard]

Beware the IDEs of March

Welcome to SAP ABAP and uhm ... VBA?

[Anonymous Coward]

I don't argue the possible merits of the approach - it is just not something that is NEW. The only thing I am worried about is return to nasty blob files with code intermixed with binary objects etc. Or some extensive incomprehensible bulk XML Document model to wrap entire projects' code into a single file.

Call me old fashioned - but files work well. Extremely well. Besides - most IDE add a lot of navigation and eye candy by intelligently parsing code, linking objects together etc, so I simply doubt that this is really "a radical departure". These concepts will simply be incorporated into existing IDEs, without sacrificing the file base concept.

Sounds like Leo

[Anonymous Coward]

Check out the Leo outliner/editor for an example of a working, useful, not-particularly-language-specific(but Python-centric) system in this vein:

http://personalpages.tds.net/~edream/front.html

Leo is based around nodes in an outline. You can mark up your files with nodes, or have Leo inject the node information automatically with some fairly reliable heuristics. Once you have nodes, you can move them around, nest them, generate clone views, etc.... I find it extremely useful for refactoring or piecing together bits of an architecture I don't understand. It can be a little fiddly to create the nodes, but everything is scriptable and it plays reasonably well with regular code editors.

Again, smalltalk already did it

[rubies]

The general recommendations were that each smalltalk method should be a few lines at most. Everything small, easy to understand and self contained. That doesn't mean the program couldn't be arbitrarily complex, but it did mean that unit testing was almost redundant as you could test each small functional part in-situ.

Unfortunately, it also meant that you couldn't really show your program to anyone until you were 95% done as it requires a bottom up approach to development. I loved it - if I could get the new C# / .NET stuff into a bubble browsed environment with a little "Do It" popup that used to appear in Smalltalk ("Do It" used to execute whatever you had selected) then I'd be quite a bit more productive. Most smalltalk programmers got used to including a comment in their method that had an example (with arguments if necessary) that you could "do it" and see the results.

Re:U have screen wide enough to fix bugs in bubble

[SimonInOz]

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

And next - four screens!! Your desk starts getting a bit crowded, though.
How about three though? That split in the middle is mildly irritating.

But at least now we can use those wide screens

[Anonymous Brave Guy]

Actually, as I watched the video, the one thing I kept thinking was how nice it would be to use my current (1920x1200) screen efficiently for programming.

The typical Microsoft/Eclipse/whatever GUI today is horribly wasteful: vast areas are wasted on window dressing, toolbars, menus, scrollbars, title bars, line number margins, breakpoint margins, bookmark margins... I'm lucky if more than 1/2 of the pixels on my screen are actually showing me code at any given time, and the moment you mention compiling or debugging anything you're lucky if it's over 1/3 of the pixels.

Moreover, as others have noted, typical code formatting conventions today are wasteful as well. Any arbitrary limit on line width belongs in another century, and IME just results in developers who have a good reason to write a relatively long line messing around with awkward formatting hacks or truncating identifiers in order to obey the letter of the law. Equally, there is no point having lines that average perhaps half that length filling all 1920 pixels of my widescreen monitor's width.

There were plenty of ideas in the presentation that I thought had potential, though many of them have been tried by others before as well. Of all of those ideas, the one thing I wish every IDE would do tomorrow is let me open lots of smaller windows as I navigate my code, organise the windows automatically, and hide all the other clutter unless I actually want it. The Code Bubbles IDE seems to do a decent job of that.

Re:But at least now we can use those wide screens

[Anonymous Coward]

Visual Studio? Shift+Alt+Enter will transport you to a world of wonder. I'm sure other IDEs can do this too...

Re:But at least now we can use those wide screens

[Anonymous Coward]

White spaces and interface ornaments are supposed to *help* readability, it's not about squeezing pixels...

Re:But at least now we can use those wide screens

[Anonymous Brave Guy]

Full screen mode is all very well, but doesn't really address the other half of the problem: while it clears away the clutter, it still doesn't use the space particularly efficiently for displaying and exploring code.

Re:But at least now we can use those wide screens

[Anonymous Brave Guy]

Good use of white space certainly does improve readability, because it allows separation between different topics while visually associating related material. However, sticking a source file with lines averaging say 40 characters long into a 1920px-wide window doesn't help with either of these things, it just wastes all that space to the right of the code. Similarly, sticking a short source file (or a long source file where you are presently only interested in a short excerpt) into a full-height window is wasteful of vertical space. The nicest thing about the Code Bubbles approach, IMHO, is that it seems to allow effective use of more of the screen without mandating some clumsy tiled layout.

As for interface ornaments, we'll just have to agree to disagree on that one. A lot of modern UIs are horribly overcrowded, to the detriment of their usability, and IDEs might be the worst offenders of the lot. Powerful doesn't have to imply complicated, but apparently the UI designers at Microsoft, Eclipse, etc. didn't get the memo. Ironically, if they removed a lot of the details and minor controls and just used more whitespace and a simpler presentation of UI elements, things would probably be a lot better.

1920x1200???

[CPE1704TKS]

I'm still at 80x25, you insensitive clod!

How does it deal with polymorphism?

[swilly]

I can't see how this would work with polymorphism. Since you often can't know what type an object is until runtime, how do you decide what "bubble" to open?

Re:How does it deal with polymorphism?

[ChunderDownunder]

Traditional IDEs will have on hand the available subclasses. e.g. clicking on a sidebar icon for an abstract method will reveal implementations. In the bubble sense, choosing a subclass will open a bubble for the implementation you're interested in - or a bubble for each perhaps.

One possible application may be to visually represent the XML spaghetti known as the Spring Framework. :) i.e. showing bubble sets for IoC defined object graphs. e.g. a 'production' bubble vs. a 'unit test' bubble.

MVC Architecture

[tehniobium]

I could see this being useful for Model-View-Controller type applications (dunno whether that's used in Java).

It would be cool to use your screen real estate to automatically open the view and model belonging to the controller you're coding.

I had a similar idea

[cyclomedia]

Mine was mashing up the way that Visual Studio and SQL Management Studio work so that instead of viewing a whole source file in one go you'd have individual functions (etc) in individual windows. If you unmaximised the code window/tab in my mockup i'm not THAT far off:

http://cyclomedia.co.uk/blog/media/VisualStudioIDEConcept.png

Use the API

[Anonymous Coward]

You shouldn't need to look at the internals of a function/method in another module whilst editing code that calls that function. It encourages sloppy thinking. Just use the API. And if you really do need to see the implementation, opening up another tab in Eclipse is not exactly hard.

Love it!

[FreeXenon]

I Love this. I wish I had this interface for Dreamweaver. This is essentially how I write and debug code.

Re:U have screen wide enough to fix bugs in bubble

[Anonymous Coward]

Most humans are better at organizing items on a 2d flat surface than I think you realize. Vfx compositors have built their complex code like this for 20 years. I've always wondered why this sort of thing never caught on in programming. Maybe it's a left brain/ right brain thing.

Re:U have screen wide enough to fix bugs in bubble

[Anonymous Coward]

Oh yeah, 35" up and 23" left. But of-course, you can zoom the screen in and out, all you have to do is remember what all those minuscule pictures have in them there and then 'you can continue working'. You have 'miniature maps' of the entire workspace. God, how many times I had to work with tools that did this, it was never any help. The 'miniature map' is a terrible idea for text boxes, it's not apparent, like a file list, what's in any of those text boxes.

What about, having a magnifying glass like mouse pointer when the screen is zoomed out, so what ever bubble you point at, the text can get read very well?

Also a plus for such a IDE is, that it would prevent my coworkers from writing a 300-line-method and don't agree that they need to refactor it.

And, your complains remind me in another coworker, who wrote java code with vi until 3 years ago ...

I'm already using a wide screen efficiently

[drew_eckhardt]

The typical Microsoft/Eclipse/whatever GUI today is horribly wasteful: vast areas are wasted on window dressing, toolbars, menus, scrollbars...

I get around that by not using an IDE except to debug Java I've written. In vim each source file, build error log, or document is separated by one character whether they're arranged side by side or vertically and there's no scroll bar or mouse needed. For compiled languages the debugger gets one window with a couple pixels around it plus a scroll bar with watch expression display together with source.

If an emacs user taunted me about running my debuggers in a separate window I might be tempted to get the Conque plugin.

Any arbitrary limit on line width belongs in another century, and IME just results in developers who have a good reason to write a relatively long line messing around with awkward formatting hacks or truncating identifiers in order to obey the letter of the law.

While an arbitrary limit is bad, there's a point at which running into a limit generally means that indentation levels are getting too deep because function granularity is too coarse. You months or years later, your co-workers, and successors will all be happier if you fix the problem instead of trying to squeeze things into the 'letter of the law'. With name spaces and APIs having POSIX-length identifiers 80 characters is appropriate. 120 characters works for longer things.

A one-page function length limit with occasional exceptions is also a fine idea.

Re:I'm already using a wide screen efficiently

[Anonymous Brave Guy]

I guess I just react badly to anyone who issues dogmatic rules, whether it's line length, function length, max levels of indentation, or whatever.

It has been my experience that those who write good code naturally use sensible line and function lengths, don't use deep nesting pointlessly, and so on. They probably have views similar to your final line: a reasonable rule of thumb, and acknowledging the possibility of occasional exceptions.

It has also been my experience that those who say you should never break such-and-such a limit (possibly even enforced by tools at the source control stage) are the kind of people who think a three-line database query in a business logic layer is as complicated as programming gets. Some problems simply have more essential complexity than that, and therefore so does the code that models them, but trying to argue that with someone so hopelessly lacking in both breadth of experience and imagination that they can't even see their blind spot is usually futile. Unfortunately, sometimes those people wind up writing the coding standards at your office or sitting on the committee that defines the programming language or libraries you use, and there's not really much you can do then except make better choices next time.

Innovative!!

[nullhero]

Now can I get a plugin for Xcode? Great idea!