Intention Actions Order

When I do a 'Show Intention Actions' on an interface I get the following two:

Convert to Class
Implement Interface

In previous versions the Implement Interface intention was always on top and I have 'Option-Enter Enter' in my fingers when I want to implement an interface.

Is this worth filing a bug report for?

S.

20 comments

It isn't.
Intentions are alphabetically sorted now.

--
regards,
--
Alexey Kudravtsev
Software Developer
JetBrains, Inc, http://www.jetbrains.com
"Develop with pleasure!"

"Stefan Arentz" <no_reply@jetbrains.com> wrote in message
news:23377858.1177177450779.JavaMail.itn@is.intellij.net...

When I do a 'Show Intention Actions' on an interface I get the following
two:

>

Convert to Class
Implement Interface

>

In previous versions the Implement Interface intention was always on top
and I have 'Option-Enter Enter' in my fingers when I want to implement an
interface.

>

Is this worth filing a bug report for?

>

S.



0

Uh, oh. That already annoyed me too.

Why would you want to make the most dedicated Idea users (those that use Idea a lot and got used to keyboard shortcuts) angry?

An order that is determined by logical reasons / most often used features makes much more sense.

Alexey Kudravtsev (JetBrains) wrote:

It isn't.
Intentions are alphabetically sorted now.

0

It isn't.
Intentions are alphabetically sorted now.


Big step backward in useability for me.

S.

0

I wondered why I was suddenly doing the wrong thing on a regular basis. Were they sorted in any way previously? I think moving to a predictable presentation is probably a good thing, even if it means a bit of short term pain. But ideally I'd like the list sorted by frequency of use.

Cheers,
Colin

0

Yes, I'd noticed exactly the same thing myself. I'd agree that sorting by frequency of use sounds like a much better course of action.

0

Simon Knott wrote:

Yes, I'd noticed exactly the same thing myself. I'd agree that sorting by frequency of use sounds like a much better course of action.


Well, sorting by frequency introduces the problem that the order might change more or less
unpredictably until the gathered data has stabilized.

I do agree that a predictable intention order is a good thing, but it has be a useful order too.
Right now, even inspection QuickFixes are sorted to some weird position
(http://www.jetbrains.net/jira/browse/IDEA-11735).

There either needs to be a hard-coded and/or a user-defined system that results in a more
appropriate order, and/or the provided intentions should be reviewed about whether they need to be
an intention at all. "Convert to class" could also live quite well as a rather rarely used
refactoring, while "Implement Interface" seems to be every-day work. Alternatively, allow the user
to really turn off intentions - or make it possible to convert them into "micro-refactorings" in a
"Customizations"-like way.

Please don't fix things that ain't broken - at least not in a way that the result is less usable
than it was before.

Sascha

0

Ah true, I hadn't really thought that idea through :)

I'd agree on the fixing things which aren't broken though. I know that the EAPs are the perfect place to try out new ideas and that change isn't always a bad thing, but in the last few builds there seem to have been lots of little changes under the hood which really impact day-to-day efficiency (undo-granualarity, intention re-ordering, local history not functionally usable). They aren't being mentioned in the change-lists, unless I'm being a bit blind, which makes it harder to give constructive feedback since I'm personally not sure whether they are bugs or a re-working of existing functionality.

0

Not really. Finding an entry in a longer list is easier when the entries are
sorted.

0

1) The list always was sorted - just not alphabetically.
2) It's not really faster, too: If you already scanned the same list fifty times then get a different order (sorted alphabetically) on the 51th time then you will take much longer to find the same item again ... or as happened to me and seemingly others as well you simply select the wrong item and are baffled about the results.
3) After you get used to a certain order, the ease and quickness of selection depends on an average minimum way to travel down the list - so obviously it makes sense to have most common used items first rather then those whose english names start with certain letters. "most common" should of course be decided statically (so that there's a risk of not being absolutely accurate for your specific usage patterns) rather than statistically, so that the order does not change.

0

1) The list always was sorted - just not alphabetically.


