informat IDE survey

  • Permalink
  • submit to reddit
  • Email
  • Follow


I'm curious what people are using as their IDE to write Java code.
The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
now?  What are you using?
-- 
Roedy Green Canadian Mind Products
http://mindprod.com
If you think it’s expensive to hire a professional to do the job, wait until you hire an amateur.
~ Red Adair

0
Reply see_website (5878) 3/18/2011 11:50:31 PM

See related articles to this posting


On 18-03-2011 19:50, Roedy Green wrote:
> I'm curious what people are using as their IDE to write Java code.
> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
> now?  What are you using?

That is more or less still the case (with Eclipse in front).

http://storage.pardot.com/1772/18317/Survey_Results.pdf
http://www.zeroturnaround.com/java-ee-productivity-report-2011/

Personally I also prefer Eclipse.

Arne
0
Reply UTF 3/19/2011 12:04:16 AM

On 11-03-18 08:50 PM, Roedy Green wrote:
> I'm curious what people are using as their IDE to write Java code.
> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
> now?  What are you using?

All of the above, plus JDeveloper. The choices are largely driven by
having to work on client sites with client developers who are told what
to use, which means I use what they use so I don't go insane.

Truth be told I don't much care which IDE I use. All of them have the
necessaries, as far as I am concerned. Provided that they are reliable I
am tolerant of idiosyncracies.

AHS
-- 
The user's going to pick dancing pigs over security every time.
-- Bruce Schneier

0
Reply Arved 3/19/2011 12:08:04 AM

In article <1sr7o6liio3kg2qc20iavn9npamovs5a6l@4ax.com>, 
see_website@mindprod.com.invalid says...
> 
> I'm curious what people are using as their IDE to write Java code.
> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
> now?  What are you using?

Eclipse... with provisioning done by Yoxos Launcher. Great setup.
0
Reply Steve 3/19/2011 1:00:58 AM

Roedy Green <see_website@mindprod.com.invalid> writes:
> I'm curious what people are using as their IDE to write Java code.
> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
> now?  What are you using?

     Emacs.  And I'm measurably more productive than my colleagues who
waste their time fighting with their IDEs.

Regards,

Patrick

------------------------------------------------------------------------
http://www.softwarematters.org
Large scale, mission-critical, distributed OO systems design and
implementation.  (C++, Java, Common Lisp, Jini, middleware, SOA)
0
Reply Patrick 3/20/2011 2:55:42 AM

On Sat, 19 Mar 2011 22:55:42 -0400, Patrick May
<patrick@softwarematters.org> wrote, quoted or indirectly quoted
someone who said :

>     Emacs.  And I'm measurably more productive than my colleagues who
>waste their time fighting with their IDEs.

I take it you are not a windows user, or for some reason are able to
avoid windows apps. I found flipping back and forth insanity inducing.
-- 
Roedy Green Canadian Mind Products
http://mindprod.com
If you think it’s expensive to hire a professional to do the job, wait until you hire an amateur.
~ Red Adair

0
Reply Roedy 3/20/2011 3:12:11 AM

In article <m2mxkqwle9.fsf@softwarematters.org>, 
patrick@softwarematters.org says...
> 
> Roedy Green <see_website@mindprod.com.invalid> writes:
> > I'm curious what people are using as their IDE to write Java code.
> > The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
> > now?  What are you using?
> 
>      Emacs.  And I'm measurably more productive than my colleagues who
> waste their time fighting with their IDEs.

I don't know... I find the use of Eclipse to be very productive. It 
doesn't get in my way at all. And I find that rapid GUI development with 
WindowBuilder Pro is extremely helpful.


0
Reply Steve 3/20/2011 4:08:40 AM

In message <m2mxkqwle9.fsf@softwarematters.org>, Patrick May wrote:

> Roedy Green <see_website@mindprod.com.invalid> writes:
>
>> I'm curious what people are using as their IDE to write Java code.
>> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
>> now?  What are you using?
> 
>      Emacs.  And I'm measurably more productive than my colleagues who
> waste their time fighting with their IDEs.

I wasn’t going to be the first, but another vote for Emacs here. :)
0
Reply Lawrence 3/20/2011 7:59:35 AM

On 11-03-19 11:55 PM, Patrick May wrote:
> Roedy Green <see_website@mindprod.com.invalid> writes:
>> I'm curious what people are using as their IDE to write Java code.
>> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
>> now?  What are you using?
> 
>      Emacs.  And I'm measurably more productive than my colleagues who
> waste their time fighting with their IDEs.
> 
> Regards,
> 
> Patrick

Nothing against Emacs, but if your colleagues are "fighting" with their
IDEs then they are either novices or doing something wrong. If you are
doing standard editing+building of Java source, say, it's basically
impossible for Emacs on any platform to be faster, in practical terms,
than Eclipse or Netbeans or IntelliJ. What could possibly be faster?
Typing of keystrokes or deleting a piece of text? Calling javac to
compile your source? Locating a Java class and opening it?

If you mean that your colleagues are fighting with their IDEs when it
comes to doing another task that isn't particularly well-supported by
the state of tooling for that task in the IDE, I'll buy that. For
example, for a number of reasons I won't do all but the simplest
revision control operations (whether SVN or Mercurial or whatever) in an
IDE - I do them on the command line and then refresh the IDE. I won't do
anything but the simplest merge work in an IDE either - I'll use a
purpose-built merge program on whatever OS I'm on.

If an IDE proves lacking or fractious during a deploy procedure to an
app server, I'll not use the IDE. I make sure I know how to command-line
or admin console deploy artifacts to the server if necessary.

A key skill that intermediate developers (even promising junior)
developers learn is how to *not* use an IDE when it's in the way. If all
the dialog-driven tooling in an IDE is interfering with your use of JPA,
say, then skip the automation and craft the necessary files yourself. If
some little quirk in JDeveloper, while working with Oracle ESB or BPEL,
is driving you to distraction, skip the IDE and know what XML files you
need to edit directly.

Emacs doesn't have close to the same kind of Java support that a full
Java IDE has. So ultimately the productivity argument for Emacs over a
Java IDE comes down to editing large volumes of text...for which Emacs
is arguably better. However, and speaking for myself, as a Java
programmer (well, as a programmer period, in any language), I don't
generate large volumes of text. I don't even create medium volumes of
text. Even in full-blown new development mode I spend most of my time
thinking about what I'm doing, not acting like an administrative
assistant pounding out letters for the boss.

I trust that you're not talking about Emacs+JDEE, say. That combination
*is* a Java IDE.

AHS
-- 
The user's going to pick dancing pigs over security every time.
-- Bruce Schneier

0
Reply Arved 3/20/2011 1:15:10 PM

Arved Sandstrom <asandstrom3minus1@eastlink.ca> wrote:

> Nothing against Emacs, but if your colleagues are "fighting" with their
> IDEs then they are either novices or doing something wrong. If you are
> doing standard editing+building of Java source, say, it's basically
> impossible for Emacs on any platform to be faster, in practical terms,
> than Eclipse or Netbeans or IntelliJ. What could possibly be faster?
> Typing of keystrokes or deleting a piece of text? Calling javac to
> compile your source? Locating a Java class and opening it?

Rather tangential to this discussion, perhaps, but I think that one
of the bad habits of developers who grew up on an IDE as opposed
to text-editors + command-line tools are likely to have is to reach 
for the debugger much too soon.

I've seen far too many developers who spend time blithely single-stepping 
through code instead of thinking about what could be wrong.

-- 
Leif Roar Moldskred
0
Reply Leif 3/20/2011 2:56:25 PM

Steve Sobol <sjsobol@JustThe.net> writes:

> In article <m2mxkqwle9.fsf@softwarematters.org>, 
> patrick@softwarematters.org says...
>> 
>> Roedy Green <see_website@mindprod.com.invalid> writes:
>> > I'm curious what people are using as their IDE to write Java code.
>> > The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
>> > now?  What are you using?
>> 
>>      Emacs.  And I'm measurably more productive than my colleagues who
>> waste their time fighting with their IDEs.
>
> I don't know... I find the use of Eclipse to be very productive.

I've never seriously used Eclipse, but I'd be willing to bet a paycheck
that I could adapt and be productive with it in a week or two. The key
word there is "adapt" - a little flexibility goes a long way.

sherm--

-- 
Sherm Pendley
                                   <http://camelbones.sourceforge.net>
Cocoa Developer
0
Reply Sherm 3/20/2011 3:22:35 PM

Leif Roar Moldskred wrote:
> Rather tangential to this discussion, perhaps, but I think that one
> of the bad habits of developers who grew up on an IDE as opposed
> to text-editors + command-line tools are likely to have is to reach
> for the debugger much too soon.
>
> I've seen far too many developers who spend time blithely single-stepping
> through code instead of thinking about what could be wrong.

Sure, people misuse tools.  But a hammer isn't a bad tool because someone hit 
their thumb with it, and an adze isn't a bad tool just because someone tried 
to fasten a bolt with it.

"Grew up on an IDE" is one of those pitiful excuses used to let someone off 
the hook for not knowing what the fuck they're doing.

-- 
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg
0
Reply Lew 3/20/2011 3:26:24 PM

On 20/03/2011 15:56, Leif Roar Moldskred allegedly wrote:
> I've seen far too many developers who spend time blithely single-stepping
> through code instead of thinking about what could be wrong.

Amen. Always makes me wonder whether a good punching would help.

0
Reply Daniele 3/20/2011 4:44:03 PM

On 3/20/2011 7:56 AM, Leif Roar Moldskred wrote:

> Rather tangential to this discussion, perhaps, but I think that one
> of the bad habits of developers who grew up on an IDE as opposed
> to text-editors + command-line tools are likely to have is to reach
> for the debugger much too soon.


Corrallary: Not using print/log statements to debug code.

Not only are log statements often a much faster way to debug, they are 
permanent and therefore can be reused later, used when you have new and 
different problems, and also can be used by other programmers or later 
in a product's life cycle, i.e. maintenance.

0
Reply markspace 3/20/2011 5:13:32 PM

On 03/20/2011 01:13 PM, markspace wrote:
> On 3/20/2011 7:56 AM, Leif Roar Moldskred wrote:
>
>> Rather tangential to this discussion, perhaps, but I think that one
>> of the bad habits of developers who grew up on an IDE as opposed
>> to text-editors + command-line tools are likely to have is to reach
>> for the debugger much too soon.
>
>
> Corrallary: Not using print/log statements to debug code.
>
> Not only are log statements often a much faster way to debug, they are
> permanent and therefore can be reused later, used when you have new and
> different problems, and also can be used by other programmers or later in a
> product's life cycle, i.e. maintenance.

+1.

Particularly if the log statements are designed to help ops folks, not 
particularly developers, particularly.

-- 
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg
0
Reply Lew 3/20/2011 6:22:47 PM

"Daniele Futtorovic" <da.futt.news@laposte-dot-net.invalid> wrote in message 
news:im5ash$sjc$1@news.eternal-september.org...
> On 20/03/2011 15:56, Leif Roar Moldskred allegedly wrote:
>> I've seen far too many developers who spend time blithely single-stepping
>> through code instead of thinking about what could be wrong.
>
> Amen. Always makes me wonder whether a good punching would help.

Single-stepping through newly-written code is an excellent way to determine 
whether it's working as designed, or getting what looks like the right 
answer for the wrong reason.
 

