Role-based names vs. Information Repetition about naming-cheatsheet

[kettanaito]

Hey, @xtofl.

This is a great dive into meaningful callback/handler names. We don't currently recommend how you should name your handlers, and the A/HC/LC pattern is still applicable to functions like mark, which stand for a meaningful action passed to wherever you choose.

There's one nuance about naming handlers after their intention as opposed to after their application:

handleClickOutside // application
refetchUsers // intention

When preferring the intention, there's always a danger of that intention migrating away or growing out of proportion in time. Let's take your country's example:

country.on_click(mark)

Initially, mark circles the clicked country on the map. That sounds great. Now, in time, we've also decided it to display some country info next to the circle. So it also displays the info, that's still under the "mark" intention. Well, then, we also wanted to fetch some weather forecast in that country and render it right next to the country name. Now we also do this side-effect... I hope you're getting the point. We (developers) tend to let our intentions grow and change but it's not a general practice to make sure that function names stay aligned with the intention. Partially, because intentions may become complex, and representing them in a function name gets too verbose:

country.on_click(mark_and_show_weather_also_maybe_track_analytics_if_signed_in)

That's my argument for considering application-based names like handleCountryClick. I agree that it doesn't give you the intention from the function name, but it gives you enough contextual information (hey, this is called when I click on a country) to get started. This way we encapsulate the complexity of our intentions within the function itself, and the handler name will remain true as long as it's passed to country.on_click.

I also think that function names alone are insufficient sometimes to describe the intention. Mainly, due to the complexity of those intentions that I've described above. That's why it's generally dangerous to derive intentions from function names alone. I'd rather trust tests, as those can be as verbose as the intention requires.