What I want in an editor/IDE

[Chris Cioffi]

I started writing this list because I wanted to have definite points
to base a comparison on and as the starting point of writing something
myself. After looking around, I think it would be a waste of time to
start writing yet another IDE and so am now thinking in terms of new
features/plug-ins for existing systems.

Right now I mostly use Komodo Personal and it's pretty close to being
what I want. They don't currently support plug-ins, but maybe in the
future. I do about 90% of my development on and for Win32. The rest
is for Linux and usually done in vim through an ssh login.

What Komodo has that I really like:
-Projects - This is the difference between an editor and an IDE for
me. The ability to define a set of files as being logically related.
My issue is that Komodo doesn't go nearly far enough. What I really
want would be an IDE that removed the idea of a 'file' from the
process.

We break up programs into modules/packages for 2 reasons:
1. Too much complexity in a file
2. Re-usability

A decent project management system would allow us to define those
relationships and handle the fussy details in the background.

My response to the 'I want control' argument: I'm most productive
writing code, not doing fiddly file management.

I know this is kind of vague. I'm still working on the details of
exactly what this should be. See the code outliner below.

-Debugger

-Simple (one or two key/click) way to run the program I'm editing

-Syntax completion (Kinda...)

What I am still looking for:
-Post run access to the command interpretor. Basically, after my
program crashes, I'd like to be at a place where I can do a little
digging on variable state, etc. This might just be my need to learn
more about pdb and start using it.

-Built in, syntax aware, spell checker.

-Code/class browser, should be doc string aware

-The ability to import/export all settings from another installation.
I work on 2-3 machines and would like to be able to sit down, point at
a config and use that config. If I point to an Internet based config
it doesn't need to be read/write, just give me "my" options for right
now, thank you very much.

-Sophisticated Python aware syntax highlighting Beyond just "this is
a string". I'd like to have highlighting distinguish between doc
strings, normal strings and triple
quoted strings.

-Better command completion, like what ActiveState PythonWin does. For
instance, while it is frequently no possible to know the class/type

-Ability to work through an SSH shell. I can deal with losing some
debugging capability, although I'd prefer to be able to have the IDE
open it's own remote shell and execute remotely.

-Ability to build extensions in Python would be slick.

-Built-in UML to code outline builder. At least a graphical code
structure designer. (At the object/function/module/package level.)

-GUI designer? With all the GUI tool kits/langauges this might not be
reasonable except as a plug in...

-Support for version control systems. This probably needs to be a
plug in kind of thing so it can support CVS, Subversion, et al.

What features do you think make a great coding system? I'm throwing
this out both for current IDE developers to get ideas from and to see
if I'm the only person not 100% happy with what's currently available.
;->

Chris
--
Still searching for an even prime > 2!

[Jussi Jumppanen]

Chris Cioffi wrote:

I do about 90% of my development on and for Win32. The
rest is for Linux and usually done in vim through an ssh
login.
Take a look at Zeus for Windows:

http://www.zeusedit.com/lookmain.html

Zeus will not run on Linux but it does have ftp editing
with support for SSH and SSL/TLS.
What Komodo has that I really like:
-Projects - This is the difference between an editor and an IDE for
me. The ability to define a set of files as being logically related.
Zeus has projects and workspaces. You can even add your ftp
files to the project.
We break up programs into modules/packages for 2 reasons:
In Zeus this is done using the workspace. The workspace represents
the overall program and then add individual modules and/or packages
are represented by the individual projects added to the workspace.
-Debugger
Zeus will run the external Python debugger internally. The debugger
integration could be better but it does work.
-Simple (one or two key/click) way to run the program I'm
editing
Zeus has tools, macros, project debug and execute options all
fully configurable that allow you to do this.
-Syntax completion (Kinda...)
Zeus does automatic ctags management for all file in a
workspace. It uses the ctags database for code completion
and for tag searching.
-Post run access to the command interpretor.
Zeus does not do this.
-Built in, syntax aware, spell checker.
Zeus only has the spell checker. It leaves the sytax checking
to the author and the compiler/interpreter :)
-Code/class browser, should be doc string aware
Zeus has a project based class browser built from the ctags
database. It is not doc string aware. But it does integrate
with Doxygen, which does implify the project documention
process.
-The ability to import/export all settings from another
installation. I work on 2-3 machines and would like to
be able to sit down, point at a config and use that config.
Just copy over the zConfig directory and you are done.
If I point to an Internet based config it doesn't need to
be read/write, just give me "my" options for right now,
thank you very much.
Zeus has no internet config option, but the zConfig can be
network (ie LAN) based.
-Sophisticated Python aware syntax highlighting Beyond
just "this is string". I'd like to have highlighting
distinguish between doc strings, normal strings and triple
quoted strings.
Zeus comes pre-configured for python and the syntax highlighting
is fully configurable.