0
Reply Mike 3/20/2011 6:38:10 PM

On 20/03/2011 19:38, Mike Schilling allegedly wrote:
> "Daniele Futtorovic" <da.futt.news@laposte-dot-net.invalid> wrote in
> message news:im5ash$sjc$1@news.eternal-september.org...
>> On 20/03/2011 15:56, Leif Roar Moldskred allegedly wrote:
>>> I've seen far too many developers who spend time blithely
>>> single-stepping
>>> through code instead of thinking about what could be wrong.
>>
>> Amen. Always makes me wonder whether a good punching would help.
>
> Single-stepping through newly-written code is an excellent way to
> determine whether it's working as designed

Not even that. Not unless you can simulate all the logical branches
(which, incidentally, means doing your stepping through 2^n times, with
n being the number of branchings), in which case you'd have written a
unit test and might as well give it a run for itself and see in one go
whether there's a problem in the first place.

What's more, you speak of newly-written code. I understood Leif's
comment to apply to debugging, rather.

-- 
DF.
An escaped convict once said to me:
"Alcatraz is the place to be"
0
Reply Daniele 3/20/2011 7:04:05 PM

Mike Schilling wrote:
> Daniele Futtorovic wrote:
>> Leif Roar Moldskred allegedly wrote:
>>> I've seen far too many developers who spend time blithely single-stepping
>>> through code instead of thinking about what could be wrong.

>> Amen. Always makes me wonder whether a good punching would help.

> Single-stepping through newly-written code is an excellent way to determine
> whether it's working as designed, or getting what looks like the right answer
> for the wrong reason.

The right tool is what works for a given programmer at a given moment with the 
given situation.  One shouldn't be afraid to apply the debugger, but it isn't 
the only crayon in the box.

Not long ago I worked on a routine (to calculate the number of days in an 
interval) that appeared to pass its unit tests because the test code had the 
same bug as the code under test, canceling the effect.  Code inspection 
revealed suspicion, debugging confirmed it, a new test class was able to 
validate the difference and confirm the fix, and judicious log statements in 
the code guarded against future problems.  All the techniques were useful.

-- 
Lew
A mixed metaphor is like casting your pearls before they hatch.
0
Reply Lew 3/20/2011 7:07:46 PM

In message <z5nhp.37980$d46.4501@newsfe07.iad>, Arved Sandstrom wrote:

> If you are doing standard editing+building of Java source, say, it's
> basically impossible for Emacs on any platform to be faster, in practical
> terms, than Eclipse or Netbeans or IntelliJ. What could possibly be
> faster?

Pressing CTRL/S to start a search, typing the search string, then repeating 
CTRL/S to step forward through all instances or CTRL/R to step backward. 
Press Enter to leave the point at the desired location, or CTRl/G to abandon 
the search.

Pressing CTRL-X ( to start defining a macro, CTRL-X ) to finish it, then 
CTRL-X e to execute it, e to execute again, repeat, repeat.

Having multiple clipboards with CTRL/X r s 1, CTRL/X r s 2 etc.

Being able to execute a shell command and insert its output directly into a 
text buffer.

Basically, being able to type as fast as you can think.
0
Reply Lawrence 3/20/2011 8:04:29 PM

On 11-03-20 03:38 PM, Mike Schilling wrote:
> "Daniele Futtorovic" <da.futt.news@laposte-dot-net.invalid> wrote in
> message news:im5ash$sjc$1@news.eternal-september.org...
>> On 20/03/2011 15:56, Leif Roar Moldskred allegedly wrote:
>>> I've seen far too many developers who spend time blithely
>>> single-stepping
>>> through code instead of thinking about what could be wrong.
>>
>> Amen. Always makes me wonder whether a good punching would help.
> 
> Single-stepping through newly-written code is an excellent way to
> determine whether it's working as designed, or getting what looks like
> the right answer for the wrong reason.

I won't argue the point; it's clearly a useful thing for you to do in
some scenario involving new code. The question that occurs to me is,
given that if we're considering debugging that we've got executable code
in hand, what happened to all the unit tests? And functional tests?

"Right answer for the wrong reason": I can see debugging happening here.
Lew came up with a scenario where that was useful. But "determining
whether it's working as designed": I don't see this as a compelling
scenario for debugging.

On a related note, and I could have added this to a reply to several
other posts in this thread, I tend to look at defect work in any stage
of development - new code or old code - as an opportunity to help out
the ops support people and the maintenance programmers. Probably because
I do mostly maintenance consulting - how to rescue applications. :-)
Because debugging is sort of the tool of last resort in this environment
I consider logging and tests and code knowledge to come first. In fact
even with a codebase that I didn't have source for I'd probably consider
decompiling first, as an aid to putting in useful tracing with something
like AspectJ.

The other point to consider, in discussing a limited skillset that
focuses on debugging, is how do you deal with all those defects that
cannot be reliably reproduced, or that don't happen in a debugger? By
"reliably reproduced" I mean those defects - and they are common - that
happen in production but that nobody knows how to make happen in any
other setting.

AHS
-- 
The user's going to pick dancing pigs over security every time.
-- Bruce Schneier

0
Reply Arved 3/20/2011 8:18:03 PM

On 20/03/2011 21:04, Lawrence D'Oliveiro allegedly wrote:
> Basically, being able to type as fast as you can think.

It's either one or the other, lad. You can't see the big picture when 
you've got to focus on writing the small one.

-- 
DF.
An escaped convict once said to me:
"Alcatraz is the place to be"
0
Reply Daniele 3/20/2011 8:27:45 PM

On 11-03-20 05:04 PM, Lawrence D'Oliveiro wrote:
> In message <z5nhp.37980$d46.4501@newsfe07.iad>, Arved Sandstrom wrote:
> 
>> If you are doing standard editing+building of Java source, say, it's
>> basically impossible for Emacs on any platform to be faster, in practical
>> terms, than Eclipse or Netbeans or IntelliJ. What could possibly be
>> faster?
> 
> Pressing CTRL/S to start a search, typing the search string, then repeating 
> CTRL/S to step forward through all instances or CTRL/R to step backward. 
> Press Enter to leave the point at the desired location, or CTRl/G to abandon 
> the search.

Every decent text editor under the sun, whether contained in an IDE or
standalone, can do this through multiple files in defined scopes. Java
IDES can also let you restrict your search to methods or ctors or
fields, for example. I must be missing something.

> Pressing CTRL-X ( to start defining a macro, CTRL-X ) to finish it, then 
> CTRL-X e to execute it, e to execute again, repeat, repeat.

The main Java IDEs have macros in a true sense of the term. You haven't
found them yet?

> Having multiple clipboards with CTRL/X r s 1, CTRL/X r s 2 etc.

Some Java IDEs have this capability or an equivalent. Failing that it's
not exactly difficult to keep a text editor pane/window open as a clipboard.

> Being able to execute a shell command and insert its output directly into a 
> text buffer.

Well, let's see, I need to do that _inside_ a Java IDE about once every
5 years. Considering that the operation of executing a shell command and
inserting its output into a file I can do in a Linux/Mac OS X terminal
or a Windows Powershell window, I don't think I'm missing much here.

> Basically, being able to type as fast as you can think.

Which is fantastic if you're writing a book.

AHS
-- 
The user's going to pick dancing pigs over security every time.
-- Bruce Schneier

0
Reply Arved 3/20/2011 9:07:52 PM

On Sun, 20 Mar 2011 17:18:03 -0300, Arved Sandstrom wrote:

> The other point to consider, in discussing a limited skillset that
> focuses on debugging, is how do you deal with all those defects that
> cannot be reliably reproduced, or that don't happen in a debugger? By
> "reliably reproduced" I mean those defects - and they are common - that
> happen in production but that nobody knows how to make happen in any
> other setting.
>
That can be where the next stage after the ability to turn on tracing/
logging really shines - tracing/logging via a circular buffer, where 
tracing messages are generated but written into a circular buffer rather 
than to a file. The buffer is dumped if/when the program hits a fatal or 
a serious but recoverable error. There are three benefits from this 
approach:

- the overheads of writing to the circular buffer are much less than
  writing to a log file - so much so that the impact on the running
  system is often scarcely noticeable.

- you don't have megabytes of trace log chewing up disk space and
  using bandwidth if it gets sent to the maintenance programmer. 

- you merely get the n trace messages, where n is the number of lines
  in the buffer and will be a few hundred at most. This is usually
  plenty to show the error and how it caused the more serious error.

Its an approach I learned back in the late 70s when I was sysadmin for 
ICL's George 3 OS, which maintained two circular buffers, one much finer 
grained than the other, and which could be printed out during a crash 
analysis.  

If your shop has a standard tracing class its worth giving it a 
configurable circular buffering capability.


-- 
martin@   | Martin Gregorie
gregorie. | Essex, UK
org       |
0
Reply martin1645 (571) 3/20/2011 9:15:23 PM

On 20-03-2011 11:22, Sherm Pendley wrote:
> Steve Sobol<sjsobol@JustThe.net>  writes:
>> In article<m2mxkqwle9.fsf@softwarematters.org>,
>> patrick@softwarematters.org says...
>>> Roedy Green<see_website@mindprod.com.invalid>  writes:
>>>> I'm curious what people are using as their IDE to write Java code.
>>>> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
>>>> now?  What are you using?
>>>
>>>       Emacs.  And I'm measurably more productive than my colleagues who
>>> waste their time fighting with their IDEs.
>>
>> I don't know... I find the use of Eclipse to be very productive.
>
> I've never seriously used Eclipse, but I'd be willing to bet a paycheck
> that I could adapt and be productive with it in a week or two. The key
> word there is "adapt" - a little flexibility goes a long way.

Being able to learn a new tool relative quickly is a
requirement for being a good software developer.

Arne

0
Reply ISO 3/20/2011 9:29:53 PM

On 20/03/2011 22:15, Martin Gregorie allegedly wrote:
> On Sun, 20 Mar 2011 17:18:03 -0300, Arved Sandstrom wrote:
>
>> The other point to consider, in discussing a limited skillset that
>> focuses on debugging, is how do you deal with all those defects that
>> cannot be reliably reproduced, or that don't happen in a debugger? By
>> "reliably reproduced" I mean those defects - and they are common - that
>> happen in production but that nobody knows how to make happen in any
>> other setting.
>>
> That can be where the next stage after the ability to turn on tracing/
> logging really shines - tracing/logging via a circular buffer, where
> tracing messages are generated but written into a circular buffer rather
> than to a file. The buffer is dumped if/when the program hits a fatal or
> a serious but recoverable error. There are three benefits from this
> approach:
>
> - the overheads of writing to the circular buffer are much less than
>    writing to a log file - so much so that the impact on the running
>    system is often scarcely noticeable.
>
> - you don't have megabytes of trace log chewing up disk space and
>    using bandwidth if it gets sent to the maintenance programmer.
>
> - you merely get the n trace messages, where n is the number of lines
>    in the buffer and will be a few hundred at most. This is usually
>    plenty to show the error and how it caused the more serious error.
>
> Its an approach I learned back in the late 70s when I was sysadmin for
> ICL's George 3 OS, which maintained two circular buffers, one much finer
> grained than the other, and which could be printed out during a crash
> analysis.
>
> If your shop has a standard tracing class its worth giving it a
> configurable circular buffering capability.

Sounds cool. But what if you want to have logging statements so as to 
affirm that some expected thing happened?


