<article>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#article10_03_10_1827244</id>
	<title>Code Bubbles &mdash; Rethinking the IDE's User Interface</title>
	<author>timothy</author>
	<datestamp>1268247120000</datestamp>
	<htmltext>kang327 writes <i>"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 &mdash; it is <a href="http://www.cs.brown.edu/people/acb/codebubbles\_site.htm">based on fragments instead of files</a>. 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."</i></htmltext>
<tokenext>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 .
"</tokentext>
<sentencetext>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.
"</sentencetext>
</article>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429544</id>
	<title>XEmacs binding...</title>
	<author>fahrbot-bot</author>
	<datestamp>1268252280000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext>M-C-x fuck-up-my-screen</htmltext>
<tokenext>M-C-x fuck-up-my-screen</tokentext>
<sentencetext>M-C-x fuck-up-my-screen</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31449182</id>
	<title>Re:U have screen wide enough to fix bugs in bubble</title>
	<author>Anonymous</author>
	<datestamp>1268425380000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430580</id>
	<title>Re:Step by step, Java reinvents Smalltalk...</title>
	<author>hfranz</author>
	<datestamp>1268213760000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Thats why I am looking at Scala right now. More flexible syntax, multi-paradigm, compiles to java or<nobr> <wbr></nobr>.net byte code.</p></htmltext>
<tokenext>Thats why I am looking at Scala right now .
More flexible syntax , multi-paradigm , compiles to java or .net byte code .</tokentext>
<sentencetext>Thats why I am looking at Scala right now.
More flexible syntax, multi-paradigm, compiles to java or .net byte code.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31439284</id>
	<title>Re:Mylyn in Eclipse</title>
	<author>tthomas48</author>
	<datestamp>1268328480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Exactly what I thought of. If they could merge this concept with Mylyn it would be amazingly powerful.</p></htmltext>
<tokenext>Exactly what I thought of .
If they could merge this concept with Mylyn it would be amazingly powerful .</tokentext>
<sentencetext>Exactly what I thought of.
If they could merge this concept with Mylyn it would be amazingly powerful.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429472</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429524</id>
	<title>love it - i had already "dreamt this up" w/hope</title>
	<author>happyjack27</author>
	<datestamp>1268252220000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>and my hopes have been fulfilled.</htmltext>
<tokenext>and my hopes have been fulfilled .</tokentext>
<sentencetext>and my hopes have been fulfilled.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430970</id>
	<title>Re:bubbles = isolation</title>
	<author>shutdown -p now</author>
	<datestamp>1268215620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>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.</p></div><p>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.</p><p><div class="quote"><p>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.</p> </div><p>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.</p><p>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.</p></div>
	</htmltext>
<tokenext>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 do n'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 .</tokentext>
<sentencetext>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.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430038</id>
	<title>Re:Oh goodie</title>
	<author>Anonymous</author>
	<datestamp>1268254440000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>But this way, atleast you have your dozen windows located inside one bigger window.</p></htmltext>
<tokenext>But this way , atleast you have your dozen windows located inside one bigger window .</tokentext>
<sentencetext>But this way, atleast you have your dozen windows located inside one bigger window.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429422</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429422</id>
	<title>Oh goodie</title>
	<author>Anonymous</author>
	<datestamp>1268251740000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext><p>More UI elements to click-n-drag</p><p>As if having a couple dozen windows open and trying to organize them wasn't fun enough.</p></htmltext>
<tokenext>More UI elements to click-n-dragAs if having a couple dozen windows open and trying to organize them was n't fun enough .</tokentext>
<sentencetext>More UI elements to click-n-dragAs if having a couple dozen windows open and trying to organize them wasn't fun enough.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429612</id>
	<title>codebase awareness</title>
	<author>Alban</author>
	<datestamp>1268252700000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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.</htmltext>
<tokenext>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 should n't be a substitute for having some amount of awareness .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430328</id>
	<title>Not keen on the interface</title>
	<author>e2d2</author>
	<datestamp>1268212620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 do n'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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698</id>
	<title>What a giant failure</title>
	<author>Chemisor</author>
	<datestamp>1268253000000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429356</id>
	<title>What rethinking?</title>
	<author>Accidental Angel</author>
	<datestamp>1268251440000</datestamp>
	<modclass>Redundant</modclass>
	<modscore>1</modscore>
	<htmltext>It looks like the Smalltalk GUI to me.</htmltext>
<tokenext>It looks like the Smalltalk GUI to me .</tokentext>
<sentencetext>It looks like the Smalltalk GUI to me.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430190</id>
	<title>Re:U have screen wide enough to fix bugs in bubble</title>
	<author>MemoryDragon</author>
	<datestamp>1268211900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.<br>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432960</id>
	<title>Again, smalltalk already did it</title>
	<author>rubies</author>
	<datestamp>1268227020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p><p>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# /<nobr> <wbr></nobr>.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.</p></htmltext>
<tokenext>The general recommendations were that each smalltalk method should be a few lines at most .
Everything small , easy to understand and self contained .
That does n't mean the program could n'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 could n'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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432048</id>
	<title>Re:What HR Wants...</title>
	<author>Anonymous</author>
	<datestamp>1268220720000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p><p>captcha: newborn</p></htmltext>
<tokenext>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</tokentext>
<sentencetext>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</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429904</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429478</id>
	<title>Solution in the search of problem.</title>
	<author>anonymousNR</author>
	<datestamp>1268251980000</datestamp>
	<modclass>Redundant</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>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.</p></div><p>I agree with Developers spending time reading and navigating code fragments but isn't that part of the job ?
I think its called debugging<nobr> <wbr></nobr>,locating problem, identifying it in the code and fixing it, if it takes navigating or standing on his head he will do it.</p></div>
	</htmltext>
<tokenext>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 is n'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 .</tokentext>
<sentencetext>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.
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429904</id>
	<title>What HR Wants...</title>
	<author>sycodon</author>
	<datestamp>1268253780000</datestamp>
	<modclass>Funny</modclass>
	<modscore>5</modscore>
	<htmltext><p>Wanted:<br>Java developer with 40 years experience in Code Bubbling concepts.<br>5 years experience with the Code Bubble IDE.</p></htmltext>