But "triple quoted strings" are NOT supported :(
-Better command completion, like what ActiveState PythonWin
does. For instance, while it is frequently no possible to
know the class/type
Zeus only has code-completion for items in the tags database
so it probably does not have this.

But Zeus does have template code completion. This means
things like:

if()<enter key here>

can be configured to complete to this:

if()
{
|< cursor here
}

The templates are fully configurable.
-Ability to work through an SSH shell. I can deal with losing
some debugging capability, although I'd prefer to be able to
have the IDE open it's own remote shell and execute remotely.
Zeus does not do this.
-Ability to build extensions in Python would be slick.
Zeus has a full macro scripting lanaguage. Zeus scripts
can be written in Python, Lua, JavaScript, VBScript, even
RubyScript.
-Built-in UML to code outline builder. At least a graphical code
structure designer. (At the object/function/module/package level.)
Zeus does not have this.
-GUI designer? With all the GUI tool kits/langauges this might
not be reasonable except as a plug in...
Zeus does not have this.
-Support for version control systems. This probably needs to
be a plug in kind of thing so it can support CVS, Subversion,
et al.
Zeus has support for any SCC compliant version control, which
is nealy all of them.

It also comes with "out of the box" support for CVS.
What features do you think make a great coding system?

Just some:

1) Fast start times
2) Fast file load times
3) Fast keyboard response times
4) Configurable keyboard mappings
5) Stable

Jussi Jumppanen
Author of: Zeus for Windows (New version 3.93 out now)
"The C/C++, Cobol, Java, HTML, Python, PHP, Perl programmer's editor"
Home Page: http://www.zeusedit.com

[John Roth]

"Chris Cioffi" <ev********@gmail.com> wrote in message
news:ma*************************************@pytho n.org...

I started writing this list because I wanted to have definite points
to base a comparison on and as the starting point of writing something
myself. After looking around, I think it would be a waste of time to
start writing yet another IDE and so am now thinking in terms of new
features/plug-ins for existing systems.
I tend to think of IDEs along three dimensions:

The first dimension is horizontal. (x)Emacs, vi(m),
JEdit and so forth give you a basic level of support
for a large number of languages. In today's
environment, I expect any serious entry to have
decent syntax highlighting and indentation support
for all supported languages, and also have integrated
support for some repository (CVS at least.)

The second level is vertical. IDEs like Eclipse and
IntelliJ add language specific support for things like
class browsers and refactoring tools, but only for
specific languages (primarilly Java for Eclipse,
I don't know if IntelliJ does that level of support
for multiple languages.)

The third axis is development process support.
This includes things like repository access (CVS,
Subversion, etc.) as well as integration with testing
tools (unittest, PyFIT), build tools, interface builders,
OR mappers and similar tools that are part
of the development process.

In many ways, I'd expect a significant amount of
support for the third category (not just repository
access) in anything I'd call an Integrated Development
Environment (IDE).

As far as the specific feature set is concerned, it
looks like the development community has reached
a fork in the road on debuggers. I'm in the group
that almost never uses a debugger; the presence
of first class debugging support in an editor or
IDE tells me that they probably skimped on
something else that I really am interested in (unless
it's supported by a very large community, which
no Python oriented editors/IDEs are.)
Right now I mostly use Komodo Personal and it's pretty close to being
what I want. They don't currently support plug-ins, but maybe in the
future. I do about 90% of my development on and for Win32. The rest
is for Linux and usually done in vim through an ssh login.