0
Reply Daniele 3/20/2011 9:46:41 PM

Arved Sandstrom wrote:
> Lawrence D'Oliveiro wrote:
>> Basically, being able to type as fast as you can think.

> Which is fantastic if you're writing a book.

They don't make a typewriter that fast.

-- 
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg
0
Reply Lew 3/20/2011 10:43:42 PM


"Daniele Futtorovic" <da.futt.news@laposte-dot-net.invalid> wrote in message 
news:im5j34$a82$1@news.eternal-september.org...
> On 20/03/2011 19:38, Mike Schilling allegedly wrote:
>> "Daniele Futtorovic" <da.futt.news@laposte-dot-net.invalid> wrote in
>> message news:im5ash$sjc$1@news.eternal-september.org...
>>> On 20/03/2011 15:56, Leif Roar Moldskred allegedly wrote:
>>>> I've seen far too many developers who spend time blithely
>>>> single-stepping
>>>> through code instead of thinking about what could be wrong.
>>>
>>> Amen. Always makes me wonder whether a good punching would help.
>>
>> Single-stepping through newly-written code is an excellent way to
>> determine whether it's working as designed
>
> Not even that. Not unless you can simulate all the logical branches
> (which, incidentally, means doing your stepping through 2^n times, with
> n being the number of branchings),

If they're two-way branches :-)

> in which case you'd have written a
> unit test and might as well give it a run for itself and see in one go
> whether there's a problem in the first place.

But if you want to check whether, for instance, your logic for exiting a 
loop early works, you're not going to get with with a JUnit-type "is the 
result right?" test.  You may find it much later when analyzing performance, 
but that won't be cheap.
 

0
Reply Mike 3/20/2011 10:53:03 PM

On Sun, 20 Mar 2011 22:46:41 +0100, Daniele Futtorovic wrote:

> On 20/03/2011 22:15, Martin Gregorie allegedly wrote:
>> On Sun, 20 Mar 2011 17:18:03 -0300, Arved Sandstrom wrote:
>>
>>> The other point to consider, in discussing a limited skillset that
>>> focuses on debugging, is how do you deal with all those defects that
>>> cannot be reliably reproduced, or that don't happen in a debugger? By
>>> "reliably reproduced" I mean those defects - and they are common -
>>> that happen in production but that nobody knows how to make happen in
>>> any other setting.
>>>
>> That can be where the next stage after the ability to turn on tracing/
>> logging really shines - tracing/logging via a circular buffer, where
>> tracing messages are generated but written into a circular buffer
>> rather than to a file. The buffer is dumped if/when the program hits a
>> fatal or a serious but recoverable error. There are three benefits from
>> this approach:
>>
>> - the overheads of writing to the circular buffer are much less than
>>    writing to a log file - so much so that the impact on the running
>>    system is often scarcely noticeable.
>>
>> - you don't have megabytes of trace log chewing up disk space and
>>    using bandwidth if it gets sent to the maintenance programmer.
>>
>> - you merely get the n trace messages, where n is the number of lines
>>    in the buffer and will be a few hundred at most. This is usually
>>    plenty to show the error and how it caused the more serious error.
>>
>> Its an approach I learned back in the late 70s when I was sysadmin for
>> ICL's George 3 OS, which maintained two circular buffers, one much
>> finer grained than the other, and which could be printed out during a
>> crash analysis.
>>
>> If your shop has a standard tracing class its worth giving it a
>> configurable circular buffering capability.
> 
> Sounds cool. But what if you want to have logging statements so as to
> affirm that some expected thing happened?
>
If you have logging statements to report that stuff has happened then 
that would go into the buffer.

Similarly, I'd expect your logging system could turn buffering on or off 
at run time as well as setting a logging level level filter. I usually 
control this via command line options but I might make it settable on a 
server via a control and monitoring client as well.

My current Java tracing class provides an error() method, which outputs a 
message and stops the run and a trace() method which can be used for, 
err, tracing and debugging. All output goes to stderr but the tracing 
level control is done via conditionals in the program because that saves 
to overhead of an essentially null call method call when tracing is off.

I'm not currently using a circular buffer, but slotting it into the 
tracing class and making calls of error() trigger a buffer dump are 
obviously trivial to implement.  I'd also make the buffer size 
configurable and add a dump() method so I could also force a buffer dump 
without needing a fatal error to trigger it. I might also add a clear() 
method so that, e.g. a program could clear the buffer at the start of 
each cycle round the main loop.



-- 
martin@   | Martin Gregorie
gregorie. | Essex, UK
org       |
0
Reply Martin 3/20/2011 11:30:00 PM

On 18/03/2011 23:50, Roedy Green wrote:
> I'm curious what people are using as their IDE to write Java code.
> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
> now?  What are you using?

Forced to use Eclipse by Android

-- 
Dirk

http://www.neopax.com/technomage/ - My new book - Magick and Technology
0
Reply Dirk 3/20/2011 11:47:59 PM

On 20-03-2011 19:47, Dirk Bruere at NeoPax wrote:
> On 18/03/2011 23:50, Roedy Green wrote:
>> I'm curious what people are using as their IDE to write Java code.
>> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
>> now? What are you using?
>
> Forced to use Eclipse by Android

Forced is a strong way.

You are following Google's recommendation to
use Eclipse for Android development.

Arne

0
Reply UTF 3/20/2011 11:55:28 PM

On 3/20/2011 2:46 PM, Daniele Futtorovic wrote:

>> If your shop has a standard tracing class its worth giving it a
>> configurable circular buffering capability.
>
> Sounds cool. But what if you want to have logging statements so as to
> affirm that some expected thing happened?


I haven't actually tried to build such a thing, but Java logging has a 
circular buffer built in (MemoryHandler) as well as the more standard 
console and file handlers.

I would probably start by having two handler, one MemoryHandler and one 
FileHandler.  Set the priority on the FileHandler to "normal" levels -- 
Severe, Warning, Config, Info.  If you want to "know that something 
happened", write it out with one of those levels.

At the same time set the MemoryHandler to a much lower level, say 
"Finer" or similar.  When something does happen, dump the MemoryHandler. 
  Then you'll have both standard logs and the recent log of events just 
before the event of interest.  This seems to be what Martin is talking 
about.

0
Reply markspace 3/21/2011 12:08:18 AM

In message <8uni10Fns8U1@mid.individual.net>, Dirk Bruere at NeoPax wrote:

> Forced to use Eclipse by Android

I am doing Android development without Eclipse.

Just fine, thank you.
0
Reply Lawrence 3/21/2011 12:30:14 AM

In message <im5nvv$447$1@news.eternal-september.org>, Daniele Futtorovic 
wrote:

> On 20/03/2011 21:04, Lawrence D'Oliveiro allegedly wrote:
>
>> Basically, being able to type as fast as you can think.
> 
> It's either one or the other, lad. You can't see the big picture when
> you've got to focus on writing the small one.

Are you admitting you can’t type and think at the same time?
0
Reply Lawrence 3/21/2011 12:30:38 AM

In message <M0uhp.29469$yR1.20309@newsfe03.iad>, Arved Sandstrom wrote:

> On 11-03-20 05:04 PM, Lawrence D'Oliveiro wrote:
>
>> Pressing CTRL-X ( to start defining a macro, CTRL-X ) to finish it, then
>> CTRL-X e to execute it, e to execute again, repeat, repeat.
> 
> The main Java IDEs have macros in a true sense of the term. You haven't
> found them yet?

Macros are just a quick convenience. For anything more complicated, I want a 
proper scripting language. Which Emacs has.
0
Reply Lawrence 3/21/2011 12:31:53 AM

On 21/03/2011 01:08, markspace allegedly wrote:
> On 3/20/2011 2:46 PM, Daniele Futtorovic wrote:
>
>>> If your shop has a standard tracing class its worth giving it a
>>> configurable circular buffering capability.
>>
>> Sounds cool. But what if you want to have logging statements so as
>> to affirm that some expected thing happened?
>
>
> I haven't actually tried to build such a thing, but Java logging has
> a circular buffer built in (MemoryHandler) as well as the more
> standard console and file handlers.
>
> I would probably start by having two handler, one MemoryHandler and
> one FileHandler. Set the priority on the FileHandler to "normal"
> levels -- Severe, Warning, Config, Info. If you want to "know that
> something happened", write it out with one of those levels.
>
> At the same time set the MemoryHandler to a much lower level, say
> "Finer" or similar. When something does happen, dump the
> MemoryHandler. Then you'll have both standard logs and the recent log
> of events just before the event of interest. This seems to be what
> Martin is talking about.

Sounds really good, actually. I'm starting to like this.

Okay, but this does presuppose that you have one, or some very few, core
places to your application where things are run in some kind of loop and
where you can catch 'interesting events', doesn't it? I mean, you have
to trigger the dump somehow.

-- 
DF.
An escaped convict once said to me:
"Alcatraz is the place to be"
0
Reply Daniele 3/21/2011 12:35:04 AM

On 21/03/2011 01:30, Lawrence D'Oliveiro allegedly wrote:
> In message<im5nvv$447$1@news.eternal-september.org>, Daniele
> Futtorovic wrote:
>
>> On 20/03/2011 21:04, Lawrence D'Oliveiro allegedly wrote:
>>
>>> Basically, being able to type as fast as you can think.
>>
>> It's either one or the other, lad. You can't see the big picture
>> when you've got to focus on writing the small one.
>
> Are you admitting you can=92t type and think at the same time?

I'm claiming that on average neither I nor you nor anyone else can
concentrate on writing a specific line of code and at the same time on
the overall architecture that line of code is part of. It's like the
forest and the trees.

--=20
DF.
An escaped convict once said to me:
"Alcatraz is the place to be"

0
Reply Daniele 3/21/2011 12:38:29 AM

On 3/20/2011 5:35 PM, Daniele Futtorovic wrote:

> Okay, but this does presuppose that you have one, or some very few, core
> places to your application where things are run in some kind of loop and
> where you can catch 'interesting events', doesn't it? I mean, you have
> to trigger the dump somehow.


Yes.  I can think of two ways to do it, off hand.  One would be to have 
some sort of ad-hoc mechanism.  You add some code to a known problem 
area to call a "dump" method which triggers the MemoryHandler.

The second way I think would be to have some general mechanism.  You 
could try a logging Handler that, instead of logging (or in addition to 
logging) also triggered the MemoryHandler when it gets a specific level 
or type of Exception.  You'd have to write such a class specially, but 
once you did you'd have some flexibility to attach it to problem areas 
wherever they are found, without having to modify code and recompile.


0
Reply markspace 3/21/2011 12:48:10 AM

On 21/03/2011 01:48, markspace allegedly wrote:
> On 3/20/2011 5:35 PM, Daniele Futtorovic wrote:
>
>> Okay, but this does presuppose that you have one, or some very few,
>> core places to your application where things are run in some kind
>> of loop and where you can catch 'interesting events', doesn't it? I
>> mean, you have to trigger the dump somehow.
>
>
> Yes. I can think of two ways to do it, off hand. One would be to have
> some sort of ad-hoc mechanism. You add some code to a known problem
> area to call a "dump" method which triggers the MemoryHandler.
>
> The second way I think would be to have some general mechanism. You
> could try a logging Handler that, instead of logging (or in addition
>  to logging) also triggered the MemoryHandler when it gets a specific
>  level or type of Exception. You'd have to write such a class
> specially, but once you did you'd have some flexibility to attach it
>  to problem areas wherever they are found, without having to modify
> code and recompile.