<tokenext>Wanted : Java developer with 40 years experience in Code Bubbling concepts.5 years experience with the Code Bubble IDE .</tokentext>
<sentencetext>Wanted:Java developer with 40 years experience in Code Bubbling concepts.5 years experience with the Code Bubble IDE.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429878</id>
	<title>Re:What a giant failure</title>
	<author>MagikSlinger</author>
	<datestamp>1268253720000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext>Speak for yourself.  Some of us <em>like</em> the mouse and window for code editing.</htmltext>
<tokenext>Speak for yourself .
Some of us like the mouse and window for code editing .</tokentext>
<sentencetext>Speak for yourself.
Some of us like the mouse and window for code editing.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432718</id>
	<title>Re:bubbles = isolation</title>
	<author>fbjon</author>
	<datestamp>1268225160000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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.</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431688</id>
	<title>Shakespeare said it</title>
	<author>Megahard</author>
	<datestamp>1268218920000</datestamp>
	<modclass>Funny</modclass>
	<modscore>5</modscore>
	<htmltext>Beware the IDEs of March</htmltext>
<tokenext>Beware the IDEs of March</tokentext>
<sentencetext>Beware the IDEs of March</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431954</id>
	<title>Re:Step by step, Java reinvents Smalltalk...</title>
	<author>Anonymous</author>
	<datestamp>1268220180000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p><p>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).</p><p>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)</p></htmltext>
<tokenext>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 do n'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 )</tokentext>
<sentencetext>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)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433636</id>
	<title>Re:What HR Wants...</title>
	<author>Anonymous</author>
	<datestamp>1268232840000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>and 5 years experience in applying Cloud Sourced Code Bubbling Concepts to the Cloud</p></htmltext>
