I just put together a list of features I'd like to have in SLIME. I think it's better to post it here than letting it get dusty in my home-dir. Consider it as a base of discussion or a possible roadmap for, say, SLIME 2.0 than as a list of must-haves. It's all in the spirit of making SLIME+Lisp the superior tool to accomplish everything :) Of course, I'm willing to contribute, too.
They are ordered in terms of (by me) estimated efford.
* Nicer Homepage
How about this?: http://www.inf.tu-dresden.de/~s3815210/slime-hp-suggestion/
* Class Browser
Open a window where the class under the point is shown with all its direct superclasses and its direct subclasses or all of both.
- `s' shows/hides the class' direct slots - `m' shows/hides all methods specializing on the class
* Source Outline Mode
Provide an outline mode for lisp source. That is the user can collapse/expand single lisp expressions.
- The keybindings should be the same as in the text outline mode. - What do we show of collapsed expressions? Should a `defun' include the argument list? Should it be specific to the expression being collapsed? Should every expression be collapsible? - A block of comments may be considered a) as a single sexp b) as belonging to the next sexp (if it's on a separate line) or to the provious sexp (if it's on the same line) I favour b) since it would make a full-collapsed file more concise.
* Refactoring Aids
Provide commands for refactoring operations. Examples for useful Lisp-refactorings are: - extract/inline function/method - move slot to super-/subclass - inline temp/replace temp with query - rename function/class/slot/variable/... - ...
- We have to work out which refactorings from [1] are applicable to Lisp (and make sence) and which additional refactorings would be useful for Lisp. - Some refactorings are really hard to implement. Namely all that require a code walker - Note that refactorings are considered save modifications on _working_ code in order to ease implementation of new features. It might still be worth considering how much refactoring is possible without assuming that the code is already compiled and DTRT.
* Program Slicing
Display (only) all the code that can effect a specified object. For example if invoked on a slot name display all expressions that may change this slot's value _and_ show all expressions that effect these former statements.
- How much effort would it take to implement this? - Is it really useful for lisp? (Since lisp does indeed have side-effects, I think it would be of a certain use. So maybe the question should be: How much useful can it be for lisp?) - Can we cover all cases? - What additional information would be needed?
Footnotes: [1] "Refactoring - Improving the Design of Existing Code" by Martin Fowler et. al., Addison Wesley, 2000
Regards,
-ts