Suggestions

Hi people,
First of all, I would like to praise OA for a wonderful product.

Here are some suggestions for improving Dolphin, according to my
opinion (may be some were already suggested, sorry about that):

* Implement It in the Debugger
If the object being passed as a parameter is nil AND it is a literal,
the argument name could be taken from it

* A simpler but still useful form of code completion could be achieved
for object identifiers (not for messages).  You know identifiers
begining with lower case it could only be (although I could be missing
some): pseudo-variables (nil, true, false, etc.), iv, temp, args.  For
upper case (Class vars, Pools, Globals of all kinds).  For selectors,
Squeak proposes any selector that begins with the typed letters.  I
believe one can also use regular expressiones.  Of course a type
inferencer would certainly narrow the choices

* About coding in the debugger, please take a look at:
http://www.esug.org/summerschools/2001_Essen/presentations/EnsuDemo/index.html

* Reload Package

* In the Class Browser Copy/Paste Class  (or create Class based
on:...)  I know this has already been discussed, but I still believe
it is useful.  For example, right now I am using the Visitor Pattern
and need to create a subclass of an abstract one will almost all the
same methods (same selectors and arguments) and fill them with a
slightly different body.  Yeah, probably with some more deep thinking,
I might come with a better way to factor out commonalities and have a
pluggable visitor.  But right now I don't have the time or enough
context to succesfully do that, I am kind of hacking by now.

* Case sensitivity option in Method | Browse | Containing text...  
Also a history list of previous searches will be more than welcome

* There is a feature in Delphi which I like to be incorporated.
Imagine you are in the visual composer and want to select a component.
 Now in Dolphi, you can select a component inside another by a series
of clicks in place.  What I sometimes need is just the opposite.  In
Delphi, you can select a succesively, the cointainer of current
component by pressing Esc.  O a related note, in Self or other
Morphic-like environments, you can pop-up a list of all containers of
a certain component.

* Multi-selection on the method list of a Browser would be very
helpful.  I think there is a third party library that has it (don't
remember which one right now), but I feel this feature belongs to the
plain base image

* A simple way to "see" all workspace bindings.  If there is one, I
didn't find it