<tokenext>and 5 years experience in applying Cloud Sourced Code Bubbling Concepts to the Cloud</tokentext>
<sentencetext>and 5 years experience in applying Cloud Sourced Code Bubbling Concepts to the Cloud</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429904</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429590</id>
	<title>Re:bubbles = isolation</title>
	<author>Galestar</author>
	<datestamp>1268252520000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p><div class="quote"><p>Then TFS mentions something as banal as "wrapping long lines of code"....and my bubble bursts.</p></div><p>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.</p></div>
	</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429930</id>
	<title>Is it really the case?</title>
	<author>PaulBu</author>
	<datestamp>1268253900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I was *jokingly* asking if this is the case in my previous post (http://developers.slashdot.org/comments.pl?sid=1578224&amp;cid=31429828), but you seem to confirm this. Wow, stunned...</p><p>Paul B.</p></htmltext>
<tokenext>I was * jokingly * asking if this is the case in my previous post ( http : //developers.slashdot.org/comments.pl ? sid = 1578224&amp;cid = 31429828 ) , but you seem to confirm this .
Wow , stunned...Paul B .</tokentext>
<sentencetext>I was *jokingly* asking if this is the case in my previous post (http://developers.slashdot.org/comments.pl?sid=1578224&amp;cid=31429828), but you seem to confirm this.
Wow, stunned...Paul B.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429458</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429410</id>
	<title>On the fence</title>
	<author>binarylarry</author>
	<datestamp>1268251680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I think this would be a cool tool for evaluating how an application is executed, as well as visualizing call sites and application traversal.</p><p>But I think it would be a major pain in the ass for most development purposes.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31449618</id>
	<title>Re:U have screen wide enough to fix bugs in bubble</title>
	<author>Anonymous</author>
	<datestamp>1268389740000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p> 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.</p></div><p>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?</p><p>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.</p><p>And, your complains remind me in another coworker, who wrote java code with vi until 3 years ago<nobr> <wbr></nobr>...</p></div>
	</htmltext>
<tokenext>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 do n'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 .. .</tokentext>
<sentencetext> 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 ...
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430036</id>
	<title>Re:bubbles = isolation</title>
	<author>suomynonAyletamitlU</author>
	<datestamp>1268254440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p><p>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.</p><p>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.</p></htmltext>
<tokenext>I agree that their effort should n'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 would n't be hard to have it jump to the line you already have selected in the " bubble " view .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432556</id>
	<title>Re:bubbles = isolation</title>
	<author>pclminion</author>
	<datestamp>1268224020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p> <em>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</em> </p><p>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."</p><p>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?"</p></htmltext>
<tokenext>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 ?
"</tokentext>
<sentencetext> 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?
"</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430326</id>
	<title>Tiled window managers an vi called</title>
	<author>Anonymous</author>
	<datestamp>1268212620000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>And they want their UI back.</p></htmltext>
<tokenext>And they want their UI back .</tokentext>
<sentencetext>And they want their UI back.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431098</id>
	<title>since it is not based on files</title>
	<author>mestar</author>
	<datestamp>1268216220000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext><p>Too bad that you have to have an unused partition on your drive to use this thing.</p><p>--<br>No files for you!</p></htmltext>
<tokenext>Too bad that you have to have an unused partition on your drive to use this thing.--No files for you !</tokentext>
<sentencetext>Too bad that you have to have an unused partition on your drive to use this thing.--No files for you!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429750</id>
	<title>2nd goal of a Java developer achieved....</title>
	<author>croftj</author>
	<datestamp>1268253180000</datestamp>
	<modclass>Funny</modclass>
	<modscore>4</modscore>
	<htmltext><p>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.</p><p>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.</p><p>All of this just to help overcome the basics such as overloading operators.</p><p>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.</p><p>-joe</p></htmltext>
<tokenext>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</tokentext>
<sentencetext>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</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430002</id>
	<title>Emacs has been able to do this for ages ...</title>
	<author>ThomasB1</author>
	<datestamp>1268254260000</datestamp>
	<modclass>Funny</modclass>
	<modscore>2</modscore>
	<htmltext>... I just haven't figured out the shortcut to open this view yet.</htmltext>
<tokenext>... I just have n't figured out the shortcut to open this view yet .</tokentext>
<sentencetext>... I just haven't figured out the shortcut to open this view yet.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429308</id>
	<title>Rob Malda's tranny died under mysterious circumsta</title>
	<author>Anonymous</author>
	<datestamp>1268251080000</datestamp>
	<modclass>Offtopic</modclass>
	<modscore>-1</modscore>
	<htmltext><p><b>Rob Malda's tranny died under mysterious circumstances</b></p><p>New details about Rob Malda's past may come out in the divorce proceedings with his wife of 8 years, Kathleen. Page 6 speculates that she may fight the prenup, citing Malda&rsquo;s infidelity with various street trannies.</p><p>In 2007, Malda was caught by Dexter police with a transvestite hooker in his car. He told his wife that he &ldquo;stopped to help a person crying.&rdquo; Several other hookers sold tales of Malda&rsquo;s solicitation to the tabloids, and all of them were convinced to recant, with one exception:<br>Paul Barresi, a private detective who claims he was hired for damage control by Malda when the scandal broke, tells Page Six: &ldquo;I called [Malda attorney] Marty &lsquo;Bull Dog&rsquo; Singer and told him I could round up all the transsexuals alleging sexual dalliances with Malda.&rdquo; And they would all recant their stories.</p><p>&ldquo;In less than 10 days,&rdquo; Barresi says, &ldquo;I got them all to sign sworn, videotaped depositions, stating it wasn&rsquo;t Malda himself, but rather a look-alike, who they&rsquo;d encountered - with the exception of Suiuli.&rdquo; In 2008, she fell to her death from her Dexter roof.</p><p>Atisone Suiuli was the tranny found in Malda&rsquo;s car in 2007. After being caught by police, she had proof that she was with Malda and wouldn&rsquo;t change her story. How convenient for him that she died soon afterwards.</p></htmltext>
<tokenext>Rob Malda 's tranny died under mysterious circumstancesNew details about Rob Malda 's past may come out in the divorce proceedings with his wife of 8 years , Kathleen .
Page 6 speculates that she may fight the prenup , citing Malda    s infidelity with various street trannies.In 2007 , Malda was caught by Dexter police with a transvestite hooker in his car .
He told his wife that he    stopped to help a person crying.    Several other hookers sold tales of Malda    s solicitation to the tabloids , and all of them were convinced to recant , with one exception : Paul Barresi , a private detective who claims he was hired for damage control by Malda when the scandal broke , tells Page Six :    I called [ Malda attorney ] Marty    Bull Dog    Singer and told him I could round up all the transsexuals alleging sexual dalliances with Malda.    And they would all recant their stories.    In less than 10 days ,    Barresi says ,    I got them all to sign sworn , videotaped depositions , stating it wasn    t Malda himself , but rather a look-alike , who they    d encountered - with the exception of Suiuli.    In 2008 , she fell to her death from her Dexter roof.Atisone Suiuli was the tranny found in Malda    s car in 2007 .
After being caught by police , she had proof that she was with Malda and wouldn    t change her story .
How convenient for him that she died soon afterwards .</tokentext>
<sentencetext>Rob Malda's tranny died under mysterious circumstancesNew details about Rob Malda's past may come out in the divorce proceedings with his wife of 8 years, Kathleen.
Page 6 speculates that she may fight the prenup, citing Malda’s infidelity with various street trannies.In 2007, Malda was caught by Dexter police with a transvestite hooker in his car.
He told his wife that he “stopped to help a person crying.” Several other hookers sold tales of Malda’s solicitation to the tabloids, and all of them were convinced to recant, with one exception:Paul Barresi, a private detective who claims he was hired for damage control by Malda when the scandal broke, tells Page Six: “I called [Malda attorney] Marty ‘Bull Dog’ Singer and told him I could round up all the transsexuals alleging sexual dalliances with Malda.” And they would all recant their stories.“In less than 10 days,” Barresi says, “I got them all to sign sworn, videotaped depositions, stating it wasn’t Malda himself, but rather a look-alike, who they’d encountered - with the exception of Suiuli.” In 2008, she fell to her death from her Dexter roof.Atisone Suiuli was the tranny found in Malda’s car in 2007.
After being caught by police, she had proof that she was with Malda and wouldn’t change her story.
How convenient for him that she died soon afterwards.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433230</id>
	<title>But at least now we can use those wide screens</title>
	<author>Anonymous</author>
	<datestamp>1268229000000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext><p>Actually, as I watched the video, the one thing I kept thinking was how nice it would be to use my current (1920x1200) screen <em>efficiently</em> for programming.</p><p>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.</p><p>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.</p><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476</id>
	<title>Re:bubbles = isolation</title>
	<author>ottothecow</author>
	<datestamp>1268251920000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext>I like the idea at least as I understand it from the summary.<p>

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.</p><p>

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.</p><p>

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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429830</id>
	<title>So what does it do that I can't do in vim or emacs</title>
	<author>Anonymous</author>
	<datestamp>1268253600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p><p>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.</p><p>The tools should let you work with whatever paradigm you wish, not dictate it to you.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429984</id>
	<title>Re:bubbles = isolation</title>
	<author>guruevi</author>
	<datestamp>1268254140000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Congratulations, you've just defined Objective-C/Smalltalk/PHP Classes &amp; Functions and probably a host of other so-called 'object-oriented' languages.</p><p>This IDE just seems to make OO simpler by diagramming your program ala Visio instead of coding the interactions.</p></htmltext>
<tokenext>Congratulations , you 've just defined Objective-C/Smalltalk/PHP Classes &amp; 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 .</tokentext>
<sentencetext>Congratulations, you've just defined Objective-C/Smalltalk/PHP Classes &amp; 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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</id>
	<title>Re:bubbles = isolation</title>
	<author>l3v1</author>
	<datestamp>1268252220000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><i>isolated, self-contained, easily testable pieces of code</i> <br> <br>
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.</htmltext>
<tokenext>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 ca n'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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429998</id>
	<title>Re:What a giant failure</title>
	<author>Anonymous</author>
	<datestamp>1268254200000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>are you using lynx right now, by any chance?</htmltext>
<tokenext>are you using lynx right now , by any chance ?</tokentext>
<sentencetext>are you using lynx right now, by any chance?</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430720</id>
	<title>Re:bubbles = isolation</title>
	<author>Dracolytch</author>
	<datestamp>1268214480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>From what I see this appears to be more useful for code editing versus code authoring...</p><p>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.</p><p>As for code authoring? That could be a real headache (literally)</p><p>~D</p></htmltext>
<tokenext>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</tokentext>
<sentencetext>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</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692</id>
	<title>Step by step, Java reinvents Smalltalk...</title>
	<author>Paul Fernhout</author>
	<datestamp>1268252940000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>5</modscore>
	<htmltext><p>See the Smalltalk browser:<br>
&nbsp; &nbsp; <a href="http://onsmalltalk.com/on-the-smalltalk-browser" title="onsmalltalk.com">http://onsmalltalk.com/on-the-smalltalk-browser</a> [onsmalltalk.com]</p><p>Now if only Java had Smalltalk's blocks.</p><p>And Smalltalk's more descriptive message passing syntax of "Foo x: 10 y: 20". instead of "new Foo(10, 20);"</p><p>And Smalltalk's extendable control syntax...</p><p>And Smalltalk's "doesNotUnderstand" concept for proxying.</p><p>And Smalltalk's become: method.</p><p>And Smalltalk's ability to rethrow exceptions...</p><p>And Smalltalk's multi-generational garbage collector...</p><p>And so on...</p><p>One step at a time...</p><p>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".<br>
&nbsp; &nbsp; <a href="http://fargoagile.com/joomla/content/view/15/26/" title="fargoagile.com">http://fargoagile.com/joomla/content/view/15/26/</a> [fargoagile.com]<br>
&nbsp; &nbsp; &nbsp; &nbsp; "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 &gt;$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."</p><p>How much people forget...</p><p>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...</p></div>
	</htmltext>
<tokenext>See the Smalltalk browser :     http : //onsmalltalk.com/on-the-smalltalk-browser [ onsmalltalk.com ] 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/ [ fargoagile.com ]         " 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 &gt; $ 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 do n'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.. .</tokentext>
<sentencetext>See the Smalltalk browser:
    http://onsmalltalk.com/on-the-smalltalk-browser [onsmalltalk.com]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/ [fargoagile.com]
        "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 &gt;$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...
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430034</id>
	<title>Re:What a giant failure</title>
	<author>stoanhart</author>
	<datestamp>1268254440000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext>What a closed-minded and overly general statement! <br> <br>

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.
<br> <br>
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.</htmltext>
<tokenext>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 do n't explore new ideas we wo n't find better ways of doing things .
How can you call it an automatic giant failure when you have n't even tried it yet .
Your complaint about not using all available screen space for what you want to see does n'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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31436406</id>
	<title>Re:VisualAge?</title>
	<author>Anonymous</author>
	<datestamp>1268314320000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Eclipse never catched up with the possibilities in VisualAge (which is now driven by Instantiations after IBM).</p></htmltext>
<tokenext>Eclipse never catched up with the possibilities in VisualAge ( which is now driven by Instantiations after IBM ) .</tokentext>
<sentencetext>Eclipse never catched up with the possibilities in VisualAge (which is now driven by Instantiations after IBM).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430168</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433262</id>
	<title>Re:bubbles = isolation</title>
	<author>fbumg</author>
	<datestamp>1268229300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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.</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429924</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429472</id>
	<title>Mylyn in Eclipse</title>
	<author>MyForest</author>
	<datestamp>1268251920000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>3</modscore>
	<htmltext><p>I've recently been using <a href="http://www.eclipse.org/mylyn/" title="eclipse.org" rel="nofollow">Mylyn</a> [eclipse.org] 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.</p><p>Then of course there's the rather gorgeous "<a href="http://www.ibm.com/developerworks/java/library/j-mylyn2/" title="ibm.com" rel="nofollow">Run unit tests in context</a> [ibm.com]" to give me feedback on the things I've been tinkering with.</p></htmltext>
<tokenext>I 've recently been using Mylyn [ eclipse.org ] 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 [ ibm.com ] " to give me feedback on the things I 've been tinkering with .</tokentext>
<sentencetext>I've recently been using Mylyn [eclipse.org] 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 [ibm.com]" to give me feedback on the things I've been tinkering with.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430478</id>
	<title>Large Display</title>
	<author>Anonymous</author>
	<datestamp>1268213280000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430864</id>
	<title>Re:Debugging and documentation</title>
	<author>Anonymous</author>
	<datestamp>1268215200000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.<br>http://www.cs.brown.edu/people/acb/codebubbles\_beta\_signup.htm</p></htmltext>
<tokenext>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</tokentext>
<sentencetext>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</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429948</id>
	<title>Haskell not Java</title>
	<author>Great Big Bird</author>
	<datestamp>1268253960000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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.</htmltext>
<tokenext>I think this idea might work best with a functional language like Haskell .
But I ca n't imagine this being good for Java or any other object oriented language .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432980</id>
	<title>Re:U have screen wide enough to fix bugs in bubble</title>
	<author>SimonInOz</author>
	<datestamp>1268227260000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.<br>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.</p><p>And next - four screens!! Your desk starts getting a bit crowded, though.<br>How about three though? That split in the middle is mildly irritating.</p></htmltext>
<tokenext>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 have n'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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429498</id>
	<title>It's a good idea.</title>
	<author>Anonymous</author>
	<datestamp>1268252100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p><p>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.</p></htmltext>
<tokenext>I think it 's brilliant .
I do n'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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306</id>
	<title>bubbles = isolation</title>
	<author>Anonymous</author>
	<datestamp>1268251080000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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).
<p>
Then TFS mentions something as banal as "wrapping long lines of code"....and my bubble bursts.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429924</id>
	<title>Re:bubbles = isolation</title>
	<author>sirius\_bbr</author>
	<datestamp>1268253840000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>4</modscore>
	<htmltext><p>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).</p><p>When developing new code, the bubble-concept could be too confusing, because it seems to hide the overall structure of the code.<br>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.</p></htmltext>
<tokenext>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 do n'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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431320</id>
	<title>Fundamentalist</title>
	<author>RAMMS+EIN</author>
	<datestamp>1268217300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p><p>That said, I am all for innovation, and I'm also all for innovation in IDEs. I'm curious to see how this goes.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430126</id>
	<title>Re:bubbles = isolation</title>
	<author>Anonymous</author>
	<datestamp>1268211600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>And I'd add small and short to that list.</p> </div><p>No you won't - this is a Java IDE. Java + "small and short" = FILE\_NOT\_FOUND.</p></div>
	</htmltext>
<tokenext>And I 'd add small and short to that list .
No you wo n't - this is a Java IDE .
Java + " small and short " = FILE \ _NOT \ _FOUND .</tokentext>
<sentencetext>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.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430930</id>
	<title>Re:bubbles = isolation</title>
	<author>cmiller173</author>
	<datestamp>1268215560000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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.</htmltext>
<tokenext>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 would n'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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446236</id>
	<title>Re:Step by step, Java reinvents Smalltalk...</title>
	<author>xiong.chiamiov</author>
	<datestamp>1268309580000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>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.</p></div><p>In case you haven't noticed, the language that rules the internet is not Java, but scripting languages (<a href="http://www.ruby-lang.org/" title="ruby-lang.org" rel="nofollow">one of which</a> [ruby-lang.org] that is growing particularly rapidly pulls quite a bit from Smalltalk).</p></div>
	</htmltext>
<tokenext>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 have n't noticed , the language that rules the internet is not Java , but scripting languages ( one of which [ ruby-lang.org ] that is growing particularly rapidly pulls quite a bit from Smalltalk ) .</tokentext>
<sentencetext>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 [ruby-lang.org] that is growing particularly rapidly pulls quite a bit from Smalltalk).
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429664</id>
	<title>snippets might be useful for better diffs</title>
	<author>Vadim Grinshpun</author>
	<datestamp>1268252820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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<nobr> <wbr></nobr>:)</p><p>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".</p><p>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.</p></htmltext>