What Komodo has that I really like:
-Projects - This is the difference between an editor and an IDE for
me. The ability to define a set of files as being logically related.
My issue is that Komodo doesn't go nearly far enough. What I really
want would be an IDE that removed the idea of a 'file' from the
process.
I look at projects in a very different way. A project is a group
of files that can be built into a product. Good project support
includes all of the build mechanics required to get from the
source files (in multiple languages and with multiple toolsets)
to the final result. It also includes everything needed to support
the development process by running the *correct* test processes
on those files, the correct documentation processes,
the correct editors on each file type, etc.

If I can't have that, then the next level down is whatever
I've defined as a project on CVS (or whatever.) That's the
absolutely lowest level on which a project is at all meaningful
to me.
-Debugger
See my comments above.

-Simple (one or two key/click) way to run the program I'm editing
For me, this is a simple way of running the unittest and PyFIT
tests I've defined for the story I'm working on.

Running the program by itself wouldn't hurt either, but it's
not on the top of the list.
-Syntax completion (Kinda...)
The level that's in PythonWin gets in the way more than
it helps. See Hans Nowak's comments in his current blog.

http://zephyrfalcon.org/weblog2/arch...0580.html#e585
-Post run access to the command interpretor. Basically, after my
program crashes, I'd like to be at a place where I can do a little
digging on variable state, etc. This might just be my need to learn
more about pdb and start using it.
Don't need it. See my comments on the debugger.
-Built-in syntax aware spell checker.
Nice, but I don't tend to write lots of comments. This
is an XP thing, of course. (note my fix to your grammer
in the line above [grin]. I'm told the book "Eats,
Shoots, and Leaves" is excellent, although I haven't read
it myself.)
-Code/class browser, should be doc string aware

-The ability to import/export all settings from another installation.
I work on 2-3 machines and would like to be able to sit down, point at
a config and use that config. If I point to an Internet based config
it doesn't need to be read/write, just give me "my" options for right
now, thank you very much.

-Sophisticated Python aware syntax highlighting Beyond just "this is
a string". I'd like to have highlighting distinguish between doc
strings, normal strings and triple quoted strings.
I thought I liked PythonWin until I tried JEdit's python mode.
It does a number of things better than PythonWin in this area.
AFAIAC, that's a must have.

To be very blunt about it, anything claiming to be a programming
editor that doesn't have syntax highlighting for every supported language
simply doesn't make the cut in my eyes. That's a base level
facility today.
-Better command completion, like what ActiveState PythonWin does. For
instance, while it is frequently no possible to know the class/type
PythonWin usually gets in the way more than it helps.
-Ability to work through an SSH shell. I can deal with losing some
debugging capability, although I'd prefer to be able to have the IDE
open its own remote shell and execute remotely.
Are you talking about running the editor on a different
machine than the one you're currently on, or running
side processes (like the debugger) on a different
machine than the editor?
-Ability to build extensions in Python would be slick.
Are you asking for C/C++ editor support so you can work
on extensions in the same process, or are you talking about
extensions to the editor?
-Built-in UML to code outline builder. At least a graphical code
structure designer. (At the object/function/module/package level.)
I think this is more of a pipe dream, except in a few relatively
restricted cases. Obviously the current set of tool vendors
flogging these products to the unsuspecting masses don't agree
with me, though.

In any case, this falls under the top level of project support:
if you're generating code for something with a task specific
language, then the IDE needs to support the task specific
language with a suitable editor, support the generation process,
and *not* give update access to the generated code, even if it
looks the same as other code (eg .py files.) See Dave
Thomas' and Andy Hunt's comments on Evil Wizards
in "The Pragmatic Programmer."
-GUI designer? With all the GUI tool kits/langauges this might not be
reasonable except as a plug in...
I'd think that most of what I want almost requires a plug-in
architecture.
-Support for version control systems. This probably needs to be a
plug in kind of thing so it can support CVS, Subversion, et al.
Manditory.