Yes, this second one is the one I've been thinking about in the
meantime. Extremely neat and powerful. I think that's what I'm gonna
write tomorrow. Although I think I'll make the MemoryHandler attachable
to the Thread or the ThreadGroup...

Should be a lot of fun! Thanks for the inspiration to you, markspace and
Martin.

-- 
DF.
An escaped convict once said to me:
"Alcatraz is the place to be"
0
Reply Daniele 3/21/2011 1:06:24 AM

On 3/20/2011 6:06 PM, Daniele Futtorovic wrote:

>
> Yes, this second one is the one I've been thinking about in the
> meantime. Extremely neat and powerful.


Here's what I came up with.  Note that after checking the docs, I 
noticed that MemoryHandler will self-push if its pushLevel is met or 
exceeded.  So if that's all the functionality you need you have it in 
one class already.

The code below is completely untested.


package test;

import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.MemoryHandler;

/**
  *
  * @author Brenden
  */
public class TriggerHandler extends java.util.logging.Handler {

     public TriggerHandler() {
         setLevel( Level.SEVERE );
         String slevel = LogManager.getLogManager().getProperty(
                 "logging.config.memorydump.trigger.level");
         try {
             Level level = Level.parse(slevel);
             setLevel( level );
         } catch( IllegalArgumentException ex ) {
             // bail, log this?
         }
     }


     @Override
     public void publish(LogRecord record) {
         if( record.getLevel().intValue() >= getLevel().intValue() ) {
             String logger = LogManager.getLogManager().getProperty(
                     "logging.config.memorydump.logger");
             if( logger == null ) {
                 logger = ""; // root logger
             }
             Handler[] handlers = Logger.getLogger(logger).getHandlers();
             for( Handler h : handlers ) {
                 if( h instanceof MemoryHandler ) {
                     MemoryHandler mh = (MemoryHandler)h;
                     mh.push();
                     mh.flush();
                 }
             }
         }
         // Assume parent handlers will be invoked.
     }

     @Override
     public void flush() {
     }

     @Override
     public void close() throws SecurityException {
     }

}
0
Reply markspace 3/21/2011 2:31:09 AM

On Sun, 20 Mar 2011 11:38:10 -0700, "Mike Schilling"
<mscottschilling@hotmail.com> wrote, quoted or indirectly quoted
someone who said :

>Single-stepping through newly-written code is an excellent way to determine 
>whether it's working as designed, or getting what looks like the right 
>answer for the wrong reason.

I get in trouble thinking code is working just because the results
look plausible.  If I single step through some of the complicated
bits, bugs show up when I see behaviour that is not expected, even if
it does not lead to palpably wrong output. 

One of the bugs I am discovering hides longest is writing regex
patterns that find only 99% of the instances they should. Often the
problematic case does not exist anywhere at the time I write the code.
It only shows up later.

You pretty well have to create a set of pathological examples and run
tests with them.
-- 
Roedy Green Canadian Mind Products
http://mindprod.com
If you think it’s expensive to hire a professional to do the job, wait until you hire an amateur.
~ Red Adair

0
Reply Roedy 3/21/2011 4:05:40 AM

On 11-03-20 09:31 PM, Lawrence D'Oliveiro wrote:
> In message <M0uhp.29469$yR1.20309@newsfe03.iad>, Arved Sandstrom wrote:
> 
>> On 11-03-20 05:04 PM, Lawrence D'Oliveiro wrote:
>>
>>> Pressing CTRL-X ( to start defining a macro, CTRL-X ) to finish it, then
>>> CTRL-X e to execute it, e to execute again, repeat, repeat.
>>
>> The main Java IDEs have macros in a true sense of the term. You haven't
>> found them yet?
> 
> Macros are just a quick convenience. For anything more complicated, I want a 
> proper scripting language. Which Emacs has.

I won't deny that. But let's look at the original terms of reference for
this thread, which I'm trying to stick to: IDE's for writing Java code.
That context is why, for example, I'm skeptical of the advantage of
being able to squeeze out every last bit of ergonomic speed in typing -
we're writing *code*.

As for scripting of the IDE, the real discussion there is about the
ability to extend the capability of the IDE. In Emacs you do it one way,
in the main Java IDEs you do it other ways (although you can consider
"scripting" languages also).

Eventually you'll change the requirements to the extent that only Emacs
can satisfy them...like "editor must be extensible and customizable with
Emacs Lisp".

AHS
-- 
The user's going to pick dancing pigs over security every time.
-- Bruce Schneier

0
Reply Arved 3/21/2011 9:10:46 AM

Arved Sandstrom wrote:
> Lawrence D'Oliveiro wrote:
>> Arved Sandstrom wrote:

>>> Lawrence D'Oliveiro wrote:
>>>> Pressing CTRL-X ( to start defining a macro, CTRL-X ) to finish it, then
>>>> CTRL-X e to execute it, e to execute again, repeat, repeat.

>>> The main Java IDEs have macros in a true sense of the term. You haven't
>>> found them yet?

>> Macros are just a quick convenience. For anything more complicated, I want a
>> proper scripting language. Which Emacs has.

> I won't deny that. But let's look at the original terms of reference for
> this thread, which I'm trying to stick to: IDE's [sic] for writing Java code.
> That context is why, for example, I'm skeptical of the advantage of
> being able to squeeze out every last bit of ergonomic speed in typing -
> we're writing *code*.

Implicit in your point is the necessity to think whilst coding.

If one uses the hundred-monkeys approach (bang at the keyboard enough and 
you'll wind up with Shakespeare, or at least some code you can give to your 
manager) then yes, typing speed is more important.

> As for scripting of the IDE, the real discussion there is about the
> ability to extend the capability of the IDE. In Emacs you do it one way,
> in the main Java IDEs you do it other ways (although you can consider
> "scripting" languages also).
>
> Eventually you'll change the requirements to the extent that only Emacs
> can satisfy them...like "editor must be extensible and customizable with
> Emacs Lisp".

"No true Scotsman".

-- 
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg
0
Reply Lew 3/21/2011 11:45:29 AM

Lawrence D'Oliveiro <ldo@geek-central.gen.new_zealand> writes:
> In message <8uni10Fns8U1@mid.individual.net>, Dirk Bruere at NeoPax wrote:
>> Forced to use Eclipse by Android
>
> I am doing Android development without Eclipse.
>
> Just fine, thank you.

     That's at least two of us.

Patrick

------------------------------------------------------------------------
http://www.softwarematters.org
Large scale, mission-critical, distributed OO systems design and
implementation.  (C++, Java, Common Lisp, Jini, middleware, SOA)
0
Reply Patrick 3/21/2011 12:31:25 PM

Roedy Green <see_website@mindprod.com.invalid> writes:
> On Sat, 19 Mar 2011 22:55:42 -0400, Patrick May
> <patrick@softwarematters.org> wrote, quoted or indirectly quoted
> someone who said :
>
>>     Emacs.  And I'm measurably more productive than my colleagues who
>>waste their time fighting with their IDEs.
>
> I take it you are not a windows user, or for some reason are able to
> avoid windows apps. I found flipping back and forth insanity inducing.

     Flipping back and forth between what?  Emacs runs on Windows and,
with cygwin's bash shell, it's almost a not unpleasant development
environment.

     Most of my work is server-side, though, so I can develop under OSX
and Linux.

Regards,

Patrick

------------------------------------------------------------------------
http://www.softwarematters.org
Large scale, mission-critical, distributed OO systems design and
implementation.  (C++, Java, Common Lisp, Jini, middleware, SOA)
0
Reply Patrick 3/21/2011 12:33:37 PM

Arved Sandstrom <asandstrom3minus1@eastlink.ca> writes:
> On 11-03-19 11:55 PM, Patrick May wrote:
>> Roedy Green <see_website@mindprod.com.invalid> writes:
>>> I'm curious what people are using as their IDE to write Java code.
>>> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
>>> now?  What are you using?
>> 
>>      Emacs.  And I'm measurably more productive than my colleagues who
>> waste their time fighting with their IDEs.
>
> Nothing against Emacs, but if your colleagues are "fighting" with their
> IDEs then they are either novices or doing something wrong.

     Actually, they're pretty experienced.  Most of the fighting I see
is when new versions of any component of their tool chain come out,
although I do see them occasionally having to restart their IDE to fix
some problem or other.

> If you are doing standard editing+building of Java source, say, it's
> basically impossible for Emacs on any platform to be faster, in
> practical terms, than Eclipse or Netbeans or IntelliJ.

     In practical terms, I have sat in several train-the-trainers
sessions for new product releases and found that, using Emacs plus
command line builds, I routinely finish the exercises before any of the
IDE users and have time to explore more features.  This productivity is
also apparent in production development environments.

     YMMV, of course.

Regards,

Patrick

------------------------------------------------------------------------
http://www.softwarematters.org
Large scale, mission-critical, distributed OO systems design and
implementation.  (C++, Java, Common Lisp, Jini, middleware, SOA)
0
Reply Patrick 3/21/2011 12:39:13 PM

On 20/03/11 20:04, Lawrence D'Oliveiro wrote:
> In message <z5nhp.37980$d46.4501@newsfe07.iad>, Arved Sandstrom wrote:
> 
>> If you are doing standard editing+building of Java source, say, it's
>> basically impossible for Emacs on any platform to be faster, in practical
>> terms, than Eclipse or Netbeans or IntelliJ. What could possibly be
>> faster?
> 
> Pressing CTRL/S to start a search, typing the search string, then repeating 
> CTRL/S to step forward through all instances or CTRL/R to step backward.

and that's where Emacs falls flat on its face. CtrlsS is XOFF on a
serial link. I know it can be re-mapped, but then you usually end up
with different keymaps on different systems, and since Emacs is entirely
keymap based it becomes very, very confusing.


> Press Enter to leave the point at the desired location, or CTRl/G to abandon 
> the search.

and using search in an IDE is just as simple and quick. With many added
benefits.

> 
> Pressing CTRL-X ( to start defining a macro, CTRL-X ) to finish it, then 
> CTRL-X e to execute it, e to execute again, repeat, repeat.

You need to spend time learning how to use an IDE.

> 
> Having multiple clipboards with CTRL/X r s 1, CTRL/X r s 2 etc.

is a messy hack.

> 
> Being able to execute a shell command and insert its output directly into a 
> text buffer.
> 

is of very little advantage in windowed systems. On the very rare
occasions I need to do that I just type the command into a shell, select
the required portion of the output, and click the middle mouse button in
the IDE to paste the contents.

> Basically, being able to type as fast as you can think.

is in general a bad idea. It just encourages you to type without
thinking through the consequences of what you are typing.

-- 
Nigel Wade
0
Reply Nigel 3/21/2011 1:40:29 PM

On 21/03/2011 03:31, markspace allegedly wrote:
> On 3/20/2011 6:06 PM, Daniele Futtorovic wrote:
>
>>
>> Yes, this second one is the one I've been thinking about in the
>> meantime. Extremely neat and powerful.
>
>
> Here's what I came up with. Note that after checking the docs, I noticed
> that MemoryHandler will self-push if its pushLevel is met or exceeded.
> So if that's all the functionality you need you have it in one class
> already.