<tokenext>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 can not 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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431852</id>
	<title>Welcome to SAP ABAP and uhm ... VBA?</title>
	<author>Anonymous</author>
	<datestamp>1268219700000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p><p>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.</p></htmltext>
<tokenext>I do n'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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446180</id>
	<title>Re:Oh goodie</title>
	<author>xiong.chiamiov</author>
	<datestamp>1268309280000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>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.</p></div><p>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).</p></div>
	</htmltext>
<tokenext>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 do n't care .
Finding the one I want is either F8 , F9 or F10 away .
I do n'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 ca n't stand using a floating wm ) .</tokentext>
<sentencetext>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).
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430828</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430828</id>
	<title>Re:Oh goodie</title>
	<author>evil\_aar0n</author>
	<datestamp>1268215020000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 do n't care .
Finding the one I want is either F8 , F9 or F10 away .
I do n't know how I functioned without Expose , before .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429422</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494</id>
	<title>Debugging and documentation</title>
	<author>beakerMeep</author>
	<datestamp>1268252040000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext>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.</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429608</id>
	<title>Excellent for Students</title>
	<author>JW CS</author>
	<datestamp>1268252640000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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.</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430168</id>
	<title>VisualAge?</title>
	<author>Dunx</author>
	<datestamp>1268211780000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>This sounds an awful lot like what VisualAge had in the late 90s. That mutated into Eclipse of course.</p></htmltext>