* The debug it option has sometimes the u and some other the g as the
shortcut.  Also, though in some places F11 works fine, in other it
does not (sorry, don't remember which ones right now)

* A "combo" similar to ifNil:ifNotNil: but for collections:  
ifEmpty:ifNotEmpty:

Well, that is all I can remember right now.

Best regards,
Daniel Rozzeta

"Daniel Rozzeta" <[hidden email]> wrote in message
news:[hidden email]...
> * A simpler but still useful form of code completion could be achieved
> for object identifiers (not for messages).  You know identifiers
> begining with lower case it could only be (although I could be missing
> some): pseudo-variables (nil, true, false, etc.), iv, temp, args.  For
> upper case (Class vars, Pools, Globals of all kinds).  For selectors,
> Squeak proposes any selector that begins with the typed letters.  I
> believe one can also use regular expressiones.  Of course a type
> inferencer would certainly narrow the choices
...

I have a goodie that provides some of what you want.  Take a look here
http://www.mitchellscientific.com/smalltalk/ it is called CJDLookup.  I have
been using an improved version in my image that will display a list of all
methods in the system if it can not determine the receiver type.

> * Multi-selection on the method list of a Browser would be very
> helpful.  I think there is a third party library that has it (don't
> remember which one right now), but I feel this feature belongs to the
> plain base image
...
I believe Tools+ is what you are referring to:
http://www.solutionsoft.co.uk/toolsplus/

Chris

"Daniel Rozzeta" <[hidden email]> wrote in message
news:[hidden email]...

> * In the Class Browser Copy/Paste Class  (or create Class based
> on:...)  I know this has already been discussed, but I still believe
> it is useful.

I've felt the need for this as well, though I haven't looked at the prior
discussions.

> * Case sensitivity option in Method | Browse | Containing text...

Also filters.

> Also a history list of previous searches will be more than welcome

Practically every place where you type something in should remember at least
the last thing you typed, and even better is a history.

> * The debug it option has sometimes the u and some other the g as the
> shortcut.  Also, though in some places F11 works fine, in other it
> does not (sorry, don't remember which ones right now)

If you're in the debugger and you want to debug-it, you have to select the
code then choose from the menu--F11 doesn't work.

Daniel

You wrote in message news:[hidden email]...
> Hi people,
> First of all, I would like to praise OA for a wonderful product.
>
> Here are some suggestions for improving Dolphin, according to my
> opinion (may be some were already suggested, sorry about that):

Thanks for your kind comments, and for your feedback.

>
> * Implement It in the Debugger
> If the object being passed as a parameter is nil AND it is a literal,
> the argument name could be taken from it

Can you explain further? I don't understand how the argument can be both nil
and a "literal".

Currently the debugger bases the argument names on the type of the argument.
Often this works well, and the results fit the normal Smalltalk convention.
Sometimes the result is too specific, for example one might want 'anInteger'
instead of 'aSmallInteger'. Its possible we will put a mechanism in place to
improve on this in the next version, but its a low priority at present.

> * A simpler but still useful form of code completion could be achieved
> for object identifiers (not for messages).  You know identifiers
> begining with lower case it could only be (although I could be missing
> some): pseudo-variables (nil, true, false, etc.), iv, temp, args.  For
> upper case (Class vars, Pools, Globals of all kinds).  For selectors,
> Squeak proposes any selector that begins with the typed letters.  I
> believe one can also use regular expressiones.  Of course a type
> inferencer would certainly narrow the choices

It is likely we will have some form of code completion in D6. In the
meantime Chris Demers has a useful add-on for D5 as described in his
posting.

>
> * About coding in the debugger, please take a look at:
>
http://www.esug.org/summerschools/2001_Essen/presentations/EnsuDemo/index.ht
ml

When I get the time....

>
> * Reload Package

A much requested feature, which I have at long last recorded in our change
tracking system as #1233.

There are a number of easy ways to achieve what you want in very few steps
without adding a feature that will encourage cut & paste coding. First
create the new class. You can then either drag across the methods you want
to copy individually, or en-masse by dragging a category out of the category
tree. If you have a particular category containing all the appropriate
methods then use that, otherwise just drag over the 'All' category and
delete what you don't need. Note that copying a class can essentially be
achieved by the two steps of creating the new class and then dragging over
the 'All' methods category, and you might need a third step to drag over the
class methods. However...

For the visitor pattern I would recommend defining a method protocol
containing all the selectors. To do this open a browser on a class which
implements the required methods, and switch to the method protocols pane.
Now add a new protocol, giving it an appropriate name. Drag all the desired
methods into it. Now with a browser open on the new class which is to
implement the protocol, you can just switch to the method protocols pane and
again 'Add' the protocol you just defined. This will add stub methods. The
particular advantage of using a protocol is that if you later decide to add
a new method to the protocol (perhaps you add a new type of object to be
visited), then if you add that method to the protocol all the other
implementors of the protocol will automatically have stub methods compiled
into them, the body of which raises an error to the effect that they need to
be implemented. This will (of course :-)) fire when you run your tests.

>
> * Case sensitivity option in Method | Browse | Containing text...

#1234

> Also a history list of previous searches will be more than welcome

This has come up before as a request to add a generic capability to the
Prompter to support a drop-down list of previous entries (#1167), but
obviously this could be put to use in many places in the IDE (#1235).

>
> * There is a feature in Delphi which I like to be incorporated.
> Imagine you are in the visual composer and want to select a component.
>  Now in Dolphi, you can select a component inside another by a series
> of clicks in place.  What I sometimes need is just the opposite.  In
> Delphi, you can select a succesively, the cointainer of current
> component by pressing Esc.  O a related note, in Self or other
> Morphic-like environments, you can pop-up a list of all containers of
> a certain component.

#1236.

>
> * Multi-selection on the method list of a Browser would be very
> helpful.  I think there is a third party library that has it (don't
> remember which one right now), but I feel this feature belongs to the
> plain base image

This has been suggested before a number of times, and it would be useful for
dragging methods around, repackaging a number of methods in one step, ditto
deleting, etc, so recorded as #1237.

>
> * A simple way to "see" all workspace bindings.  If there is one, I
> didn't find it

Do you mean variable bindings? If so the Workspace/Variables command is what
you want.
Do you mean keyboard bindings? If so 'Help/Key Bindings'.
>
> * The debug it option has sometimes the u and some other the g as the
> shortcut.  Also, though in some places F11 works fine, in other it
> does not (sorry, don't remember which ones right now)

Inconsistent keyboard menu shortcuts recorded as #1239.

The F11 is not available for 'Debug It' in the Debugger because it is used
for 'Step Into' (which if you think about it is what 'Debug It' does to the
selected expression).

>
> * A "combo" similar to ifNil:ifNotNil: but for collections:
> ifEmpty:ifNotEmpty:

Personally I think you should add your own loose method for that, the
collection protocol being fat enough as it is.

>
> Well, that is all I can remember right now.

Thanks again

Regards

Blair

> > * Implement It in the Debugger
> > If the object being passed as a parameter is nil AND it is a literal,
> > the argument name could be taken from it
>
> Can you explain further? I don't understand how the argument can be both nil
> and a "literal".

OK.  Everything one writes is perfectly clear until someone else reads
it ;o)

Suppose you evaluate this code:

anA := A new.
aB := nil.
anA nonexistentMethod: aB.

A debugger will pop up.  If you choose implement in the debugger, it
will generate

nonexistentMethod: anUndefinedObject

However, sin the source code of the message send reads:
nonexistentMethod: aB
With a little more effort you can instead generate:
nonexistentMethod: aB

I don't know the specifics of Compiled Code format nor if the source
code literals are easily accesible.  But since the debugger can show
it, I guessed it can be obtained.
Anyway, it is not such a big improvement nor I have any accute need.
It is just a suggestion.


> Do you mean variable bindings? If so the Workspace/Variables command is what
> you want.

Yes.  It was OBVIOUS.  Sorry for having "opened my mouth"


> Personally I think you should add your own loose method for that,

Exactly what I did.  The suggestion just came up by travelling through
loose methods searching for a seemingly helpful comment.


> the collection protocol being fat enough as it is.

You are probably right


Best regards,
Dan