John Roth
What features do you think make a great coding system? I'm throwing
this out both for current IDE developers to get ideas from and to see
if I'm the only person not 100% happy with what's currently available.
;->

Chris
--
Still searching for an even prime > 2!

[G. S. Hayes]

Chris Cioffi <ev********@gmail.com> wrote in message news:<ma*************************************@pyth on.org>...

I do about 90% of my development on and for Win32. The rest
is for Linux and usually done in vim through an ssh login.
You're 10% of the way there. :-)
What Komodo has that I really like:
-Projects - This is the difference between an editor and an IDE for
me. The ability to define a set of files as being logically related.
What exactly does this mean? I ask that as a serious question. When
I edit in vim, files are related in a whole bunch of ways:

* tags; if I call a function/method/class from another file, vim will
automatically jump me to that file when I hit Ctrl-] on the call and
jump me back to where I came from when I hit Ctrl-t (just build a tags
table with "ctags *.py" beforehand).
* Sessions; if you save a session, next time you restore it vim will
open the same files, buffers, etc, loading each file into its own
window, putting the cursor on the same line number in each file,
setting up all your bookmarks and options as they were, etc (use
mksession for this)
* views and folds; you can save and restore multiple views on a file
with mkview. Folds give you another way to navigate around logically
related functions in a file without feeling like you have a huge
monolithic file.
* Directories; the os-level way of defining a set of files as
logically related

and probably others that I can't think of at the moment.

I'm curious as to what moving away from the file concept really buys
you, other than making it harder to use regular tools on your python
files (outside the IDE). To me, a good editor works *with* the file
concept (making it so you don't need to do file management, specify
individual filenames to edit, etc, but at the same time integrating
well with the rest of the OS tools).
-Debugger vimsh + pdb
-Simple (one or two key/click) way to run the program I'm editing
You'll have to define the program name in each session (once), but
after that mapping a key to run it is easy.
-Syntax completion (Kinda...)
Vim will complete on tags (ie class/method/function names),
words/phrases in the current window/buffer/session, user-defined
dictionaries, /usr/dict/words, etc. You can configure which of the
above to use and in what order (or even map multiple keys to different
setups)
-Post run access to the command interpretor. Basically, after my
program crashes, I'd like to be at a place where I can do a little
digging on variable state, etc. This might just be my need to learn
more about pdb and start using it.
vimsh + python -i, or pdb.
-Built in, syntax aware, spell checker.
vim has none built in, but it does syntax highlighting (which will
visually catch some typos) and integrates tightly with external spell
checkers.
-Code/class browser, should be doc string aware
Vim will e.g. open a small preview window with the called method and
docstring displayed in it, among many other things; not sure exactly
what you're looking for.
-The ability to import/export all settings from another installation.
Trivial with vim
-Sophisticated Python aware syntax highlighting Beyond just "this is
a string". I'd like to have highlighting distinguish between doc
strings, normal strings and triple quoted strings.
Vim can distinguish regular strings, triple-quoted strings, and raw
strings (and Unicode strings, etc), but I don't think it
differentiates docstrings.
-Ability to work through an SSH shell
Vim runs in a GUI window or on console, so this is easy. Either X11
tunnelling or fall back to console mode.
-Ability to build extensions in Python would be slick. Vim does.
-Built-in UML to code outline builder. At least a graphical code
structure designer. (At the object/function/module/package level.)
Nope, and I have no experience with alternatives here.
-GUI designer? With all the GUI tool kits/langauges this might not be
reasonable except as a plug in...
I use glade for this.
-Support for version control systems. This probably needs to be a
plug in kind of thing so it can support CVS, Subversion, et al.
There are Vim packages for both of those (among many others)
What features do you think make a great coding system?

#1 It should be a UDE (Unintegrated development environment), so that
you can easily replace pieces (debugger, GUI builder, compiler, etc)
without changing the rest of your toolchain. Ideally it should be
easy to make all the pieces work together transparently but still easy
to replace them with alternatives.