<tokenext>This sounds an awful lot like what VisualAge had in the late 90s .
That mutated into Eclipse of course .</tokentext>
<sentencetext>This sounds an awful lot like what VisualAge had in the late 90s.
That mutated into Eclipse of course.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31435424</id>
	<title>Re:bubbles = isolation</title>
	<author>drewhk</author>
	<datestamp>1268298180000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432556</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429300</id>
	<title>Deja vu</title>
	<author>Anonymous</author>
	<datestamp>1268251020000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext>It looks like those (incredibly crappy) multi window IDEs of ten years ago. The name is cute though.</htmltext>
<tokenext>It looks like those ( incredibly crappy ) multi window IDEs of ten years ago .
The name is cute though .</tokentext>
<sentencetext>It looks like those (incredibly crappy) multi window IDEs of ten years ago.
The name is cute though.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430022</id>
	<title>Neat! I'd really like to try that out. However...</title>
	<author>rhythmx</author>
	<datestamp>1268254380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I'm not so keen on my IDE being <i>reliant</i> 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.</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433050</id>
	<title>Re:bubbles = isolation</title>
	<author>beelsebob</author>
	<datestamp>1268227860000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446268</id>
	<title>Re:What a giant failure</title>
	<author>xiong.chiamiov</author>
	<datestamp>1268309760000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>Speak for yourself.  Some of us <em>like</em> the mouse and window for code editing.</p></div><p>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.</p><p>Trackpads have made me appreciate keyboard-controlled window managers, vimperator, and the aforementioned editor so much more.</p></div>
	</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429878</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31457024</id>
	<title>I'm already using a wide screen efficiently</title>
	<author>drew\_eckhardt</author>
	<datestamp>1268390280000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>The typical Microsoft/Eclipse/whatever GUI today is horribly wasteful: vast areas are wasted on window dressing, toolbars, menus, scrollbars...</p></div><p>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.</p><p>If an emacs user taunted me about running my debuggers in a separate window I might be tempted to get the Conque plugin.</p><p><div class="quote"><p>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.</p></div><p>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.</p><p>A one-page function length limit with occasional exceptions is also a fine idea.</p></div>
	</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433230</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429738</id>
	<title>But, does it have...</title>
	<author>narooze</author>
	<datestamp>1268253120000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>3</modscore>
	<htmltext>But, does it have <a href="http://www.vim.org/" title="vim.org" rel="nofollow">a good text editor</a> [vim.org]?</htmltext>
<tokenext>But , does it have a good text editor [ vim.org ] ?</tokentext>
<sentencetext>But, does it have a good text editor [vim.org]?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430406</id>
	<title>Re:Soo much space required.</title>
	<author>BikeHelmet</author>
	<datestamp>1268212980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430764</id>
	<title>Re:Soo much space required.</title>
	<author>Anonymous</author>
	<datestamp>1268214720000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>AMD will probably include this project in all of their Eyefinity marketing materials</p></htmltext>