How it was sorted? By relevance?

BTW, what about preselecting the most often used entry?

0

Hello Tom,

>> 1) The list always was sorted - just not alphabetically.
>>

How it was sorted? By relevance?


There was never any intentional meaningful sort order. They were sorted by
order of registration in plugin source code, or something like that. In Selena,
the possibility to run multiple inspections in parallel on multicore machines
was added, so the order in which inspections added their quickfixes to the
available quickfix list became random. Alphabetic sorting was added to get
rid of this randomness.

--
Dmitry Jemerov
Software Developer
JetBrains, Inc.
http://www.jetbrains.com/
"Develop with Pleasure!"


0

Hm, ok, if you promise not to change the order again during the next three years, that solution is fine with me. I guess in about four months I will have stopped invoking the wrong options accidentally ;)

I still think an order "by relevance" would be neater, but I guess that's much too much work considering all the plugins, peoples' different wishes concerning the order and the relatively small business value. Probably there are many more important things to do.

0

Well, the things were broken for a while.
When we introduced highlighting multithreading, it meant that quickfixes
started to appear in random order.
So, in the absence of any meaningful way of prioritize intentions, the
alphabetical order seemed the simple solution to keep intentions to pop up
in predictable way.

Are you aware of any other approach to sort the intentions that is simple,
intuitive and stable ?
--
regards,
--
Alexey Kudravtsev
Software Developer
JetBrains, Inc, http://www.jetbrains.com
"Develop with pleasure!"

"Sascha Weinreuter" <sascha.weinreuter@NOSPAM-cit.de> wrote in message
news:f0pq36$dlg$1@is.intellij.net...

Simon Knott wrote:

>> Yes, I'd noticed exactly the same thing myself. I'd agree that sorting
>> by frequency of use sounds like a much better course of action.
>

Well, sorting by frequency introduces the problem that the order might
change more or less
unpredictably until the gathered data has stabilized.

>