My company's code is tied to log4j. Since I already have my trusted
logging layer for that...

public static void log( Logger logger, Level level, Throwable t, String 
format, Object... args ){
   if( level.isGreaterOrEqual(logger.getEffectiveLevel()) ){
     logger.log( level, String.format(format, args), t );
   }
}

.... I took another approach. I installed a ThreadLocal circular buffer,
its contents instances of a subclass of log4j's LoggingEvent (to avoid
doing the String#format needlessly). Then, when the log method above is
called: if it doesn't pass the level, it goes into the buffer; 
otherwise, if it's Level.ERROR, the contents of the buffer are logged;
fi; then the statement is logged; fi.

I'm going to have a look how it works out in practice, but first results
were pleasing. Considering the standard production mode where little
is logged under normal circumstances, I get the full monty when
an error occurs. Kinda of the best of two worlds: no unnecessary
clutter, and all the details I need when it matters. In development, the
level is on full, of course.

It's still a bit shaky to my liking, but as far as I can see the
pernicious idiom:

if( logger.isMyLevelEnabled() )
   logger.myLevel( message )

prohibits anything more solid.


> The code below is completely untested.
>
>
> package test;
>
> import java.util.logging.Handler;
> import java.util.logging.Level;
> import java.util.logging.LogManager;
> import java.util.logging.LogRecord;
> import java.util.logging.Logger;
> import java.util.logging.MemoryHandler;
>
> /**
> *
> * @author Brenden
> */
> public class TriggerHandler extends java.util.logging.Handler {
>
> public TriggerHandler() {
> setLevel( Level.SEVERE );
> String slevel = LogManager.getLogManager().getProperty(
> "logging.config.memorydump.trigger.level");
> try {
> Level level = Level.parse(slevel);
> setLevel( level );
> } catch( IllegalArgumentException ex ) {
> // bail, log this?
> }
> }
>
>
> @Override
> public void publish(LogRecord record) {
> if( record.getLevel().intValue() >= getLevel().intValue() ) {
> String logger = LogManager.getLogManager().getProperty(
> "logging.config.memorydump.logger");
> if( logger == null ) {
> logger = ""; // root logger
> }
> Handler[] handlers = Logger.getLogger(logger).getHandlers();
> for( Handler h : handlers ) {
> if( h instanceof MemoryHandler ) {
> MemoryHandler mh = (MemoryHandler)h;
> mh.push();
> mh.flush();
> }
> }
> }
> // Assume parent handlers will be invoked.
> }
>
> @Override
> public void flush() {
> }
>
> @Override
> public void close() throws SecurityException {
> }
>
> }

0
Reply Daniele 3/21/2011 6:24:32 PM

On Mon, 21 Mar 2011 08:33:37 -0400, Patrick May
<patrick@softwarematters.org> wrote, quoted or indirectly quoted
someone who said :

>     Flipping back and forth between what?  Emacs runs on Windows and,
>with cygwin's bash shell, it's almost a not unpleasant development
>environment.

Emacs and CUA user interfaces.
-- 
Roedy Green Canadian Mind Products
http://mindprod.com
If you think it’s expensive to hire a professional to do the job, wait until you hire an amateur.
~ Red Adair

0
Reply Roedy 3/21/2011 6:40:36 PM

Roedy Green wrote:
> Patrick May wrote, quoted or indirectly quoted someone who said :
>>      Flipping back and forth between what?  Emacs runs on Windows and,
>> with cygwin's bash shell, it's almost a not unpleasant development
>> environment.
>
> Emacs and CUA user interfaces.

And that's different from an IDE how?

-- 
Lew
Honi soit qui mal y pense.
http://upload.wikimedia.org/wikipedia/commons/c/cf/Friz.jpg
0
Reply Lew 3/21/2011 11:03:29 PM

On 11-03-21 09:39 AM, Patrick May wrote:
> Arved Sandstrom <asandstrom3minus1@eastlink.ca> writes:
>> On 11-03-19 11:55 PM, Patrick May wrote:
>>> Roedy Green <see_website@mindprod.com.invalid> writes:
>>>> I'm curious what people are using as their IDE to write Java code.
>>>> The biggies used to be Eclipse, NetBeans and IntelliJ. What are they
>>>> now?  What are you using?
>>>
>>>      Emacs.  And I'm measurably more productive than my colleagues who
>>> waste their time fighting with their IDEs.
>>
>> Nothing against Emacs, but if your colleagues are "fighting" with their
>> IDEs then they are either novices or doing something wrong.
> 
>      Actually, they're pretty experienced.  Most of the fighting I see
> is when new versions of any component of their tool chain come out,
> although I do see them occasionally having to restart their IDE to fix
> some problem or other.

Call me skeptical then that they are really spending all that much time
"fighting" with their IDEs. The amount of time I spend installing or
updating any IDE plugins is somewhere well below 1 percent of all my
working hours.

Restarting happens. Quite infrequently if you avoid or uninstall flaky
plugins, and if you don't leave your IDE open for a month at a time.

>> If you are doing standard editing+building of Java source, say, it's
>> basically impossible for Emacs on any platform to be faster, in
>> practical terms, than Eclipse or Netbeans or IntelliJ.
> 
>      In practical terms, I have sat in several train-the-trainers
> sessions for new product releases and found that, using Emacs plus
> command line builds, I routinely finish the exercises before any of the
> IDE users and have time to explore more features.  This productivity is
> also apparent in production development environments.
> 
>      YMMV, of course.
> 
> Regards,
> 
> Patrick

True enough, everyone's mileage will vary. I certainly take you at your
word that you on Emacs are faster than the colleagues you've observed
using IDEs. Based on my personal experience using Emacs, vi and flavours
thereof, a bunch of other programmer's text editors, and dozens of IDEs
for many different languages, I'm very skeptical of the general claim
that a proficient developer, who uses only Emacs and command line to
work in Java (and I'm including complex Java EE projects here including
deployment), can be faster than an equally proficient developer using
only a modern full-featured Java IDE.

The only way I could see that is if you've so tooled up and customized
your Emacs that it *is* a Java/Java EE IDE.

AHS
-- 
That's not the recollection that I recall...All this information is
certainly in the hands of the auditor and we certainly await his report
to indicate what he deems has occurred.
-- Halifax, Nova Scotia mayor Peter Kelly, who is currently deeply in
the shit
0
Reply Arved 3/21/2011 11:31:50 PM

On Sun, 20 Mar 2011, markspace wrote:

> On 3/20/2011 7:56 AM, Leif Roar Moldskred wrote:
>
>> Rather tangential to this discussion, perhaps, but I think that one of 
>> the bad habits of developers who grew up on an IDE as opposed to 
>> text-editors + command-line tools are likely to have is to reach for 
>> the debugger much too soon.
>
> Corrallary: Not using print/log statements to debug code.
>
> Not only are log statements often a much faster way to debug, they are 
> permanent and therefore can be reused later, used when you have new and 
> different problems, and also can be used by other programmers or later 
> in a product's life cycle, i.e. maintenance.

You guys are hillarious. You should go and spend some time with some 
Smalltalk guys who do *all* their programming in the debugger. You'd drop 
that crusty old anti-debuggerist inverse snobbery like a shot.

tom

-- 
Memes don't exist. Tell your friends.
0
Reply Tom 3/22/2011 12:19:27 AM

In message <M0uhp.29469$yR1.20309@newsfe03.iad>, Arved Sandstrom wrote:

> On 11-03-20 05:04 PM, Lawrence D'Oliveiro wrote:
>
>> Being able to execute a shell command and insert its output directly into
>> a text buffer.
> 
> Well, let's see, I need to do that _inside_ a Java IDE about once every
> 5 years. Considering that the operation of executing a shell command and
> inserting its output into a file I can do in a Linux/Mac OS X terminal
> or a Windows Powershell window, I don't think I'm missing much here.

Which is fine with a few tens of lines or possibly even hundreds of lines. 
But when you have to do that with thousands of lines, you start to 
appreciate being able to spit them out straight into an editor buffer.
0
Reply ldo (2177) 3/22/2011 3:47:55 AM

In message <8up2qeF4reU1@mid.individual.net>, Nigel Wade wrote:

> On 20/03/11 20:04, Lawrence D'Oliveiro wrote:
>
> You need to spend time learning how to use an IDE.

Spoken like a true non-Emacs user.

>> Having multiple clipboards with CTRL/X r s 1, CTRL/X r s 2 etc.
> 
> is a messy hack.

Yup, definitely knows little or nothing about Emacs.

>> Being able to execute a shell command and insert its output directly into
>> a text buffer.
> 
> is of very little advantage in windowed systems.

Au contraire, as I have explained elsewhere.

0
Reply ldo (2177) 3/22/2011 3:49:27 AM

In message <qCEhp.33388$hP6.25011@newsfe19.iad>, Arved Sandstrom wrote:

> On 11-03-20 09:31 PM, Lawrence D'Oliveiro wrote:
>
>> In message <M0uhp.29469$yR1.20309@newsfe03.iad>, Arved Sandstrom wrote:
>> 
>>> On 11-03-20 05:04 PM, Lawrence D'Oliveiro wrote:
>>>
>>>> Pressing CTRL-X ( to start defining a macro, CTRL-X ) to finish it,
>>>> then CTRL-X e to execute it, e to execute again, repeat, repeat.
>>>
>>> The main Java IDEs have macros in a true sense of the term. You haven't
>>> found them yet?
>> 
>> Macros are just a quick convenience. For anything more complicated, I
>> want a proper scripting language. Which Emacs has.
> 
> I won't deny that. But let's look at the original terms of reference for
> this thread, which I'm trying to stick to: IDE's for writing Java code.

Is that all you do, day in and day out? That kind of limited focus is what 
gives people the impression that computer programming is a boring, 
repetitive activity.

I use a text editor for lots of things—writing code in several different 
languages, system administration, documentation ... I have even used Emacs 
to patch binary files (proprietary software ... sigh). The whole purpose of 
a computer is to perform tedious and repetitive tasks so I don’t have to, 
and I find that Emacs is just one of the many wonderful things to have on a 
computer for that reason.
0
Reply Lawrence 3/22/2011 3:56:27 AM

In message <tbjdo6d00ivhdvp79oa8rb3a0b982vsf1d@4ax.com>, Roedy Green wrote:

> One of the bugs I am discovering hides longest is writing regex
> patterns that find only 99% of the instances they should. Often the
> problematic case does not exist anywhere at the time I write the code.
> It only shows up later.

I don’t think I have ever written a regular expression complicated enough to 
have that problem. For any situation like that, I would almost certainly 
resort to a hand-coded state machine parser.
0
Reply Lawrence 3/22/2011 3:58:00 AM

In message <im66m5$h6v$1@news.eternal-september.org>, Daniele Futtorovic 
wrote:

> On 21/03/2011 01:30, Lawrence D'Oliveiro allegedly wrote:
>
>> In message<im5nvv$447$1@news.eternal-september.org>, Daniele
>> Futtorovic wrote:
>>
>>> On 20/03/2011 21:04, Lawrence D'Oliveiro allegedly wrote:
>>>
>>>> Basically, being able to type as fast as you can think.
>>>
>>> It's either one or the other, lad. You can't see the big picture
>>> when you've got to focus on writing the small one.
>>
>> Are you admitting you can’t type and think at the same time?
> 
> I'm claiming that on average neither I nor you nor anyone else can
> concentrate on writing a specific line of code and at the same time on
> the overall architecture that line of code is part of. It's like the
> forest and the trees.