<tokenext>AMD will probably include this project in all of their Eyefinity marketing materials</tokentext>
<sentencetext>AMD will probably include this project in all of their Eyefinity marketing materials</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430110</id>
	<title>Re:bubbles = isolation</title>
	<author>ianare</author>
	<datestamp>1268254740000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p><p>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.</p><p>OK, now back to work : I'm building a multithreaded back-end business software program using Vi.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429912</id>
	<title>Re:Screen Size</title>
	<author>Anonymous</author>
	<datestamp>1268253840000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>most IDEs make it harder to view code side by side than Emacs did 15 years ago.</p></div><p>Exactly.  End of story.</p></div>
	</htmltext>
<tokenext>most IDEs make it harder to view code side by side than Emacs did 15 years ago.Exactly .
End of story .</tokentext>
<sentencetext>most IDEs make it harder to view code side by side than Emacs did 15 years ago.Exactly.
End of story.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429458</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430974</id>
	<title>Re:What a giant failure</title>
	<author>Anonymous</author>
	<datestamp>1268215680000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Any criticism that uses the phrase "automatically a failure" without substantiation is...</p></htmltext>
<tokenext>Any criticism that uses the phrase " automatically a failure " without substantiation is.. .</tokentext>
<sentencetext>Any criticism that uses the phrase "automatically a failure" without substantiation is...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429840</id>
	<title>I'll improve on your methods!</title>
	<author>Anonymous</author>
	<datestamp>1268253600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>The narrator sounds like Strong Sad.</p></htmltext>
<tokenext>The narrator sounds like Strong Sad .</tokentext>
<sentencetext>The narrator sounds like Strong Sad.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430100</id>
	<title>Re:Soo much space required.</title>
	<author>Anonymous</author>
	<datestamp>1268254680000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><div class="quote"><p>I'm going to need a bigger screen.</p></div><p>Problem Solved, Viewsonic VP2290b monitor, 3840x2400.</p></div>
	</htmltext>
<tokenext>I 'm going to need a bigger screen.Problem Solved , Viewsonic VP2290b monitor , 3840x2400 .</tokentext>
<sentencetext>I'm going to need a bigger screen.Problem Solved, Viewsonic VP2290b monitor, 3840x2400.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433142</id>
	<title>Re:bubbles = isolation</title>
	<author>khayman80</author>
	<datestamp>1268228460000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>Keeping stuff in separate files and including them is a good organization technique...</p></div></blockquote><p>Why? That just means I have to open more files when I want to perform extensive maintenance on the program.</p><p>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.)</p><p>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.</p><p>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.</p><p>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...</p></div>
	</htmltext>
<tokenext>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 do n'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 are n'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.. .</tokentext>
<sentencetext>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...
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430114</id>
	<title>Re:Debugging and documentation</title>
	<author>MemoryDragon</author>
	<datestamp>1268254740000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>A good uml plugin can almost do the same...<br>Problem is there are no good uml plugins<nobr> <wbr></nobr>:-)</p></htmltext>
<tokenext>A good uml plugin can almost do the same...Problem is there are no good uml plugins : - )</tokentext>
<sentencetext>A good uml plugin can almost do the same...Problem is there are no good uml plugins :-)</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430180</id>
	<title>But...</title>
	<author>Anonymous</author>
	<datestamp>1268211900000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>But... I don't want to wrap lines.<nobr> <wbr></nobr>:(</p></htmltext>
