>> Rob DeLine: Hello everybody. It is my great pleasure this morning to introduce
Steve Reiss from Brown University. It is also been my pleasure over the last year and a
half or so to be a frequent collaborator with Steve. Steve and his colleagues at Brown are
pretty famous at this point for having put out the Code Bubbles user interface design for
development environments and he is going to be telling us about that today. Based on
that and the overlap between that great piece of work and some work we were doing here,
we formed a collaboration a year and a half ago, Brown University, Microsoft Research
and Visual Studio Ultimate to basically do a nice combination of what we have been
doing here with Code Bubbles. We've released that as Debugger Canvas in June. So
now there are basically two really great robust implementations of the Code Bubbles
idea. One is Debugger Canvas and Steve is going to tell us about the other one for
Eclipse this morning. So with that I will let Steve get started.
>> Steven P. Reiss: Well, I want to thank you all for coming. I understand you don't
have to come to see this. I am a professor so I am used to physical people being there
and if they weren't there I would be lost. So thank you. I also have two talks today, so
I'm going to kind of rush a little bit and see if I can get to the second one or not.
>> Rob DeLine: He has also had three Diet Cokes in the last hour or so [laughter].
>> Steven P. Reiss: Ask lots of questions so that I get to drink this one too. I also had a
big cup of tea, lots of caffeine in the morning and then I will sort of taper off at the end of
today so I can sleep on the plane tonight.
Okay. So I am going to talk about Code Bubbles making whatever that says.
Programming is fun. I think so at least. The problem is all of my students and everyone
else tells me that programming is still too difficult. I don't know why they are coming
out with that. This is why they don't let me teach intro classes. So I am trying to make
programming easier and one of the things I have been working on for many, many years
is tools to make programming easier in the development environment. It is supposed to
help. What is wrong with today's programming environments? Take Eclipse for
example, or take any other one you would like to have there.
One, they don't match the way programmers work. Programmers tend to think in terms
of working sets or tasks. The task involves a piece of file here, a piece of the code here, a
piece of code here, a piece of documentation here, an e-mail message from somebody, a
bug report, all types of things. You have to put up and view all at once then go back and
forth with. Environments are typically file oriented; they are not task oriented. It is hard
to organize stuff; it is hard to see everything. You have to keep it all in your head all at
once. This makes it fairly inefficient to use. So you have to do a lot of navigation.
Studies have shown up to 40, 50 and sometimes even 80% of your time is spent
navigating, finding what you want. You get no sense of context. They are not
particularly efficient with screen space. I had two displays back in 1990 for
programming. I now have four. Whenever they get around to building the machine I
suspect out in July, I am going to double the resolution of my main displays, two of them.
That is only for one machine. I also have, I have seven in my office actually. I had nine
at one point; they took some of them away, but four some on one machine, two on
another and one on two other machines. But screen space for programmers is one of the
most valuable resources we have. Eclipse is particularly inefficient. I can only use two
of my displays at once. I can't even use four them for Eclipse. Because they are set up as
multiple screens, so I can't use all seven right now, which I would love to be able to do.
They also because you have to share the screen space, these things are very complex. It
is very hard to make new tools here. People do it, but the tendency when you create a
new tool in Eclipse is to abort Eclipse and one of the things that you find out if you abort
Eclipse is you leave all of your files in a funny state, not just your source files, those you
can recover, but your Eclipse files, and therefore you have to reinstall Eclipse all the time
in order to get anywhere.
So what we're trying to do with Code Bubbles is first make the programmer more
efficient, make life easier for the programmer. We are trying to provide an intuitive
environment, something that it does what the programmer wants, works the way the
programmer thinks. We want to support all aspects of development, so we are trying to
complete the full programming process. And we want to make programming easier.
People think it is too hard. We will try to make it easier for them, and my goal is to keep
it fun. So I want to keep my programming fun here. So I am supposed to do a demo, so
let's see what happens here.
Okay, so this is Code Bubbles, our version of Code Bubbles as it comes up. This is
running on a program; this is the program. If you have ever seen, this is based on a toy.
It has a pendulum hanging above and sort of magnets down below. It is called Romp.
And you set the magnets and they have a plus side and a minus side and you can sort of
figure out which is which, and you can see the pendulum flowing back and forth. What
is wrong with the program? Do you see any bugs? Well, a couple of things. One I
wanted that to be red; that's easy. We will do that first. Two, these pluses and minuses
aren't centered. I am fussy about that. I like good user interfaces. Those should be
centered. So we want to deal with those things. Here you have the environment. Let's
do the easy thing which is change the color of the pendulum to red, so where would that
be?
Well, if you know anything about Java, which you probably don't, being Microsoft
people, there is a routine called Paint or Paint Component and that is where all of the
drawing is done. So we will just search for Paint. It helps to spell it right. And there is
only one paint routine in this code so we will click that. There we go. We will get to this
extra bubble here later on. Right now I will just enter something. What the… Okay. So
here is the color and someplace here is magnets are growing red? That doesn't make any
sense. Magnets--here is the pendulum. Draw a pendulum. So it looks like the pendulum
drawing; we can move these bubbles around. It is done, if you can read this, it says draw
a pendulum there. And we want to see what that is. So we just click F3, go to definition
and it brings up a bubble with the draw pendulum routine. Now it doesn't matter where
this is in terms of files. I will use this mouse and probably be better off. Move this
around, the group, you can move groups around if you want, and here there is lots of
debugging code. Here is color blue, so we will just change that to red. Red. And that
should fix the color going to be red.
But you can do lots of things here. You can bring up bubbles. You have search, you can
go in here and look at various routines. You can pull them out, move them around the
screen. I can bring up, if I choose set color, it brings up the documentation for set color,
rather than the code because it is a system library. I can move these around, rearrange
them however I want. I can go look at this routine. Notice the bubbles don't overlap.
Notice that that did overlap when I brought it up. I will get to that. I get to move it
before it does. I don't have to move it. It will settle in place in a little while. You can
bring up note bubbles. We will get to these. You can have notes just sitting around. I
can also create notes and I will show you that later on, that are attached to the source and
permanently attached, but you get some sense as to what is going on here.
These are full-fledged editors, do all of your editing in these things. You can create new
routines here in various ways, so I can go here. If I want to add a new method, I can
create a new method either before or after or at the end of the class. I can create new
fields. Add new fields, add new intro classes, all types of things and also create new
comments. I have to pull my--it's not from that box. Well, okay, I can't do that. Okay.
But you get some sense of what is going on here and what I am talking about.
Most of this--let's go back to our slides. Most of this we had working about two years
ago. So why am I still working on it? What is going on now? Moreover, the papers
came out about a year plus ago and I haven't written any more on this. What is taking all
the time to see why are we--what's up? Well, a couple of things, one, I believe in the
idea, and therefore I wanted to be able to use it myself, so we wanted to get the system to
the point where it is actually usable for real programming. Two, there are a number of,
we ran into a number of problems, some of which just take time to fix, others of which
are actually interesting and will eventually lead to papers and research. Let's look at
some of these problems.
First of all, you quickly realize that languages are complex, even something as simple as
Java when you take it from a programming environment point of view tends to be quite
complex. There are a lot of little features there that are hard to deal with from an
environmental point of view. Especially if you go to the definition, what is a class? Well
if you have an anonymous class that is inside of a method, is that a class? Is that not a
class? How do you want to display that? What do you want to display there? If I go to
all these places that this could be called, how do I find all of these things in inner classes,
in anonymous classes, things that aren't even named? The environment needs to handle
all of this.
Moreover, things we haven't gotten to yet, you come to realize that your systems aren't
just Java systems; they aren't just whatever. They are multilingual. How do you deal
with that? Eclipse sort of does, but not very well. We really would like to have a good
environment that does that even for our own code. Second problem we had is how do
you architect this environment? As I said, putting things inside Eclipse gets tricky. You
tend to abort Eclipse. Eclipse is big and massive. It is not particularly flexible. There
are a number of practical points like you have to use SWT which I did not want to learn
at the time having already known Swing, so we did things outside of Eclipse and we
wanted it to be as flexible as possible so we have our own Code Bubbles running here as
a separate process, talking to Eclipse and we have a little plug-in inside of Eclipse that
does the talking and lets us access Eclipse and lets Eclipse send out messages saying
what is going on to Code Bubbles and Eclipse talks to the user app.
Reason for this architecture will become apparent as we go on in the talk. There are
many ways that we use it. We needed to do reflow and elision, that is key to bubbles.
You want to have the minimum--the bubbles are small. You want to make effective use
of screen space. You want to truncate lines. You want to remove lines that aren't
relevant. We have tried a variety of ways here. We wanted to make sure that it was
natural, that it didn't get in the way of the programmer, so what we do is we use the
complete indentation rules for reflow, so reflow is if you hit a carriage return there, it will
indent it. That works a lot of the time; it doesn't work all the time so we had to do
exceptions, so there are some places where it is going to put it all the way on the right
anyway and not save you any space. We had to make those exceptional.
Elision, you would think you could just use the AST for elision or something simple like
that. Well, that works in about 80 to 90% of the cases, but there are a number of
exceptions. ASTs for “if then” statements with lots of “else’s” tend to be fairly complex.
They don't match the way the programmer thinks. It is not deeply nested; it is linear, so
we have a number of exceptions and actually what we have is a generic pattern-based
system on the ASTs that lets us essentially assign priorities to every AST node for doing
elision. And then we wanted to, we had no idea what the users wanted and so we gave
them everything. So you can run it with no elision or never do elision, never update the
elision if it's there except manually. We also had the opposite extreme, which is always
update the elision. Look where the cursor is and make sure that whatever is near the
cursor is not alighted and anything farther away can be alighted. We also make it easy to
avoid both of these. We have a one button, one keystroke command which will make the
window big enough so you don't need any reflow automatically. Another button which
will get rid of all of the elisions, and other that will re-do elisions. It will re-do reflow
and resize.
So we worried a lot about that. We did a little bit in the initial view on code creation. It
turns out if you are a programmer you are always creating code for some reason, even
when you are sort of thinking about fixing bugs, you are still creating code. You have to
add new methods. You have to add new classes, so this occurs fairly frequently.
Moreover, you worry about your system. It has to be done in the right context. Classes
have to go the right place. Methods have to go in the right class. You have to go in the
right place in the file. You are fussy about these things. You might want to write
comments in front of them, and it all has to be done right. If you don't do it right, then
programmers have to go and correct it later on and they don't like doing that. You have
to make sure how you do it. We have a number of solutions here. We have a very
flexible template insertion system. Actually we have several different systems, they are
simple ones; they are user templates. There is an AI-based system that we have plugs for
where it will learn what your formatting is and then reuse that. We haven't gotten that
debugged yet, but it is sort of there; it learns how methods are added. We have intuitive
insertion commands. You can just type in the right place and then pull it out into a new
bubble or you saw the ad things there. We have added things in a lot of other places as
well.
And we are working on various places where you know you need a method and we will
create it automatically and try figuring out logically where the right place is where you
have an undefined method or where you want to create a test case or things like that. We
have performance issues, as you would imagine here. Programmers expect the
environment to perform. What happens on keyboard input? You think what is going to
happen when I type a key? Not much, right? This is part of the second talk actually, but
we might be able to click on it here. Tell me if this shows anything, yeah. It does. This
is what happens when you click a key. And this is just an abstract point of view of what
happens when you click on a key. So you have all of that stuff happening in the main
thread where you handle the key, and then you have a number of asynchronous events
happening down here, multiple, sometimes multiple times. How fast should keystrokes
be? All of this has to get done every keystroke. So we had that problem. Are we back
there? Yeah.
And we also found that the graphics, doing fancy graphics slows you down. So what we
did here, a number of solutions, one the graphics is a lot simpler than maybe the original
videos. You might not notice it, but they are not as rounded. Turns out that 25% of the
time spent in Code Bubbles is still spent drawing the group boundaries. That is where
most of our runtime is. And we also do a lot of background threading. We have a big
thread pool and a lot of the work is done there. And then Eclipse has its own thread pool,
so we are really making use of all of the cores in your machine. And we have lots of
them. Another problem we had is, yeah?
>>: Is it okay to ask a question right now?
>> Steven P. Reiss: Sure. Then I get to drink more [laughter].
>>: So what is the exact reason that you guys are tying into Eclipse? I mean do you
need to tie into Eclipse to actually have your own IDE that can operate on Java or operate
Java?
>> Steven P. Reiss: I didn't want to really implement all of the debugging, all of the stuff
that Eclipse does.
>>: Oh, okay.
>> Steven P. Reiss: In theory, another reason we had it separated like that is so you can
tie into any environment you want. If you wanted to tie into NetBeans or Visual Studio
in theory, the interface there is fairly simple. Actually I want to tie into Python at some
point, and not necessarily use Eclipse Python which is huge and messy. I am not going to
implement the whole debugging framework. I am not going to implement the parsing
compilation. I'm going to let Eclipse to my parsing for me.
>>: [inaudible] the interface that you are doing when you are navigating your code and
[inaudible]?
>> Steven P. Reiss: We are doing mostly front end stuff. We do have our own--we are
doing more and more of the backend stuff, but I am leaving the groundwork; I didn't want
to re-implement it. I could have just put something else there. So what does undo mean
in this framework? If I hit undo in Eclipse, what happens? It undoes the edits in the
order that you actually did them. That doesn't make sense. You think about each
individual bubble as its own editor. You want to undo in that bubble. What is the
problem with this? Well, there are intricacies; you can have two bubbles with the same
code or one bubble with a class and another bubble that is a function of the class. They
are overlapping. There are dependencies between these undos. So we have to figure out
what this means. Undo in general will undo edits in the current bubble. It does what the
user expects, however it detects internally what the dependency is and if there are
dependencies that it can detect or that it does detect then it will undo all of the edits in the
other bubble to make sure that it is consistent at that point. Otherwise it won't.
This seems to work the way people expect it to, or at least the way I expected to. I
haven't had any problems with it. But it was an interesting case. The other thing you
find out if you start using this environment for any long period of time, and this you can
see up here is an overview of what is going on. And let's see where are we currently? Oh
you can't see in that picture. It is just a little bit of the screen. But this is, you can see
there are only three bubbles here, three bubbles there, it is huge. It becomes messy. If I
use this for several hours, the whole top display becomes like this. Screen complexity
just gets overwhelming, because you have your whole history there. And it is not
particularly well defined how things got laid out, so we have tried various things. The
first thing that happened, is it used to when you popped up a bubble it popped it up right
next to you; typically our bubble is right next to you, and it has to move things out of the
way. That moved things out of context and you lost your context that you had before.
You lost your layout that you had before. This was not good.
So the first thing we tried and we still do is when you pop up a bubble, it will look at the
group in general, these things that are the same color, and pop it up to the right of the
group and move it there. So you don't rearrange the group every time you add a bubble.
Next thing we did was give the user control. This worked in some cases and didn't in
others. So now what happens when you pop up a bubble is it will sit there for 2 seconds
before it drops in and moves the other bubbles out of the way. But you can move it in
those 2 seconds, and move it to wherever you want it to be fairly easily, just right click
the mouse on it and move it. And after you move it, then it drops in essentially at that
point quick, within a fraction of a second. So that was another thing that we tried and it
seemed to be quite successful. That has become very natural to me.
Some of the things that we are working on actually a student did one of these, and never
checked it in, which means it is not usable. Automatic layout. So I want to layout the
screen. So you can do this in two ways. You can do the simple thing which is just
rearrange the windows so they are nicely spaced and columnar and layout. You can also
do it intelligently. You have relationships, you know, you pick this bubble from this one
because it was dependent upon it, because there was a call there. We have the call
relationships. We know which bubbles are variable declarations. Maybe they should be
on top. We know which are class bubbles, maybe they should be to the left of all of the
method bubbles of that class. We are working on automatic layout feature which takes
all of these relationships into account and reorganizes your screen for you.
So this is some of the problems we came into, none of which are interesting enough to
require a paper, but all of which took time to solve and make sure we had the right
solution. Now we have a number of enhanced features. We do full debugging, just like
Debugger Canvas, and let's see; we can demo this as well. Ah, bubbles, bubbles,
bubbles--why did it shrink? So here what we will do, is we want to, the second thing we
want to do is figure out where the pluses and minuses are, so that is probably in draw
magnet. So here is the draw magnet, and as you can see it is very easy to on ally things;
we will go there. This will go there. Pops it up there. We will move it--well that is if
you have a mouse that has a right button. And it is that window; we will take this and
move it over here. And move ourselves over here. And let's see where we are drawing
strings. So let's set a breakpoint there. And now we can just debug it. You can go here
to debug. And we can bring up a variety of different views. And we can start the
debugger. And of course Eclipse is not particularly fast. That is a bug. And what you
get when you hit the--when you start the program, is a breakpoint; there is a breakpoint at
the start of the program. We will just continue at that point. It brings up a bubble for
that. It brings up the bubble for the breakpoint. Breakpoint occurred in a different
thread, so it is a different group, and it came below.
We layout different threads vertically and the same thread horizontally. When we come
up you get a bubble showing your source and then that is again completely editable. All
of your features are there. You can do anything you want with that bubble and you get a
bubble showing the stack. Now you can take here and pull out views from the stack and
look at the--I need more screen space obviously. Particular frame you're looking at or
you can take a look at the variable and you can look at it here or--I don't know if that is
useful in that window. We are going to pull this out, look at variables this way. Now if I
step, these will be updated automatically. If I can at any point go here and say freeze the
values in this, and what it will do is now these values are going to be preserved as I
stepped so I have a historical record of what the values were. And freeze also saves into
a certain depth. This also shows; it is a bluish color to show it is frozen, cold.
So what we can look at here is--it is also easy to make bubbles go away. What is
interesting is post, so X and Y, 00, so it is looking, so here you can see that it is drawing
it, the string, the plus or minus at 00, which means that it is starting in the middle of the
element. We don't want it to do that. We need to offset it. And that is where you get
into understanding why the bug is and you can go and change the code. Try offsetting
that. You can say ent equals post doc at X. What doesn't it like about that? Oh, okay.
Okay, let's float. Okay, now it likes it. We can just replace this with XP. And if I save
this it goes into the Eclipse facilities and it is still running. It just starts at the beginning
of the function again and does in-line code replace, and I can just continue. Now this
won't be any much of a surprise, but--okay, I don't know what it did. Popped new
bubbles up, new values of this. Oh this is doing funny things when you hit a button, isn't
it? Because this doesn't expect those buttons to be hit. You can bring these bubbles
back. We stepped into--when we clicked on our mouse.
The other thing is this can get real complex as you can imagine. It shows you what is
going on up here. Putting a laser on should not cause buttons to occur. Okay, but you get
a sense of what is going on here and what we can do. In full-fledged debugging, all of
these features you want, a couple of extra views which I will show you later on. Let's go
back to the talk.
Now the buttons should do the right thing when we get these things synchronized. One
of the things that you find out was bubble layout is a problem. You're getting all of these
bubbles; they are coming up and if the sessions tend to be long, I will sit there in the
debugger for a half hour on one particular program. I will hit step or go or continue a
couple of hundred times. What is my screen going to look like? There is lots of data for
the programmer to simulate. Layout is important to providing the right context. We have
automatic layout heuristics here, to the right of the current thread, below if a new thread.
We try if the user creates a new window, they went in browse to what is going to be
called instead of breakpoint there. We are going to reuse that window if we can. But we
need to pop up the stack view below it, so we are going to try finding our arrays and
putting this stack view below it, and making sure things are in the right place. We want
to remove unnecessary windows. If we step in and step out again, you probably don't
need the window that you stepped into, so we are going to remove it automatically, either
then or at the next step. But you can always click on it to bring it back very easily if you
really wanted it. But the default is to make it go away.
So you've got a whole bunch of layout heuristics here. We are still working on this as
you can see, especially on a small screen it doesn't work particularly well. It works much
better on a larger screen where it has more space. Another thing we have, we have debug
history point put in there. So you may have noticed at the bottom of this display here,
down here, let's bring this window up. You can see what's going on. And this is a fixed
window, which doesn't want to resize right now. Why doesn't it want to resize? There it
would resize. And essentially this is where you were at one breakpoint and then you
went to here. We can go here and, this is a history of our session, and we can show the
source at that point or show the stack at that point.
So we have a full history of the debugging session. You can go back and forth and see
values at that point. We also have--did I bring up here--yeah performance analysis in the
debugger, so you can see where you are spending your time. In here it is in physics
initialization. The program is still running, apparently. Some thread is still running. But
it is trying to take into account which threads are stopped and everything. You can see
where you are. And you can use this to go to that method. Now the method happens to
be small here so it is going to bring up the whole class. It has heuristics as to what the
user really wanted. If you bring up an enum, this is where nums come into play. You
don't really want to bring up just the declaration of that variable. You want to bring up
the whole enum class. If you bring up an interface, if it is a very small interface, you
don't want to just bring up the function of that interface. You want to bring up the whole
interface class so that--there are heuristics as to what is going on, what you should bring
up when the user selects something there.
So let's go back to our slides. We don't really want to run Word. We are running too
much on this machine as it is. Go to current slide. So we do what we call active
debugging. I need a new name for it. Essentially we have something running in the user
program, a separate thread, very unobtrusive. It is essentially doing stack sampling.
Occasionally it is talking to a server which can talk to multiple user programs at once and
that gets back and it can talk through Eclipse and find out what is going in Eclipse, and
actually send commands to Eclipse or get information from Eclipse, or it talks mostly to
Code Bubbles, back and forth. So what do we use this for? Well performance
monitoring is one thing. We are getting stack samples, so we can figure out where you
are spending your time. We can do dead lock monitoring, understand what threads are
locked at which point and as soon as these threads come within a millisecond of when the
threads actually get into a deadlock, we can tell the user, these threads are deadlocked.
We can do thread state monitoring, so that if you looked at what it said about thread
states, it would tell you that it is doing I/O, which is string system routines. We change
these every millisecond, if it gets out. You see a threaded string mostly I/O; it will tell
you that. Normal environments don't. Eclipse doesn’t for sure.
When you get to a breakpoint, we can go and give you the last couple seconds of history
for all of the threads, at that breakpoint. So if there is some sort of thread interaction, you
can see how, what all of the other threads were doing to interact to get to that point, or
even what your own thread was doing before it got to this point. So we save that in
circular buffers. And we have a number of things we are working on, detecting abnormal
programmer--excuse me--that we want to use this for. So that is debugging.
Another thing you find out after using this environment is that context is important.
Programmers are used to having context. They are used to using files. Files provide
context. Why is this function here? What is it doing? What is in the getter setter region?
So it is probably a getter setter. Or it is in the private region. It is in the public region, or
it is associated with this other function here. They organize your system. They are used
by other tools. And they are used for reading code. If somebody wants to understand the
code, they may not go into Code Bubbles to begin with; they may just start reading the
files. Some programmers do that for some reason. I never understood that. I only do it
for student code where I want to grade the students.
Function location in the system is important to programmers. They care about where the
function is. They care about where the files are and how the files are organized. They
care about how all of the system is organized and they care about things like readability
and comments. So what we do? Let's see if we can again show some of the views we
have here. We will go back to our regular session. Now the simplest thing that we can
do is just show the whole function at once, the whole class at once. So we have class
bubbles. They tend to be wide enough to hold the whole class, which isn't good on a tiny
display. But you can see that we use elision and obviously tooltips to show what is going
on in the elision. We use elision a lot here to show essentially the structure of the whole
class. So that is one way that you can do it.
You can also go and get an overview of the class, which is another form of that, and it
shows you where the comments are, where the fields are; these are methods and you can
then again get tooltips to show you any of these. You can pull these out. You can get
code. You can also use this if I want to see this, I can insert a comment, insert a method
before or after field so I can use this for inserting into the file, and I can also use this to
rearrange things in the file. I can move things around either within the file or between
files, so it is sort of a proxy for file that you get that way.
Now you might want to get other overviews. So let's go over here and create a file
overview; and here you can see the files that are being used within this local space here in
this window. And if I go into editor it will show me where in the file that is, which file it
is and where in that file and the other editors correspond accordingly. And this will just
show all of the files within, not just the region, but the contiguous space. So if you have
lots of bubbles contiguously even though you are just showing a little bit, it will show
that whole space or you can create working sets. And it will show just what is in that
working set. And these working sets can be expanded, so if I want to do this entire thing,
and then go over here and I lose that bubble. So you have another sense and again you
have tooltips here to show you what is going on, show you the code. You can use this to
get context information as to where you are, where this is in a particular file and what is
going on there. And the other thing that we have is, let's see, so let's go in this package.
Package viewer, so we have a viewer of the package where we can show all of the
classes; we can choose whatever relationships we want to have displayed. We can
choose the type of nodes we want. We can show methods, not methods and we can move
these things around. We can click on a node and show the sub graph for that node, which
didn't work that well.
So we can expand the nodes, you can collapse nodes by package. There is only one
package here. Expand, go back. You can get it to do--if you like labels you can go
labels; labels tend to take up space. I tend not to use them but if you like labels, you
might be able to see that. I can't. My eyes are not a good. You could make it better,
bigger. Now you can almost read them. You can also change layout methods and things
like that. But I want to see everything and deduce by that. In theory, that should work; in
practice I broke that. You can go down to the method level, showing context that way.
Another bug I have to fix on Tuesday. Wish I could read the display. There are various
ways of showing context. Next thing you find out in software development it is
collaborative. People keep telling us that. I keep doing my own work, but people keep
telling me everything is collaborative. What does this mean? Well, it means lots of
things to lots of people. Everyone has their own definition. Some people just pair
programming. How do you support that? Others, it is teams of programmers. Other
times it is geographically diverse teams. Others it is just working on a common source
base, which might be a real common source base if you are an old CVS person or RCS
person or it might be a virtual, source base if you use GIT or Mercurial or SVN.
Individual sources with merging, that is that. So how do we handle all of these cases?
What can we do? How do we get bubbles to work with that?
Well, we have a number of solutions here. One, you have to support communication
among programmers, so we have chat bubbles which will work on all different kinds of
chat systems. I think it works with all of the major chats at this point. I don't know what
they are because I don't do chat. I am told that it does. It also saves chat histories, makes
them permanent, so you can go back up tomorrow or next week and see what happened
with chatting a week ago or whatever. You can send and receive working sets. You can
say here is a picture of my screen, or here are the bubbles I currently have up, send them
that information over and they can bring up the same bubbles on their screen however
they want inside Code Bubbles. And we have a new feature for educational chats where
students can get into a queue to talk to the TA's but not learn the TA's chat ID, whatever
you call it, login, so they can't bug them all the time. They only can bug them virtually.
We have e-mail support. Again, you can send and receive workspaces and other
information from bubbles. We have note bubbles. I showed you notes. Notes are saved
as part of the project. They become permanent. They can be added as annotations to
code, so you can click on a piece of code and say and a note here, and it will tie that note
in to that code and it will have an annotation on the left; I think it is a yellow N right now,
and that will show up for everyone, everyone using this project. And you can click on
that and bring the note up at any later point in time, so notes can be saved that way. They
also are saved as part of your display and as part of the working set, if you save the
working set.
The other thing we worked on recently was the programmer’s log. Now scientists and
researchers have logs. I have a stack of notebooks which is right now about this high
with all my notes in them. Programmers should do this too. They are very valuable for
understanding old code, for understanding your motivation for going back and doing that.
And if you're working with other people, collaborating, understanding what they were
thinking of and why they may have done it this way. What is the problem here? Well
programmers aren't going to do any work. Programmers have enough to do without
adding new responsibilities to them.
So we wanted to do is make it very easy, so one of the things we did, let me see if we can
get back to the demo one more time. And if we bring up a new thing, it notices we are
doing something new, because we are in a new space and there are no bubbles around us.
It wants to know what we're doing. So it is going to pop this up here, and we're going to
say go back to our previous task, or we can say we want to start a new task, and then we
can give the task name, and then we can give it a description, if we are willing to, and
then we can just create the task and then we can go up and bring up the field, bring up all
uses of that field, show what is going on here. Bring that up. We can edit in various
ways. If we decide we want to add some comments to our lab notebook, we just hit F2
and it brings us up a comment bubble where we can add notes, add attachments, add a
screenshot. I wonder if that works on the Mac.
And then any time we want to we can go back or we can go here and show the
programmer’s log. Now the programmer’s log has massive data; it is also recording lots
of things automatically. We are trying to minimize the programmer’s work. So we can
go and select the task that we are interested in. We can just look at things related to a
particular class, or particular method, we can order it in various ways, and then we bring
it up we get this logbook display. And it basically has all of the things that we did before
when open; here is our sample task. Notice we added this particular function. It is down
at the function level because it knows that. And it didn't bring up the attachment, so the
attachment didn't work. If it would've worked, it would've shown the screen display
there.
This is all saved in the database. If you are working on a team project, you can have it
saved in a database for the whole team so you can show up the logbook of the whole
team at once instead of just your logbook if you wanted to. It will show options for that
as you are bringing it up, user options if it knows there is more than one user. So we
have that type of capability as well for collaboration. No, the one is that button. And we
have to get through this. Okay, next thing you want to do in collaboration is sharing
source. So that is the Code Bubbles view that we had. What we can do is we can just
add another Code Bubbles. It is talking to the same Eclipse, sharing the same source, we
made this all work. You can add it here, it will show appear immediately. You can add it
here; it will show up here immediately. You can even add it here if you want to use
Eclipse at the same time you are using Code Bubbles and it will show up in both of these
immediately. It is all synchronized, editing.
Then you think about if you are going to do collaboration, then these days you may as
well use the cloud. There are lots of things you can get with the cloud. Problem is that
you have to set it up in some way, and we want to minimize that. People worry about
security and privacy. I talked to Google. They won't share their code with. They don't
want me to ever see anything about what the code they are using this for. And other
companies are the same way. So how do you do this so that you can go access from here
to the cloud and not share any other things that are going in between? Well, we could
start here, and one of the things that we could do is say put that all in the cloud and just
go in display. And so you can run DNC or some other protocol there. You can sort of
get this working. The problem is the Mac has different key strokes; it's command
something rather than control something. So you have to do some sort of mapping thing
there. This doesn't work with that. Different screen sizes you may need to deal with,
rather than running it here, lots of things that this is a little inefficient for. Also I don't
trust network bandwidth for some of the graphic stuff we are doing.
So this is another model you can use. Just put Eclipse and Mint in the cloud and your
front end just talks to them. We have a separate front end anyway; this should work,
right? Why won't it? Well, you have things called files which are over here. Your
source is stored in files. Can this access those files? Not particularly easily. So you have
to somehow make it so that this can access the files here and get it to all of the right stuff,
so what we ended up doing is running Code Bubbles in the cloud in server mode, quote,
which doesn't affect very much. Running Code Bubbles here in client mode, because we
have multiple Code Bubbles, they collaborate with one another. This just doesn't happen
to put up a display; that is what server means. But whenever the client mode says
essentially do whatever you normally would do, except don't try to access any files that
are part of the project. Any files you want that are part of the project you go and request
from Eclipse directly. Actually you just request them this way and it will get them from
Eclipse or from the server, depending on what kind of a file you are asking for.
And this is fine if you are VPN’d in; you can talk to your cloud and that is what this link
is. I wanted it to work from home so I could run Code Bubbles at work on my office
machine and still work at home without having to VPN because I don't like VPN’ing. So
we have this little piece of Mint here which works over the web and we encrypt
everything going through there and this Mint will talk to that Mint using the user key
which you just save here and here, and now I run at home and display everything that is
going on at work, or I can have multiple users doing this simultaneously if you want that.
Is it useful for multiple users working this way? Well, two cases where it might be. You
might want to think of doing remote pair programming this way where you can sort of
share the screen. And the other thing is very useful for is when I want to use seven
displays, because I am running on three different machines, same Eclipse, same backend,
but I now have all Code Bubbles on all of my displays at once.
In general, we do support and we will get into the version management here with
software development tools. We have testing tools. I am going to skip the demo because
of time, but we have a test bubble up here which ties in, finds all of your JE unit tests and
shows you the status of them. It is able to, it runs as a separate process talking to Mint
talking to Eclipse, talking to Code Bubbles. It actually puts a little code in the application
before it runs it to instrument to get test coverage so it gets branch coverage. It gets call
coverage and block line coverage information and reports that back. It can run either
continuous; it runs in the cloud if you are running in the cloud. So that doesn't run on
your own machine. It will run either continuously or on-demand. So you can do
continuous testing because it is talking to Eclipse and knows what files don't compile
right now. It knows where changes are made, and it takes all of that into account in
figuring out what test cases to run. It supports test debugging, so you can click on that
and run it, create a new debugging session for that test case and debug that and it has
support for creating new tests.
Version management, we want it to interface with different version systems even within
Brown, there is no consistency. Code Bubbles is currently under both GIT and SVM
control because different people want different things. It also means that I don't trust GIT
enough; I don't know it well enough, so I understand SVN and it is safe under SVN.
Then I can play with GIT and if I clobber things I can always go back. Lets the user
check-in and checkout; that we actually don't do yet. We want to provide the user with
information; again, this is done as a separate process. We actually want to have the user
know what other people are working on, so one of the things that BVCR, our version
manager does for our Code Bubbles, is whenever you make changes and whenever you
save it will do a diff use a version management system to do diff and send the results
encrypted into a central data store someplace identified by some random key for this
project and some random key for the user, so that no matter who owns this data store they
can't tell anything about what is going on because it is all encrypted, and the only people
that can decrypt it are people who actually have the project there.
And what it will also do is when it sends this it will say give me all other users for this
project. Give me the information for all of the users in this project, so it now has all of
the changes that other people have been making, so it can display, and we haven't gotten
to display up yet, but it can display the information when I am showing this function,
when I am adding this function, or when anyone else has changed it that is currently
working on it. It can show that simultaneously. So we have that type of capability
without having to do any setting. Use something like the IBM, whatever they called the
system. You have to set up a database. You have to set up a project. This is all
automatically set up. It just works, which is the way you want it to go. So that is all of
that.
Future tools and directions. Lots of things you want to do and we are still planning on
doing. Integrated code search, we have a nice project for code search. We want to get
that in. We want to do Python because people keep asking for Python and students want
Python, high school, things like that. UI builder, Eclipse doesn't have one. NetBeans
does, but Eclipse is very primitive in that sense. We want to do it right, JML
specification bubbles. Intelligent data structure display, automatic creation of working
sets, here is a task I want to do. I want to make a change to this line. What other bubbles
are going to be affected by that? Can you bring all of those bubbles up immediately so I
have some sense rather than doing it incrementally? Automatic screen layout as I said.
Visualizations of program behavior; that is my second talk, flow analysis tools. We have
a flow analyzer. What information does the programmer really want from this? What
should we be displaying? How should we display it?
An environment for doing web applications, this is where you get into doing multiple
languages, and there are a whole bunch of missing features as well. Main ones a
programmer, an Eclipse programmer would notice Word quick fix and re-factoring. We
have limited support for those. We have re-factoring, but that is about it. It turns out that
the implementation of these in Eclipse is not done right. They are sort of integrated with
the front end and rather than being separated out, which you think you would be able to
do, so getting these with our model of how we use Eclipse is difficult. Supposedly
Eclipse 4.0 is going to fix this. I haven't seen that yet. And a number of other things that
people have asked for.
So how are we going to do all this? I am me. I write a lot of code, but not that much.
Our plan is not to do it. We open sourced this project, so we're going to try to get people
interested in this. You can download it. You can play with the code. You can contribute
back. It is sort of documented. There is a tutorial that is the most helpful thing these
days, doing the type of thing that I was doing there, except doing it right. And that is
where we are coming from, so a lot of acknowledgments. If you want to open source and
work on it, I don't know if Microsoft gives you any time. Not on my machine. I did that
on the plane too, so… At least the person wasn't sitting there when I did it.
Any questions on this part of the talk? I will see if I can think about setting up, going
through the other talk very quickly. Okay, what I have to do is I have to remove this talk.
Yes? No questions. Okay so, that is one thing that I had to do. Okay… CD… Talks…
Anybody understand PowerPoint on the Mac? If I open this talk in any other way
normally my demos don't run. If I open it from within a particular directory using an
open command then the demos run. I have never understood why that is or how that is.
So we will see the demos run. What I am trying to do here [inaudible] okay, I think we
have everything here.
So this talk if it ever starts is about what is my program doing? So what the bleep is my
program doing is a question I often ask. And what do I really want to know? I want to
know what it is doing in my terms, in terms of what I understand, in terms of where I can
fix it. What should tools tell me? Well, that is what I want them to tell me. What you
actually do when you have hard problems about your system? Well what I actually do is
I work on it for maybe three or four hours or maybe two or three days if it is really messy
and I actually have time, and then I will give up. And I will come back to it six months
later or when some user complaints about it, and try fixing it again then. And the third or
fourth time I come back maybe I'll figure out what is going on. On some of these I
haven't.
So here in Bubbles one of the problems we have is that the squiggle underneath the
variable for errors sometimes becomes wrong. That should be easy to fix, right? Figure
out what happens there, how hard can this be understand? Can you write a specification
for this? Formalize it, not particularly. Programmers have hard problems. This is not a
particularly easy, well let's go back. How hard can this be? I think I am supposed to
click on this. Remember that display I showed you with everything that happened on a
keystroke? That's what happens here. That's what you have to worry about. Not only is
it that long list of things and then you saw that there were certain lines in red, about 10 of
them, those are the things that can affect it. But you have these five tasks down below
which are running asynchronously, which can also affect it. And timing can affect it.
And it is usually right. What is the situation in which it is wrong? Programmers have
hard problems and most of these problems are dynamic.
So in Code Bubbles, the underlining is one, the error message display gets out of sync,
the breakpoints are off after editing, sometimes. I think this is Eclipse's problem because
Eclipse has the errors in the wrong place, but I am not sure. The bubble interaction can
be too slow. What is slowing it down? And every now and then you get into a deadlock.
Not usually, but every now and then it happens. I have another program here where I
have multiple threads running; it is multiple particles, 100,000 particles interacting. I
gave it, took a serial implementation which I did for class and then wanted to make it
multithreaded so I converted it into multithread and I only getting about half the speed
that I expected. It is highly paralyzable. What is going on? Why am I not getting the
speed up? Typical problem.
I have a web crawler, multithreaded. Each thread grabs it; there is a thread pool in the
thread grabs the URL, it goes out gets that URL and gets the text for it, processes it, saves
the information to a database, saves any new URLs and goes back and gets the next.
Works fine most of the time, does real well. But every now and then it sort of hangs for
15 to 30 seconds, why? What is going on? It is unlikely that if you have 256 threads or
even 64 threads that they are all waiting for web pages. That just doesn't really happen. I
have a cute program which does code search. So you give it a set of test cases, a
signature set of test cases and a set of keywords and it will go out and find, you can use
Google or any other engine, find the first hundred or 200 things that match the keywords
and then take each method and now you're searching for a method and as a possible
solution it will apply all types of unsafe program transformations to that solution trying to
get something that matches the signature and can compile, and then it will run that and
compile it and run it against your test cases and report back and reformat anything that
actually passes.
Why does it take longer than expected? What is the slow down? It was unusual. The big
question I had is why does it need 24 gig of memory most of the time? I have 32, so that
wasn't too much of a problem, but I don't want to use all of my memory. And why does
one requesting to block another? Typical type of problem you have in dealing with large
systems. I have a peer to peer network; if the whole network goes down so a lot of nodes
start interconnecting at once, not just a single node, the network order is sometimes
wrong. That you can understand. But this one is a problem I have never figured out. I
will run fine and then after a month or two months or sometimes two weeks whatever, a
node will run out of memory. Now it's not like its memory is going up in any way. The
memory is flat. All data structure sizes are flat. And all of a sudden it runs out of
memory. Something weird is going on in the system at that point. I have no idea what.
How do I tell that? How do we get a tool that will tell me something that is going to
happen a month from now?
I can't do detailed analysis. So there are many types of runtime problems. None of them
are easy. Anyone have a magic tool? What we need is high-level behavioral views, realtime views, the ability to monitor long-running systems, avoiding information overload,
because you can get too much. We've spent the last decade trying to understand what
works and what doesn't here. So here is Solar and the problem is multiple threads don't
get the expected speed up and let's see if this works. No, this does not work. That is
because we started PowerPoint for the other demo and we just loaded it here.
>>: Do you have a tool that can solve these problems?
>> Steven P. Reiss: Yeah, well, some of them.
>>: What does your Taiga network do?
>> Steven P. Reiss: What does Taiga do? Taiga was designed for internet scale
programming. It basically lets you have what we call an outer face. It is essentially an
interface to say a web service or a set of web services and it will go out and find which
one best meets your criteria, passes all of your--you specify it with test cases, so it will
find one that has this interface capacity for your test cases and it will automatically
switch it out and pop something else in if it fails. And you can code to the outer face and
you don't care what the implementation is. And it is designed to run wide scale and that
is why it needs a peer to peer network that way. That was another system, okay.
So PowerPoint is no longer running. Now if I open it this way… As I say, if I start
PowerPoint up another way, the demo runs fine. So here you can see the display. Here is
what we are showing. This is what is going on in the various threads. Magenta is
weight; yellow is running synchronized; green is running; it is continually drawing. You
can view this this way as well. It is a little easier. You can see what happens here is a
goes through phases. And there is a phase where all of the threads are running, a little
synchronization but they are not blocking; the lines are where they block, like there. And
then you have another phase where three of them are waiting. What is going on? Well, it
tells me that there is a problem. It doesn't tell me what the problem is. And what is over
here is what is happening in the classes and that doesn't really give you any information.
What I have to do is click that. But we can quit that later on. And so we have that.
We have another tool called Jove, which gives you more detailed information. It
basically gives you block counts while the program is running. That doesn't really help
in this case; the basic blocks don't change between those two phases. These two are
great. I love the visualizations. They are a lot of fun to run. They just don't solve the
problems. They have a little bit too much overhead by a factor of two or a factor of four
slow down. It is okay with an interactive program, but marginally it is not something that
you want to run for a month with server programs. We have to be able to run them in
real systems and these only run where I can actually have the whole code in advance. It
won't do something like Eclipse. You need to provide more detailed information. At the
same time we have to provide less information. We want to concentrate on just what the
problem is. So let's look at these problems in turn.
Code Bubbles, the interaction is too slow, so we can try a demo here. Now probably we
should get rid of this. There. So this is what is going on in Code Bubbles right now. We
can click on one of these and get CPU information. We can click again and get detailed
CPU information and you can get some sense of where you are spending your time and
even if you don't like CPU, you can get--what's this one? This is threaded information,
what the threads are doing; the socket information; the socket I/O is going on and you
have reaction. This is I/O, heap information; we have lots of different things you can get
information about and this is done with low overhead.
Actually what is cute about this program is you get to specify what overhead you want to
have. So I can say I am willing to give you 10% or I am willing to give you 1/10 of 1%
slowdown in the program to get this information, and it will adjust the way it collects the
information which is both stack sampling at whatever rate is needed to get that, and also
detailed, also instrument the code at times to get the usage counts or allocation counts.
And whether it can do that will depend on, and how often it does that and for how long it
does that will depend on what overhead you are willing to allow it to have. Now this tool
will also give you a view of what is going on in memory.
This is showing object ownership in the application in Code Bubbles over time, and it can
do it, again, it is very low overhead to get this. It is not trying to dump all gigabyte
memory. It dumps a sample of that and reconstructs this from the sample and here
everything zoned by root, and cycles are effectively data structures. You can see there is
a data structure 45, which is 93% of the memory, and color is where you actually have
memory. So here you say character array for strings. You can see this is the overhead
for Java strings here. And this is the overhead for URLs specified as strings. And you
can get information like this, and here you can see this is all coming from a bass tree
model; 63% of that is. That is the search space. This is telling me that most of my, 63%
of memory is used for storing information for searching, and that is just simple searching.
Let me get back to where I was. Most of the rest of this is similar. A lot of this is also
bass and stuff. But you can see where your memory is by ownership. It is using a whole
bunch of heuristics to figure out what it means to have ownership, because the only
information it has, it has A points to B, class A points to class B and is deriving
everything from that. So some problems we can address this way. Let's go back to
where we were. We actually went back. We did that. Okay so, this solves low overhead
monitoring. You can run this on server programs, no problem. It is designed for servers
because it gets its information slowly. It doesn't solve the program’s problem programspecific views.
One of the things we figured out here is that generic tools only solve generic problems.
The problem is programmers don't have generic problems; they have specific problems.
You can use these tools to solve the problems after the fact; once you've solved the
problems you can go back and see where the tools showed that to you, but you won't see
it when you're running the tool. So there are lots of great software visualization papers
which say you can see this, but I bet they understood it before they saw it. I know I have
written papers that way. I know other people who have too. You see it after the fact.
You don't see it when you need to see it. So you need tools that will do that. So here
everything pauses. This is the first tool we did. This is a visualization. It looks a lot like
the one we did before. What is different here is that the colors mean different things. So
here the colors are coded in terms of what the program is doing. So it is program states.
We actually went in and labeled this. This is, you know create a thread state, ready to
exit the threads. Here is save future URLs, wait for HTML, all those different things the
thread, each thread would do, and we can color it that way.
Here is what is happening when it is in a bug, when it pauses. You can see the state.
Saturation shows something, but what you find out is that this is all normalized URL. All
the threads are waiting for normalized URL. You go look at the code and yes indeed
there is one thing that happens there and that is search look@robots.txt. It turns out the
code for looking@robots.txt is the bottleneck here; it is stopping everything, and this tells
you that. So why don't use this? These displays work. Well, the reason we don't use it,
and I don't want to run a demo, is because figuring out how you instrument the code,
whether the events, whether the 16 states for this thread and what are the events that
indicate those things, is just too much work. Programmers are not going to do that even
if it is going to save them a lot of time in the long run, they are not going to do that.
So how do we simplify this? Well in general you can't. But you can look at specific
types of problems. Most problems are in the small number of categories. One we have
looked at pretty much so far is transactions, tasks and threads. We have looked a little at
locking. So we are looking at systems that have multiple transactions coming in. They
might be user interface events. They might be actual things coming from the web server
requests. They have tasks, they have threads which handle these and they break the
transactions up into tasks.
We need to understand all of that. We did a visualization. We want to automate this
whole process. In order to automate the process we need to find event handlers. We had
to find significant subtasks, whether the subtasks, we want to do that all automatically.
We have to find the threads, which ones are relevant to your particular problem. What
are the tasks that are relevant to your particular problem? I don't know how to do all of
this automatically at this point, but I can give you some hints as to which ones might be
relevant and let you choose. We have to find queues, you know when the task gets done
it gets put in a queue and gets later taken off. It turns out we really don't need this. We
can avoid that. We figured out how to do it; then we avoid it. And we need to provide a
customized time-based view.
So this is what we end up with. I want to leave time. I don't know what view this is
because I have it as a demo. So let's see what happens if we run the demo. It might
work. Solar. Now we didn't get rid of that. Nope. And it does static and dynamic
analysis; all we really need to specify here is what the transaction, what represents a
transaction and that was an object. And then we can attach, and we have to run, so I
shouldn't have killed that I guess. This is about it, the demo. Okay. I shouldn't have
killed that. It started for a reason.
Now we can attach to a running process and then we can show the view. And it quickly
becomes fairly clear that things are going on funny. You can see the phases there, and if
you go in here and you look at what is going on, you can see here that it is running, the
handle done code all the time. In here where it is running synchronized, it's doing lots of
gravity computations. I don't know if you know that, but you can see that if you know
the code all. So what is happening here is that the gravity computations are nicely
paralyzed. The summing up of all these forces is not. Now, summing up should be
quick, right compared to computing gravity. It is not. And that is where the bottleneck
is. We paralyzed the gravity computations; we didn't paralyze the summing up and that
affected everything. That cut our factor down. So that is the system that comes the
closest to working. You can see in the S6 server, the search server, what is going on here
and here the outsiders are colored by transaction and at some point here there are multiple
transactions. You can see that one transaction just started up, put too many things in the
thread pool and they were taken sequentially out, and that is why they blocked things up.
The web crawler here you can see the broken state and here you see the normal state.
Again you can go in and see exactly what is going on. We also have done lock analysis,
and here is locks and that, and this is basically… The problem here is that you don't just
look at synchronized regions, because you use synchronized regions to implement all
different types of locks. So what we do here is we analyze how the synchronization
regions are doing and we figure out that this set of regions is used to implement a
read/write lock. And this set of regions is used to implement a semaphore with an initial
count of such and such. And we will go and deduce that and then we will visualize it
accordingly. I don't like the visualizations here because they have too much plank space
in them and I have to figure out how to fix that. How long do you hold a lock for? A
microsecond? Maybe a millisecond if it is a really long lock. How long does the
program run? Minutes, hours? How are you going to see a millisecond in an hour time
display? Fun issues like that, we are working on that one.
So there are lots of problems here. The challenge is in understanding the dynamics of
answering these things. How do you obtain real solutions to real problems in real
systems and how do you get programmers to use these tools? You have to handle real
systems. Programmers have specific questions phrased in their own terms in their own
level of abstractions and real questions are not simple. You have to figure out how to
make these so you can categorize these correctly so you can get programmers to tell you
what the questions are, figure out how to use your tools to answer those questions, and
then you have to address these real questions. You have to provide meaningful output at
different levels of abstraction minimizing, with the right information there, information in
the terms that the programmer can understand, and not have to do too much work trying
to map back and forth.
So dynamic understanding should be simple and should be usable. Please solve my
problems. I gave you lots of problems there. Most of those are still outstanding. I need
them solved. Okay. So, I still have 2 minutes left so [laughter].
>> Rob DeLine: Okay. Let's all thank Stephen for his talk.
[applause].
>> Rob DeLine: Any questions?
>>: I have a question. It is impressive in a sense how much work your group has done in
terms of really just [inaudible] honestly just for Code Bubbles. I imagine that doing all
this, trying to figure out how all of this runs, distributed total management kind of stuff
within your environment is difficult and everything. But my question really is why do
that much code? Why write that much code? I mean in a sense… I mean you have your
Code Bubbles environment and you are working within a paradigm, and I am wondering
does it make sense to always be working in that area? Does it always make sense to work
in like a bubble, when you're looking at a stack frame? Does it make sense to have a
bubble for that, or does it make sense to have a static window for that? So that when
you're working…?
>> Steven P. Reiss: Bubbles, as you might've noticed as I was moving around the
debugger, some of those bubbles are static.
>>: Yeah, but, they move with your screen. If you are going to scan across…
>> Steven P. Reiss: They stay in one place on the screen.
>>: Oh, they stay in one place on the screen, okay. I never realized that. But even on
that note, does it really make sense that it is still in the bubble?
>> Steven P. Reiss: So even if I move the screen here…
>>: Okay. [inaudible] occlusion and stuff like that.
>> Steven P. Reiss: Yeah, well, you get those issues. But they are static. And I will tell
you typically on my normal display I have an error display down here…
>>: Okay.
>> Steven P. Reiss: Fixed. I have the panel with insert for searching fixed. Here I am
going to have this fixed and maybe a console window fixed; I may not. The thread state I
will have fixed.
>>: But you can still have multiple instances of them.
>> Steven P. Reiss: Yeah, there could be multiple instances of them. I can unfix them if
I want them to float. The option is there. And most bubbles you can make that way. So
you can switch them back and forth. Right clicking on them will let you switch them
back and forth between those different options. So we tried doing that. Another thing is
if you really want to run Eclipse, you can run Eclipse and this simultaneously and they
will synchronize.
>>: I was interested about that problem as well. Because you talked about like writing
software on the cloud or however you wanted to do it [inaudible] and distributed running
the software, and you had your architecture up where you had like differing instances of
Code Bubbles running on your local client going on the cloud and then from like
communicating through Mint, or whatever. Is that actually synchronized? Like if I type
a key on my Code Bubbles over here and then this person sees it immediately showing
over there? Now do you do that…
>> Steven P. Reiss: Essentially what happens is I type; I don't save it in the file. Instead
I send it to Eclipse. Eclipse is maintaining a file buffer for that file and it has to
recompile or rebuild the parse tree after that change. And I am waiting for that rebuilt
parse tree. But also whenever it gets a change like that, it broadcasts it to any other
viewers.
>>: Okay. So you have to wait for that?
>> Steven P. Reiss: Yes. Well, some updating occurs and that's why it gets so complex
on a keystroke, because I am going to do local updating without the AST for whatever
current lines I have with whatever local information I have I am going to undo the
structure at that point, change the structure so that it is local, and when the Eclipse sends
that comes back with errors or with the new apps our synced registry, I am going to redo
it.
>>: Yeah but…
>> Steven P. Reiss: Unless I get another edit in between, in which case it notes there is
another edit and it will therefore throw this one away.
>>: And you do all of the synchronizing on basically one [inaudible]?
>> Steven P. Reiss: Yes. So in that case the synchronizing, there is a central buffer for
this particular file and that is in Eclipse.
>> Rob DeLine: At this point why don't we bring the talk to a close? We can have Steve
hang out for another couple of minutes if you have a few more follow-up questions. But
let's thank him one more time.
[applause].