While my fingers are typing trees, my brain is seeing forest.
0
Reply Lawrence 3/22/2011 3:59:51 AM

In article <im9687$qq$3@lust.ihug.co.nz>, Lawrence D'Oliveiro says...
> 
> In message <8up2qeF4reU1@mid.individual.net>, Nigel Wade wrote:
> 
> > On 20/03/11 20:04, Lawrence D'Oliveiro wrote:
> >
> > You need to spend time learning how to use an IDE.
> 
> Spoken like a true non-Emacs user.

Emacs is my preferred text editor, but I generally don't use it for 
programming purposes, except for quick-and-dirty changes. I normally use 
Eclipse. Or, for Microsoftish stuff, I'll use Visual Studio.



-- 
Steve Sobol - Programming/WebDev/IT Support
sjsobol@JustThe.net
0
Reply Steve 3/22/2011 4:07:37 AM

On 11-03-22 12:56 AM, Lawrence D'Oliveiro wrote:
> In message <qCEhp.33388$hP6.25011@newsfe19.iad>, Arved Sandstrom wrote:
> 
>> On 11-03-20 09:31 PM, Lawrence D'Oliveiro wrote:
>>
>>> In message <M0uhp.29469$yR1.20309@newsfe03.iad>, Arved Sandstrom wrote:
>>>
>>>> On 11-03-20 05:04 PM, Lawrence D'Oliveiro wrote:
>>>>
>>>>> Pressing CTRL-X ( to start defining a macro, CTRL-X ) to finish it,
>>>>> then CTRL-X e to execute it, e to execute again, repeat, repeat.
>>>>
>>>> The main Java IDEs have macros in a true sense of the term. You haven't
>>>> found them yet?
>>>
>>> Macros are just a quick convenience. For anything more complicated, I
>>> want a proper scripting language. Which Emacs has.
>>
>> I won't deny that. But let's look at the original terms of reference for
>> this thread, which I'm trying to stick to: IDE's for writing Java code.
> 
> Is that all you do, day in and day out? That kind of limited focus is what 
> gives people the impression that computer programming is a boring, 
> repetitive activity.

No, writing code is not all I do, day in and day out. I do what I am
paid to do, which is to help clients rescue poorly-designed,
poorly-implemented and poorly-tested applications on the one hand, and
attempt to create well-designed and properly-implemented/tested systems
for clients on the other hand. Neither of those efforts is completely or
even mostly about coding.

However, the thread is about Java IDEs, and morphed somewhat into a
general discussion of writing Java in various environments. That's why
I'm keeping it focused on Java and the tasks involved in coding Java.

I mean, we could have a discussion about using ActiveState Python versus
using Emacs for Python, but it's outside the scope of this thread.

> I use a text editor for lots of things—writing code in several different 
> languages, system administration, documentation ... I have even used Emacs 
> to patch binary files (proprietary software ... sigh). The whole purpose of 
> a computer is to perform tedious and repetitive tasks so I don’t have to, 
> and I find that Emacs is just one of the many wonderful things to have on a 
> computer for that reason.

I'm not dissing Emacs, and I occasionally use Emacs although I find its
philosophy old-fashioned. As someone else suggested in this thread Emacs
isn't particularly compelling *now* - it made a lot more sense some
decades ago. I'm happy for you that you still like it, and I trust that
if you've been using it for a long, long time that you are quite
productive with it despite its faults.

AHS
-- 
That's not the recollection that I recall...All this information is
certainly in the hands of the auditor and we certainly await his report
to indicate what he deems has occurred.
-- Halifax, Nova Scotia mayor Peter Kelly, who is currently deeply in
the shit
0
Reply Arved 3/22/2011 9:39:24 AM

On 11-03-22 12:47 AM, Lawrence D'Oliveiro wrote:
> In message <M0uhp.29469$yR1.20309@newsfe03.iad>, Arved Sandstrom wrote:
> 
>> On 11-03-20 05:04 PM, Lawrence D'Oliveiro wrote:
>>
>>> Being able to execute a shell command and insert its output directly into
>>> a text buffer.
>>
>> Well, let's see, I need to do that _inside_ a Java IDE about once every
>> 5 years. Considering that the operation of executing a shell command and
>> inserting its output into a file I can do in a Linux/Mac OS X terminal
>> or a Windows Powershell window, I don't think I'm missing much here.
> 
> Which is fine with a few tens of lines or possibly even hundreds of lines. 
> But when you have to do that with thousands of lines, you start to 
> appreciate being able to spit them out straight into an editor buffer.

And why do I need to have this stuff inside an editor at all? If I am
looking to process it with command-line tools I can do that on the
command-line, oddly enough. You're making it out to be a virtue that you
can run command-lines from inside your text editor...I can in fact do
that from a quite a few editors, not just Emacs, but what's the huge
value-added here?

If I do need to manually (as in visually) edit the output, then it's
easy enough to fire up Notepad++ or vi on the file.

It's entirely possible that you do some kind of repetitive file
crunching in some niche clerical capacity for which these capabilities
are well-suited. For my part I've been doing business and scientific
programming since the late '70's and I still can't think of the scenario
where I'd deeply appreciate being able to dump thousands of lines of
tool output into my editor buffer...versus just doing C.L. operations.

Perhaps you could provide a realistic example or two. Educate me.

AHS
-- 
That's not the recollection that I recall...All this information is
certainly in the hands of the auditor and we certainly await his report
to indicate what he deems has occurred.
-- Halifax, Nova Scotia mayor Peter Kelly, who is currently deeply in
the shit
0
Reply Arved 3/22/2011 9:52:42 AM

In message <Lj_hp.42949$Pg4.7727@newsfe22.iad>, Arved Sandstrom wrote:

> On 11-03-22 12:47 AM, Lawrence D'Oliveiro wrote:
>> In message <M0uhp.29469$yR1.20309@newsfe03.iad>, Arved Sandstrom wrote:
>> 
>>> On 11-03-20 05:04 PM, Lawrence D'Oliveiro wrote:
>>>
>>>> Being able to execute a shell command and insert its output directly
>>>> into a text buffer.
>>>
>>> Well, let's see, I need to do that _inside_ a Java IDE about once every
>>> 5 years. Considering that the operation of executing a shell command and
>>> inserting its output into a file I can do in a Linux/Mac OS X terminal
>>> or a Windows Powershell window, I don't think I'm missing much here.
>> 
>> Which is fine with a few tens of lines or possibly even hundreds of
>> lines. But when you have to do that with thousands of lines, you start to
>> appreciate being able to spit them out straight into an editor buffer.
> 
> And why do I need to have this stuff inside an editor at all?

Because I was creating a text file out of it.

0
Reply Lawrence 3/22/2011 11:07:33 AM

Lawrence D'Oliveiro <ldo@geek-central.gen.new_zealand> wrote:
> In message <Lj_hp.42949$Pg4.7727@newsfe22.iad>, Arved Sandstrom wrote:
>>
>> And why do I need to have this stuff inside an editor at all?
> 
> Because I was creating a text file out of it.
> 

But you can do that just as quickly and easily from the command line,
so where's the huge advantage of doing it from within the editor?

-- 
Leif Roar Moldskred
0
Reply Leif 3/22/2011 11:23:08 AM

Leif Roar Moldskred <leifm@dimnakorr.com> wrote:
> Lawrence D'Oliveiro <ldo@geek-central.gen.new_zealand> wrote:
>> In message <Lj_hp.42949$Pg4.7727@newsfe22.iad>, Arved Sandstrom wrote:
>>> And why do I need to have this stuff inside an editor at all?
>> Because I was creating a text file out of it.
> But you can do that just as quickly and easily from the command line,
> so where's the huge advantage of doing it from within the editor?

There just aren't even nearly enough Ctrl-, Meta- and other key-combos
involved in:    mytool > output.txt   ;-)  (Just kidding.)

I guess he meant including the output of some command into some text
that he is already editing.

-- 
:.!fortune
0
Reply Andreas 3/22/2011 12:06:08 PM

Andreas Leitgeb <avl@gamma.logic.tuwien.ac.at> wrote:
>
> There just aren't even nearly enough Ctrl-, Meta- and other key-combos
> involved in:    mytool > output.txt   ;-)  (Just kidding.)
> 
> I guess he meant including the output of some command into some text
> that he is already editing.

Well, sure. I mean, I use Emacs's shell buffer from time to time for
exactly that sort of thing, but it's just a small convenience. It's not 
significant advantage over doing the redirect on the command line and
then opening the output file in the editor.

Mind, there are a couple of things from Emacs I really _do_ miss when 
working in Eclipse's editor: splitting the editor window into multiple 
panes easily and conveniently, having different panes refer to the 
different positions in the same file, and Emac's way of doing cutting
and pasting (the kill ring).

In the end, though, the benefits of using the editor I prefer just 
doesn't outweith the benefits of using the same development tools as
the rest of the developers on the project.

-- 
Leif Roar Moldskred 
0
Reply Leif 3/22/2011 12:49:43 PM

Leif Roar Moldskred <leifm@dimnakorr.com> writes:

> Mind, there are a couple of things from Emacs I really _do_ miss when 
> working in Eclipse's editor: splitting the editor window into multiple 
> panes easily and conveniently, having different panes refer to the 
> different positions in the same file, and Emac's way of doing cutting
> and pasting (the kill ring).

I'm foremost an emacs user but I thought that the Emacs+ plugin to
eclipse handled splitting along with all the nice emacs editing
keybindings. I only recently looked into it as I was contemplating
having to program in Java.

For me though, the principal attraction of Emacs will forever be elisp
and the speed with which you can accomodate new editing needs.

In conclusion I think they both have significant strength and luckily
nobody has to chose one over the other.

/Peter
0
Reply peter 3/22/2011 1:00:35 PM

On 22/03/2011 04:59, Lawrence D'Oliveiro allegedly wrote:
> While my fingers are typing trees, my brain is seeing forest.

Yeah, that's definitely the impression I get from you: disjunct.

0
Reply Daniele 3/22/2011 6:01:33 PM

In message <O-6dnc4Iv5ABGxXQnZ2dnUVZ8783t52d@telenor.com>, Leif Roar 
Moldskred wrote:

> Lawrence D'Oliveiro <ldo@geek-central.gen.new_zealand> wrote:
>
>> In message <Lj_hp.42949$Pg4.7727@newsfe22.iad>, Arved Sandstrom wrote:
>>>
>>> And why do I need to have this stuff inside an editor at all?
>> 
>> Because I was creating a text file out of it.
> 
> But you can do that just as quickly and easily from the command line ...

Not really, no.
0
Reply Lawrence 3/23/2011 5:44:59 AM

In message <MPG.27f1c068b25fdf3f989697@news.justthe.net>, Steve Sobol wrote:

> In article <im9687$qq$3@lust.ihug.co.nz>, Lawrence D'Oliveiro says...
>> 
>> In message <8up2qeF4reU1@mid.individual.net>, Nigel Wade wrote:
>> 
>> > On 20/03/11 20:04, Lawrence D'Oliveiro wrote:
>> >
>> > You need to spend time learning how to use an IDE.
>> 
>> Spoken like a true non-Emacs user.
> 
> Emacs is my preferred text editor, but I generally don't use it for
> programming purposes, except for quick-and-dirty changes. I normally use
> Eclipse. Or, for Microsoftish stuff, I'll use Visual Studio.