<tokenext>But... I do n't want to wrap lines .
: (</tokentext>
<sentencetext>But... I don't want to wrap lines.
:(</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429492</id>
	<title>Gonna need a bigger monitor...</title>
	<author>Anonymous</author>
	<datestamp>1268252040000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431350</id>
	<title>Literate Programming</title>
	<author>andawyr</author>
	<datestamp>1268217420000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>This sounds very much like <a href="http://en.wikipedia.org/wiki/Literate\_programming/" title="wikipedia.org">http://en.wikipedia.org/wiki/Literate\_programming/</a> [wikipedia.org], as introduced by Knuth.</p><p>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.</p><p>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<nobr> <wbr></nobr>:-) )to develop a complex application; I believe that Knuth even stated that creating TeX and MetaFONT were made much easier by using Literate Programming...</p></htmltext>
<tokenext>This sounds very much like http : //en.wikipedia.org/wiki/Literate \ _programming/ [ wikipedia.org ] , 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.. .</tokentext>
<sentencetext>This sounds very much like http://en.wikipedia.org/wiki/Literate\_programming/ [wikipedia.org], 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...</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429700</id>
	<title>Re:Debugging and documentation</title>
	<author>Anonymous</author>
	<datestamp>1268253000000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Yes, the usage scenario you've painted here is a lot like what I'm thinking as well.</p><p>Besides, it looks quite similar to the work Ilfak's done with IDA Pro 5.</p><p>http://www.hex-rays.com/idapro/freefiles/ida5preview.htm</p></htmltext>
<tokenext>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</tokentext>
<sentencetext>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</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429746</id>
	<title>Re:bubbles = isolation</title>
	<author>phantomfive</author>
	<datestamp>1268253180000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext>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.<br> <br>
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.<br> <br>
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.</htmltext>
<tokenext>It is a good start of an idea .
The problem with coding is that the logical structure is n'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 ca n'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 does n'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 did n't like emacs for totally different reasons , I could n'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 was n't a problem to him like it was to me .
That is how new tools often are .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430860</id>
	<title>This is new?</title>
	<author>Anonymous</author>
	<datestamp>1268215200000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 ?
Wo n't the screen size needed for this make coding harder on , oh gee I do n't know , laptops maybe and netbooks for sure .
Nice try .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431560</id>
	<title>Bad for coding, good for debugging</title>
	<author>dread</author>
	<datestamp>1268218380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p><p>Anyway, if this ever gets into IntelliJ I'll be happy clam I think.</p></htmltext>
<tokenext>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 does n'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 .
Does n't matter .
Get an initial design , hammer in the functionality and iterate .
However , in that type of scenario Code Bubbles does n'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 do n't normally shift between IDEs that way .
Some do , I do n't and even though I do n'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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31440818</id>
	<title>Re:Sounds like Smalltalk's code browser.</title>
	<author>Anonymous</author>
	<datestamp>1268334060000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I prefer the Cincom Smalltalk flavor personally... more utilitarian, but also more robust.</p><p>http://www.cincomsmalltalk.com/main/products/visualworks/visualworks-overview/</p><p>Average method size of just over 6 lines.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430414</id>
	<title>Does it work for a new project</title>
	<author>vivin</author>
	<datestamp>1268213040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429482</id>
	<title>rofl java</title>
	<author>Anonymous</author>
	<datestamp>1268251980000</datestamp>
	<modclass>Flamebait</modclass>
	<modscore>-1</modscore>
	<htmltext><p>java != coding</p></htmltext>
<tokenext>java ! = coding</tokentext>
<sentencetext>java != coding</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294</id>
	<title>Sounds like Smalltalk's code browser.</title>
	<author>Anonymous</author>
	<datestamp>1268251020000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext><p>Welcome to the 1970s. <a href="http://squeak.org/" title="squeak.org" rel="nofollow">Squeak</a> [squeak.org] is one of the better implementations these days.</p></htmltext>
<tokenext>Welcome to the 1970s .
Squeak [ squeak.org ] is one of the better implementations these days .</tokentext>
<sentencetext>Welcome to the 1970s.
Squeak [squeak.org] is one of the better implementations these days.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429458</id>
	<title>Screen Size</title>
	<author>pavon</author>
	<datestamp>1268251860000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>4</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429580</id>
	<title>Looks promising...</title>
	<author>johnlcallaway</author>
	<datestamp>1268252520000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext>I do mostly maintenance programming (by choice<nobr> <wbr></nobr>.. 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.
<br> <br>
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.
<br> <br>
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.
<br> <br>
Besides<nobr> <wbr></nobr>.. 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.</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431122</id>
	<title>Enhancing the IDE vs. enhancing the language</title>
	<author>Anonymous</author>
	<datestamp>1268216340000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I once read somewhere: "In Java, you enhance the IDE. In Python, you enhance the language."</p><p>That is so true.</p></htmltext>
<tokenext>I once read somewhere : " In Java , you enhance the IDE .
In Python , you enhance the language .
" That is so true .</tokentext>
<sentencetext>I once read somewhere: "In Java, you enhance the IDE.
In Python, you enhance the language.
"That is so true.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430428</id>
	<title>Re:Screen Size</title>
	<author>BikeHelmet</author>
	<datestamp>1268213100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Good thing you can pick up monitors for $99 these days!</p><p>Or huge ones for a bit more. I got a 2048x1152 Samsung 2343BWX for $170 CAD.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429458</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31438458</id>
	<title>Re:Step by step, Java reinvents Smalltalk...</title>
	<author>pydev</author>
	<datestamp>1268326140000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><i>See the Smalltalk browser: <a href="http://onsmalltalk.com/on-the-smalltalk-browser" title="onsmalltalk.com">http://onsmalltalk.com/on-the-smalltalk-browser</a> [onsmalltalk.com] </i></p><p>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.</p></htmltext>
<tokenext>See the Smalltalk browser : http : //onsmalltalk.com/on-the-smalltalk-browser [ onsmalltalk.com ] 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 .</tokentext>
<sentencetext>See the Smalltalk browser: http://onsmalltalk.com/on-the-smalltalk-browser [onsmalltalk.com] 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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430914</id>
	<title>Re:Sounds like Smalltalk's code browser.</title>
	<author>shutdown -p now</author>
	<datestamp>1268215440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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...</p></htmltext>
<tokenext>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.. .</tokentext>
<sentencetext>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...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430132</id>
	<title>Re:bubbles = isolation</title>
	<author>Anonymous</author>
	<datestamp>1268211600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p><a href="http://en.wikipedia.org/wiki/Visual\_programming\_language" title="wikipedia.org" rel="nofollow">Visual Programming/ Dataflow programming</a> [wikipedia.org]</p></htmltext>
<tokenext>Visual Programming/ Dataflow programming [ wikipedia.org ]</tokentext>
<sentencetext>Visual Programming/ Dataflow programming [wikipedia.org]</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430604</id>
	<title>There's nothing fundamental about files.</title>
	<author>hey!</author>
	<datestamp>1268213880000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>From the operating system's standpoint, a file is the atomic unit of document management.</p><p>From a computer language standpoint, a file is an atomic unit of parsing.</p><p>From a programming standpoint, both these concepts have utility, but neither is particularly fundamental.</p><p>That's one of the things that makes literate programming possible.</p><p>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.</p><p>Also, I can't see using the system shown on a laptop.  It might be usable on a 24" monitor, but not a 15".</p></htmltext>
<tokenext>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 do n'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 does n't is meh.Also , I ca n't see using the system shown on a laptop .
It might be usable on a 24 " monitor , but not a 15 " .</tokentext>
<sentencetext>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".</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430404</id>
	<title>Re:What a giant failure</title>
	<author>MindStalker</author>
	<datestamp>1268212980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>Agreed/Disagreed .
I think this would be amazing for code reading/debugging/getting familiar with code .
Actual coding ?
Yea , it does n'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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770</id>
	<title>U have screen wide enough to fix bugs in bubbles?</title>
	<author>roman\_mir</author>
	<datestamp>1268253300000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>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.</p><p>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.</p><p>The developer's screen in the video looks like a mess and a mess at very high resolution.  Minority report interface style mess.</p><p>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?</p><p>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?</p><p>It's a nightmare, colorful, messy, visually heavy nightmare.  This will probably sell well as a 'new coding paradigm' to CTOs and such.</p><p>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.</p><p>Looks like a solution in search for a problem that has maybe one feature that is worth looking into.  Good work.</p></htmltext>
<tokenext>opening methods side by side ?
I just wish I had 200 " wide screen , or maybe I do n'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 .
Does n'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 do n'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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431248</id>
	<title>Re:Debugging and documentation</title>
	<author>wembley fraggle</author>
	<datestamp>1268217000000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429970</id>
	<title>~/emacs&amp;</title>
	<author>Anonymous</author>
	<datestamp>1268254080000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Still the best/fastest way to code.</p></htmltext>
<tokenext>Still the best/fastest way to code .</tokentext>
<sentencetext>Still the best/fastest way to code.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430218</id>
	<title>Re:Soo much space required.</title>
	<author>IamTheRealMike</author>
	<datestamp>1268212020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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.</htmltext>
<tokenext>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 ca n't wait to try it out for myself .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432756</id>
	<title>Sounds like Leo</title>
	<author>Anonymous</author>
	<datestamp>1268225460000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Check out the Leo outliner/editor for an example of a working, useful, not-particularly-language-specific(but Python-centric) system in this vein:</p><p>http://personalpages.tds.net/~edream/front.html</p><p>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.</p></htmltext>
<tokenext>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.htmlLeo 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 do n'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 .</tokentext>
<sentencetext>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.htmlLeo 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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350</id>
	<title>Soo much space required.</title>
	<author>coolsnowmen</author>
	<datestamp>1268251380000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext><p>I'm going to need a bigger screen.</p></htmltext>
<tokenext>I 'm going to need a bigger screen .</tokentext>
<sentencetext>I'm going to need a bigger screen.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429414</id>
	<title>Where have I seen something like this?</title>
	<author>140Mandak262Jamuna</author>
	<datestamp>1268251680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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 <b>awk</b> my brain. I am <b>grep</b>pping through my memory.</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429564</id>
	<title>cant help it..</title>
	<author>zcold</author>
	<datestamp>1268252340000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>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.</htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430352</id>
	<title>Re:bubbles = isolation</title>
	<author>Anonymous</author>
	<datestamp>1268212800000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>It's called crappy code (or lack of documentation) if external function calls need it's code referenced when used.</p><p>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.</p></htmltext>
<tokenext>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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31437200</id>
	<title>Re:But at least now we can use those wide screens</title>
	<author>Anonymous</author>
	<datestamp>1268321760000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>White spaces and interface ornaments are supposed to *help* readability, it's not about squeezing pixels...</p></htmltext>
<tokenext>White spaces and interface ornaments are supposed to * help * readability , it 's not about squeezing pixels.. .</tokentext>
<sentencetext>White spaces and interface ornaments are supposed to *help* readability, it's not about squeezing pixels...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433230</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432322</id>
	<title>Re:Step by step, Java reinvents Smalltalk...</title>
	<author>Anonymous</author>
	<datestamp>1268222280000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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++.</p><p>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.</p><p>- Laurent Hasson</p></htmltext>
<tokenext>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</tokentext>
<sentencetext>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</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429578</id>
	<title>Re:Sounds like Smalltalk's code browser.</title>
	<author>Anonymous</author>
	<datestamp>1268252460000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>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.</p></htmltext>
<tokenext>I do n'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 .</tokentext>
<sentencetext>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.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31435608</id>
	<title>I had a similar idea</title>
	<author>cyclomedia</author>
	<datestamp>1268301120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>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:</p><p><a href="http://cyclomedia.co.uk/blog/media/VisualStudioIDEConcept.png" title="cyclomedia.co.uk">http://cyclomedia.co.uk/blog/media/VisualStudioIDEConcept.png</a> [cyclomedia.co.uk]</p></htmltext>
<tokenext>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 [ cyclomedia.co.uk ]</tokentext>
<sentencetext>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 [cyclomedia.co.uk]</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430374</id>
	<title>Re:bubbles = isolation</title>
	<author>SQLGuru</author>
	<datestamp>1268212860000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>You can keep your resolution but go vertical.  You get to see more without scrolling and without making him scroll as much.  Win/win.</p><p>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).</p></htmltext>
<tokenext>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 ca n't be helped ) .</tokentext>
<sentencetext>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).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429590</parent>
</comment>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_29</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429746
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_32</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430974
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429700
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_28</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31440818
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_25</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31435608
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_24</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432980
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430218
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429422
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430038
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_49</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430352
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429458
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429912
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_54</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433230
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31457024
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_39</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429984
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_30</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430764
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430406
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_44</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430110
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429458
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429930
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_23</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430914
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_51</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430970
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31449182
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_36</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430114
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_52</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31438458
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_43</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431954
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_42</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429904
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433636
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_33</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430100
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430864
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429458
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430428
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_34</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429904
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432048
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432960
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_48</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433230
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31437200
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430414
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_41</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433142
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_27</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429878
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446268
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_31</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430190
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429924
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433262
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_22</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433050
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430720
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31449618
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_47</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430168
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31436406
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_46</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429472
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31439284
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_37</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446236
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_53</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431248
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429590
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430374
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430036
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430930
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430126
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_38</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432556
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31435424
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429578
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432322
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432718
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_45</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429422
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430828
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446180
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_50</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430132
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_35</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430580
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430404
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_40</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429998
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_03_10_1827244_26</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430034
</commentlist>
</thread>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430604
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429698
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430034
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430974
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430404
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429998
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429878
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446268
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429306
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429984
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430132
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429476
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433142
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31435608
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430352
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429924
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433262
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432556
---http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31435424
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429590
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430374
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429530
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432960
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432718
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430970
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430036
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430126
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433050
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430414
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430930
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430720
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430110
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429746
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431320
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429472
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31439284
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429422
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430038
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430828
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446180
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429308
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429750
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430168
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31436406
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429494
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429700
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431248
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430114
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430864
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429544
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429294
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429904
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432048
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433636
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31440818
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430914
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429578
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429350
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430406
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430764
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430218
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430100
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31433230
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31457024
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31437200
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429410
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429498
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429300
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429458
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430428
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429930
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429912
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429770
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31449182
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430190
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432980
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31449618
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429482
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431350
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_03_10_1827244.20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31429692
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31431954
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31430580
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31432322
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31446236
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_03_10_1827244.31438458
</commentlist>
</conversation>