I do agree that a predictable intention order is a good thing, but it has
be a useful order too.
Right now, even inspection QuickFixes are sorted to some weird position
(http://www.jetbrains.net/jira/browse/IDEA-11735).

>

There either needs to be a hard-coded and/or a user-defined system that
results in a more
appropriate order, and/or the provided intentions should be reviewed about
whether they need to be
an intention at all. "Convert to class" could also live quite well as a
rather rarely used
refactoring, while "Implement Interface" seems to be every-day work.
Alternatively, allow the user
to really turn off intentions - or make it possible to convert them into
"micro-refactorings" in a
"Customizations"-like way.

>

Please don't fix things that ain't broken - at least not in a way that the
result is less usable
than it was before.

>

Sascha



0

I guess "relevance" is impossible, esp. because of pluggable intentions.
IMHO alphabetic order is the best deterministic approach.

0

Maybe some sort of weighting system, alongside the alphabetical? So
unweighted (or equally weighted) items would be sorted alphabetically,
whereas items with a positive weight would be brought to the top of the
list, and those with a negative weight sent to the bottom?

This would solve the problem I have where there are often some
intentions I never or rarely use, but I have to always go past them to
select the one I want...

N.

Alexey Kudravtsev (JetBrains) wrote:

Well, the things were broken for a while.
When we introduced highlighting multithreading, it meant that quickfixes
started to appear in random order.
So, in the absence of any meaningful way of prioritize intentions, the
alphabetical order seemed the simple solution to keep intentions to pop up
in predictable way.

Are you aware of any other approach to sort the intentions that is simple,
intuitive and stable ?

0

Alexey Kudravtsev (JetBrains) wrote:

Well, the things were broken for a while.
When we introduced highlighting multithreading, it meant that quickfixes
started to appear in random order.


Well, that makes sense, though the ordering itself IMHO didn't exhibit any major flaw: Because the
intentions were ordered as they were registered, it seemed to be a good natural order because "more
relevant" intentions were usually implemented before other, maybe less relevant intentions.

So, in the absence of any meaningful way of prioritize intentions, the
alphabetical order seemed the simple solution to keep intentions to pop up
in predictable way.


Yep, the order absolutely must be predictable. But it would be even better if the habits that
long-term IDEA users developed after 5+ years wouldn't have to be re-learned now ;)

Are you aware of any other approach to sort the intentions that is simple,
intuitive and stable ?


One easy way would certainly be to make the registration order the sort key again. There may also be
other ways to "customize" the intention list. I think this is an important, but missing feature that
allows to "clean up" the intention list based on personal preferences. We can control whether the
light bulb is shown or not for a certain intention, but there's no way to get rid of an intention
when ctrl-enter is pressed.

There could also be a system that allows to assign an additional, custom "priority" to each
intention that a user can tweak. Just some thoughts...

Sascha

0

Alphabetic ordering is good, in that it is predictable, but intentions
and inspection quick fixes should be ordered separately. When an element
is highlighted by an inspection in 9 out of 10 cases I want to invoke
the quick fix. I used to be able to do a quick alt+enter, down, enter.
Now I have to locate the fix first and it is usually located after a few
rarely used intentions.
The solution is to sort inspection quick fixes before intentions
(Sascha's bug report http://www.jetbrains.net/jira/browse/IDEA-11735 ).
Just like currently the compiler quick fixes are sorted before
intentions/inspection quick fixes. That way the alt+enter order is
sorted by priority first (compiler quick fixes, inspection quick fixes,
other intentions) and alphabet second.

Bas

Alexey Kudravtsev (JetBrains) wrote:

Well, the things were broken for a while.
When we introduced highlighting multithreading, it meant that quickfixes
started to appear in random order.
So, in the absence of any meaningful way of prioritize intentions, the
alphabetical order seemed the simple solution to keep intentions to pop up
in predictable way.

Are you aware of any other approach to sort the intentions that is simple,
intuitive and stable ?

0

Are you aware of any other approach to sort the intentions that is simple,
intuitive and stable ?


I think I know solution. Make Intentions Ordering API public and annoyed
people will write a plugin. :)

0

Sounds good. Fixed.

--
regards,
--
Alexey Kudravtsev
Software Developer
JetBrains, Inc, http://www.jetbrains.com
"Develop with pleasure!"

"Bas Leijdekkers" <leijdekkers@SPAMBLOCK.carp-technologies.nl> wrote in
message news:4630A25D.5040809@SPAMBLOCK.carp-technologies.nl...

Alphabetic ordering is good, in that it is predictable, but intentions and
inspection quick fixes should be ordered separately. When an element is
highlighted by an inspection in 9 out of 10 cases I want to invoke the
quick fix. I used to be able to do a quick alt+enter, down, enter. Now I
have to locate the fix first and it is usually located after a few rarely
used intentions.
The solution is to sort inspection quick fixes before intentions (Sascha's
bug report http://www.jetbrains.net/jira/browse/IDEA-11735 ). Just like
currently the compiler quick fixes are sorted before intentions/inspection
quick fixes. That way the alt+enter order is sorted by priority first
(compiler quick fixes, inspection quick fixes, other intentions) and
alphabet second.

>

Bas

>

Alexey Kudravtsev (JetBrains) wrote:

>> Well, the things were broken for a while.
>> When we introduced highlighting multithreading, it meant that quickfixes
>> started to appear in random order.
>> So, in the absence of any meaningful way of prioritize intentions, the
>> alphabetical order seemed the simple solution to keep intentions to pop
>> up in predictable way.
>>
>> Are you aware of any other approach to sort the intentions that is
>> simple, intuitive and stable ?


0

Cool, thanks! I am really looking forward to the next build.

Bas

0

Please sign in to leave a comment.