Why? Are the GUI environments slow to start?
0
Reply Lawrence 3/23/2011 5:46:22 AM

In article <imc1fe$lef$3@lust.ihug.co.nz>, Lawrence D'Oliveiro says...

> > Emacs is my preferred text editor, but I generally don't use it for
> > programming purposes, except for quick-and-dirty changes. I normally use
> > Eclipse. Or, for Microsoftish stuff, I'll use Visual Studio.
> 
> Why? Are the GUI environments slow to start?

No, I just typically use Emacs on my older Linux server that doesn't 
have a ton of horsepower. Because it doesn't have a ton of horsepower, I 
don't typically run a lot of stuff under the GUI.


-- 
Steve Sobol - Programming/WebDev/IT Support
sjsobol@JustThe.net
0
Reply Steve 3/23/2011 5:56:26 AM

Lawrence D'Oliveiro <ldo@geek-central.gen.new_zealand> wrote:
> In message <O-6dnc4Iv5ABGxXQnZ2dnUVZ8783t52d@telenor.com>, Leif Roar 
>> 
>> But you can do that just as quickly and easily from the command line ...
> 
> Not really, no.

What's so tricky about appending "&> out.txt" to your command line?

-- 
Leif Roar Moldskred

0
Reply Leif 3/23/2011 6:18:03 AM

On 11-03-23 02:44 AM, Lawrence D'Oliveiro wrote:
> In message <O-6dnc4Iv5ABGxXQnZ2dnUVZ8783t52d@telenor.com>, Leif Roar 
> Moldskred wrote:
> 
>> Lawrence D'Oliveiro <ldo@geek-central.gen.new_zealand> wrote:
>>
>>> In message <Lj_hp.42949$Pg4.7727@newsfe22.iad>, Arved Sandstrom wrote:
>>>>
>>>> And why do I need to have this stuff inside an editor at all?
>>>
>>> Because I was creating a text file out of it.
>>
>> But you can do that just as quickly and easily from the command line ...
> 
> Not really, no.

Dude, this sub-thread originally stemmed from you touting

"Being able to execute a shell command and insert its output directly
 into a text buffer."

as a benefit of Emacs. We're also informed, by you, that the purpose of
so doing is

"Because I was creating a text file out of it."

You're now, for the record, claiming that it's faster to run shell
commands in Emacs to create a text file, than it is to run shell
commands on the *command line* to create a text file. It's also
apparently more difficult, according to you, to run these shell commands
on the command line than it is in Emacs.

Why not just come straight out and admit that you'd rather pound nails
into your forehead than use a prole tool like an IDE? It's OK, we all
have our snob moments.

AHS
-- 
That's not the recollection that I recall...All this information is
certainly in the hands of the auditor and we certainly await his report
to indicate what he deems has occurred.
-- Halifax, Nova Scotia mayor Peter Kelly, who is currently deeply in
the shit
0
Reply Arved 3/23/2011 8:49:10 AM

On 22/03/11 03:49, Lawrence D'Oliveiro wrote:
> In message <8up2qeF4reU1@mid.individual.net>, Nigel Wade wrote:
> 
>> On 20/03/11 20:04, Lawrence D'Oliveiro wrote:
>>
>> You need to spend time learning how to use an IDE.
> 
> Spoken like a true non-Emacs user.
> 

Certainly not any more. I progressed beyond it 15 years ago. But, hey,
you stick with the tools you are capable of using.

>>> Having multiple clipboards with CTRL/X r s 1, CTRL/X r s 2 etc.
>>
>> is a messy hack.
> 
> Yup, definitely knows little or nothing about Emacs.

I worked with Emacs for long enough to know all it's shortcomings.
Sufficiently so that I was glad to see the back of it when windowed
systems relegated it to the realms of obscurity it so deserved. There is
nothing about Emacs that I miss, and just about everything that I'm glad
to see the back of.

> 
>>> Being able to execute a shell command and insert its output directly into
>>> a text buffer.
>>
>> is of very little advantage in windowed systems.
> 
> Au contraire, as I have explained elsewhere.
> 

Actually, you have explained nothing. Merely stated your (as yet
unsubstantiated) opinion. Your continued refusal to back up your stated
opinion with fact is beginning to make it look baseless.

-- 
Nigel Wade

0
Reply Nigel 3/23/2011 9:59:35 AM

2011-03-23 10:59, Nigel Wade wrote:
> 
> I worked with Emacs for long enough to know all it's shortcomings.
> Sufficiently so that I was glad to see the back of it when windowed
> systems relegated it to the realms of obscurity it so deserved. There is
> nothing about Emacs that I miss, and just about everything that I'm glad
> to see the back of.

Emacs *is* a windowed system. You can use mouse commands. It can be used
without windows, though, if you don't have X or GTK. Apparently it was
too advanced for you.
0
Reply Lars 3/23/2011 11:35:25 AM

Lars Enderin <lars.enderin@telia.com> wrote:
> 2011-03-23 10:59, Nigel Wade wrote:
>> I worked with Emacs for long enough to know all it's shortcomings.
>> Sufficiently so that I was glad to see the back of it when windowed
>> systems relegated it to the realms of obscurity it so deserved. There is
>> nothing about Emacs that I miss, and just about everything that I'm glad
>> to see the back of.
> Emacs *is* a windowed system. You can use mouse commands. It can be used
> without windows, though, if you don't have X or GTK. Apparently it was
> too advanced for you.

We all know, emacs is a fully-fledged OS on its own. The only thing it
lacks, though, is a decent editor...  ;-)

0
Reply Andreas 3/23/2011 1:04:01 PM

Andreas Leitgeb <avl@gamma.logic.tuwien.ac.at> wrote:

> We all know, emacs is a fully-fledged OS on its own. The only thing it
> lacks, though, is a decent editor...  ;-)

Not so! It has a vi mode.

(Seriously. It does.)

-- 
Leif Roar Moldskred
0
Reply Leif 3/23/2011 1:15:01 PM

Leif Roar Moldskred <leifm@dimnakorr.com> wrote:
> Andreas Leitgeb <avl@gamma.logic.tuwien.ac.at> wrote:
>> We all know, emacs is a fully-fledged OS on its own. The only thing it
>> lacks, though, is a decent editor...  ;-)
> Not so! It has a vi mode.
> (Seriously. It does.)

Is it a bare-bones vi mode, or rather something like a vim mode?

Unlike modern versions of "vim", the classic "vi" doesn't really qualify
for "decent", either, anymore. At least not for my own definition of decent.

0
Reply Andreas 3/23/2011 1:30:22 PM

Andreas Leitgeb <avl@gamma.logic.tuwien.ac.at> wrote:
> 
> Is it a bare-bones vi mode, or rather something like a vim mode?

I don't know, I'm afraid. I've never used vi(m) much. 

(The emacs mode mentioned is 
http://www.informatik.uni-hamburg.de/RZ/software/emacs/vip/vip_toc.html ,
but I don't know if that answers your question.)

-- 
Leif Roar Moldskred
0
Reply Leif 3/23/2011 2:44:34 PM

In message <Rcednf1LqZkGDRTQnZ2dnUVZ8783t52d@telenor.com>, Leif Roar 
Moldskred wrote:

> Lawrence D'Oliveiro <ldo@geek-central.gen.new_zealand> wrote:
>
>> In message <O-6dnc4Iv5ABGxXQnZ2dnUVZ8783t52d@telenor.com>, Leif Roar
>>> 
>>> But you can do that just as quickly and easily from the command line ...
>> 
>> Not really, no.
> 
> What's so tricky about appending "&> out.txt" to your command line?

I want to edit the text. That’s what a text editor does.
0
Reply Lawrence 3/23/2011 11:51:31 PM

On Mon, 21 Mar 2011 19:03:29 -0400, Lew <noone@lewscanon.com> wrote,
quoted or indirectly quoted someone who said :

>> Emacs and CUA user interfaces.
>
>And that's different from an IDE how?

I have not used Emacs for many years. but back in the day, even the
way you selected text with the mouse was different. Ctrl-C Ctrl-V
worked a quite different way with different keystrokes.  These are
things I don't want to think about. I want them as finger reflexes.
Flipping back and forth between the CUA interface and the Emacs
interface requires conscious thought for every tiny operation.  It
drove me mad.  I figured the only way out would be to forswear ever
using Windows again in return for having a LISP amanunesis at my
shoulder.  Since my customers used Windows I could not consider doing
that.

Perhaps now it has a more native windows-like interface.
-- 
Roedy Green Canadian Mind Products
http://mindprod.com
If you think it’s expensive to hire a professional to do the job, wait until you hire an amateur.
~ Red Adair

0
Reply Roedy 3/24/2011 1:46:30 AM

Roedy Green <see_website@mindprod.com.invalid> writes:

> Perhaps now it has a more native windows-like interface.

I don't know about the Windows version, but Aquamacs - a native GUI
version of Emacs for Mac OS X - certainly does use all of the expected
keystrokes. Cmd-C & Cmd-V for copy & paste, Cmd-Q to exit, etc.

Now, if only I could break my habit of typing ctrl-c ctrl-c to send an
email message in gmail... :-)

sherm--

-- 
Sherm Pendley
                                   <http://camelbones.sourceforge.net>
Cocoa Developer
0
Reply Sherm 3/24/2011 2:28:36 AM

Sherm Pendley <sherm.pendley@gmail.com> wrote:
> Now, if only I could break my habit of typing ctrl-c ctrl-c to send an
> email message in gmail... :-)

There exists an extension for firefox, that adds a small extra button
to each textfield, allowing you to open the contents of the textfield 
as a temp-file in any (configurable) editor, and if firefox notices
changes in that temp-file (due to saving in the editor), it will load
them back into the textfield. (It does not care if the editor itself
still runs or not, so even if the editor forks itself into background
on start, that doesn't matter)

Maybe that would be the key to allow you to use even emacs with gmail 
(if you actually use the web-interface to it).

0
Reply Andreas 3/24/2011 5:07:08 PM

Leif Roar Moldskred <leifm@dimnakorr.com> wrote:
> Andreas Leitgeb <avl@gamma.logic.tuwien.ac.at> wrote:
>> Is it a bare-bones vi mode, or rather something like a vim mode?
> I don't know, I'm afraid. I've never used vi(m) much. 
> (The emacs mode mentioned is 
> http://www.informatik.uni-hamburg.de/RZ/software/emacs/vip/vip_toc.html ,
> but I don't know if that answers your question.)

Yes, it does.  It seems to be indeed more decent than classical "vi".

So, it seems that the lack of a decent editor in emacs is no longer
(since about 2002, the date of the linked document) accurate.

0
Reply Andreas 3/24/2011 5:25:50 PM
comp.lang.java.programmer 51861 articles. 38 followers. Post

80 Replies
343 Views

Similar Articles

[PageSpeed] 32


  • Permalink
  • submit to reddit
  • Email
  • Follow


Reply:

Similar Artilces:

Survey: What IDEs do people use?
Hi All, I hope this is not too far off topic here, but I can't think off any place where it would be exactly on topic. I'd like to get some sense of how widely used certain IDEs are. I'm particularly interested to know how widely used are Borland C++BuilderX (on various operating systems) and Bloodshed Dev-CPP. I'd also like to know what C++ IDE people think is best for Linux. Obviously this is not a scientific survey -- I don't have the time or funding for that. But I'd like to get some rough idea of people's opinions. Your help would be greatly appreciated. J...

|Survey| Define your ideal IDE
While lurking at Delphi, I thought of coming up with better IDE for PHP. So, define your ideal IDE. Just explain the killing features you want or expecting instead of mentioning other available IDEs. Thanks. -- <?php echo 'Just another PHP saint'; ?> Email: rrjanbiah-at-Y!com Blog: http://rajeshanbiah.blogspot.com/ ...

Survey on refactoring activities using IDEs
Dear visitors of comp.lang.java.programmer, the Institute of Computer Science of the "Freie Universitaet Berlin" is currently investigating the question "Did the availability of refactoring functionality of IDEs result in refactorings being performed more frequently?" We would be pleased if you could participate in our survey and fill out (requiring about 15 minutes) the survey form available online at http://www.inf.fu-berlin.de/inst/ag-se/teaching/survey/04-01/survey.php As a prerequisite, only users of the development environments (IDEs) IntelliJ IDEA or Ec...

Survey on refactoring activities using IDEs
Dear visitors of comp.software.extreme-programming, the Institute of Computer Science of the "Freie Universitaet Berlin" is currently investigating the question "Did the availability of refactoring functionality of IDEs result in refactorings being performed more frequently?" We would be pleased if you could participate in our survey and fill out (requiring about 15 minutes) the survey form available online at http://www.inf.fu-berlin.de/inst/ag-se/teaching/survey/04-01/survey.php As a prerequisite, only users of the development environments (IDEs) IntelliJ ID...

Java IDE Market Share Survey
QA Systems has carried out a survey over the last six weeks in which more than 1400 developers, software architects and sofware managers world wide were asked which Java IDE they are currently using. According to the data received Eclipse from Eclipse.org currently has the largest market share with 45%, followed by Borland JBuilder with 16% and IDEA IntelliJ with 10%. For a full list of the results in a bar chart as well as how the survey was carried out see Java IDE Market Share Survey at www.qa-systems.com. -------------------------- QA Systems - The Software Health Company� - is focused...

Survey on refactoring activities using IDEs
Dear visitors of comp.software-eng, the Institute of Computer Science of the "Freie Universitaet Berlin" is currently investigating the question "Did the availability of refactoring functionality of IDEs result in refactorings being performed more frequently?" We would be pleased if you could participate in our survey and fill out (requiring about 15 minutes) the survey form available online at http://www.inf.fu-berlin.de/inst/ag-se/teaching/survey/04-01/survey.php As a prerequisite, only users of the development environments (IDEs) IntelliJ IDEA or Eclipse fo...

Java IDE Market Share Survey
QA Systems has carried out a survey over the last six weeks in which more than 1400 developers, software architects and sofware managers world wide were asked which Java IDE they are currently using. According to the data received Eclipse from Eclipse.org currently has the largest market share with 45%, followed by Borland JBuilder with 16% and IDEA IntelliJ with 10%. For a full list of the results in a bar chart as well as how the survey was carried out see Java IDE Market Share Survey at www.qa-systems.com. -------------------------- QA Systems - The Software Health Company...

Survey on refactoring activities using IDEs
Dear visitors of comp.software.extreme-programming, the Institute of Computer Science of the "Freie Universitaet Berlin" is currently investigating the question "Did the availability of refactoring functionality of IDEs result in refactorings being performed more frequently?" We would be pleased if you could participate in our survey and fill out (requiring about 15 minutes) the survey form available online at http://www.inf.fu-berlin.de/inst/ag-se/teaching/survey/04-01/survey.php As a prerequisite, only users of the development environments (IDEs) IntelliJ ID...

Survey on refactoring activities using IDEs
Dear visitors of comp.lang.java.developer, the Institute of Computer Science of the "Freie Universitaet Berlin" is currently investigating the question "Did the availability of refactoring functionality of IDEs result in refactorings being performed more frequently?" We would be pleased if you could participate in our survey and fill out (requiring about 15 minutes) the survey form available online at http://www.inf.fu-berlin.de/inst/ag-se/teaching/survey/04-01/survey.php As a prerequisite, only users of the development environments (IDEs) IntelliJ...

Java IDE Market Share Survey
QA Systems has carried out a survey over the last six weeks in which more than 1400 developers, software architects and sofware managers world wide were asked which Java IDE they are currently using. According to the data received Eclipse from Eclipse.org currently has the largest market share with 45%, followed by Borland JBuilder with 16% and IDEA IntelliJ with 10%. For a full list of the results in a bar chart as well as how the survey was carried out see Java IDE Market Share Survey at www.qa-systems.com. -------------------------- QA Systems - The Software Health Company...

Java IDE Market Share Survey
QA Systems has carried out a survey over the last six weeks in which more than 1400 developers, software architects and sofware managers world wide were asked which Java IDE they are currently using. According to the data received Eclipse from Eclipse.org currently has the largest market share with 45%, followed by Borland JBuilder with 16% and IDEA IntelliJ with 10%. For a full list of the results in a bar chart as well as how the survey was carried out see Java IDE Market Share Survey at www.qa-systems.com. -------------------------- QA Systems - The Software Health Compa...

Dissertation: survey about java IDE's
Hi all, im a final year computer scientist and part of my dissertation is involved in java based IDE's such as eclipse, if i could ask you for a moment of your time i would really appreciate it if you could fill out a short survey for me, which can be found at the following address: http://v.poile.freeprohost.com there are only a few short questions, so nothing that will take more than a minute Also if you have any comments or something you think would be useful in my dissertation which could contribute to the software i finally develop then please reply to this thread and i will get bac...

Survey on refactoring activities using IDEs #2
Dear visitors of comp.lang.java.softwaretools, the Institute of Computer Science of the "Freie Universitaet Berlin" is currently investigating the question "Did the availability of refactoring functionality of IDEs result in refactorings being performed more frequently?" We would be pleased if you could participate in our survey and fill out (requiring about 15 minutes) the survey form available online at http://www.inf.fu-berlin.de/inst/ag-se/teaching/survey/04-01/survey.php As a prerequisite, only users of the development environments (IDEs) IntelliJ IDEA or...

Survey of NTP surveys
The little I know about NTP surveys, in chronological order: 1989, Mills, http://www.eecis.udel.edu/~mills/database/papers/ccr.ps 1994, James Guyton, I only know of this because it is referenced in Minar below. 1997, Mills, http://www.eecis.udel.edu/~mills/database/papers/survey5.ps 1999, Nelson Minar, http://alumni.media.mit.edu/~nelson/research/ntp-survey99/ 2005, Cristina Duarte Murta and Pedro R. Torres Junior, http://ntpsurvey.arauc.br/ Any other URL's I should know of? Interesting numbers for time evolution of count of stratum-1's: 1994: 66 1997: 220 1999: 957 2005: 533 ...

Paid Surveys - Make Money Online From Free Paid Surveys Paid Surveys
Paid Surveys - Make Money Online From Free Paid Surveys Welcome to Internet Paid Surveys. Here we review the best online paid survey sites that pay you for your opinions. We feature only tried and tested paid survey companies that are really worth joining and have good reputation. Our database is frequently updated and is absolutely FREE. You never have to pay firms like surveyscout to join survey sites. Anyone who asks money in return for a database of paid survey companies are only cheating you. Go through our list of free paid surveys and join them without spending a cent. Paid surveys ar...

Default Survey in AT YOUR SURVEY form
Does anyone know how to setup a defaul survey in form "Survey response Entry" of AT YOUR SURVEY (Duane Hookom). I have tried to put " [cboSrvID].ItemData (0)" on default but it seem doesn't work well. Very big thank!! hanson, your database is different than just about everyone else's databases. Your field names are going to be different than our field names, tables structured differently, etc. If you want help, you're going to have to provide more relevant information about how your database is set up and what exactly you're trying to accomplish. ...

IDE-Streamer and ide-scsi ...
Hi, I have problems reading from my IDE-Streamer (Seagate STT20000A). The device is recognized as /dev/st0. dmesg shows: Attached scsi tape st0 at scsi0, channel 0, id 0, lun 0 st0: try direct i/o: yes (alignment 512 B), max page reachable by HBA 1048575 The device is primary slave (hdb), ide-tape is unloaded and ide-scsi is loaded via /etc/init.d/boot.local (OSS 10.0, Kernel 2.6.13-15). Grub is provided hdb=ide-scsi. Writing on the tape with tar apparently works without problems as the streamer issues typical sounds and the procedure lasts reasonably long. But when displaying, verifying...

mssql ide (front ide)
Is there any front IDE for MS SQL as there is MySQL Front for MySQL. I am looking for it so that it is easy to quickly add/edit/delete the data from the existing table. Please prode the Download URL is there is any. Regards. On 22 Oct 2005 23:15:01 -0700, yehaimanish@gmail.com wrote: >Is there any front IDE for MS SQL as there is MySQL Front for MySQL. I >am looking for it so that it is easy to quickly add/edit/delete the >data from the existing table. Please prode the Download URL is there is >any. > >Regards. Each server doesn't necessarily need a dedicated IDE. A...

Survey
well, are they? ...

IDE
Just read a description of a new IDE (for Java) and find it pretty neat. It's called "Code Bubble", and their new idea is, instead of files, the IDE shows "fragments" instead. http://www.cs.brown.edu/people/acb/codebubbles_site.htm They even have a you-tube thingy to show how it work: http://www.youtube.com/watch?v=PsPX0nElJ0k Wonder if the idea can be useful for the ASM folks? On Wed, 10 Mar 2010 20:21:53 -0800 (PST) Penang <kalambong@nospicedham.gmail.com> wrote: > Just read a description of a new IDE (for Java) and find it pretty > neat. > >...

ide
any one got LDOS 5,xx drivers working for the ide bord ... got 2 mod 3 and wood like to get then working.... can assb then in TRS dos or LDOS.... ...

IDE
Is it a good idea to upgrade to JDK 6 from an older version? Also, what advantages are there in using the free IDE as opposed to a text editor? Thanks for any advice, Gerard [http://homepage.eircom.net/~gerfmcc/audio.html] gerrymcc@indigo.ie wrote: > Is it a good idea to upgrade to JDK 6 from an older version? What older version of Java are you using? IMHO Java 6 executes faster than older versions but for developing you don't need to use the same version the program is executing later (except when compiling with Java 5 or higher, then you can't run it with Java 1.4 or o...

survey
Hello All, Is there any survey on scripting languages? I would like to get information on several scripting languages including Python, Perl, Ruby, Tcl, etc. Thanks Dave __________________________________ Celebrate Yahoo!'s 10th Birthday! Yahoo! Netrospective: 100 Moments of the Web http://birthday.yahoo.com/netrospective/ "Dave Zhu" <zhu_dave@yahoo.com> wrote in message news:mailman.3358.1109974448.22381.python-list@python.org... > Hello All, > > Is there any survey on scripting languages? I would > like to get information on several scripting lan...

Survey
We are doing this survey to collect information on middleware usage and some features of the middleware. Through the survey data as one source of information, we can do research on middleware, and software engineering trend analysis and prediction. Please take out some minutes to fill in this survey. Please this is really important survey. Suvey link: http://swtech.njit.edu/middlewaresurvey/ Give little time to make this survey successful. Thank you all ...