Re: "Program to an interface" - When to break a design pattern

I've seen this design pattern before

http://witte-consulting.com/documents/design-principles/

and, in general, I see the point of it.

But say we've got something like this

LinkedHashMap<String, Integer> sortedMap = this.getSortedMap();

So you have the method

public LinkedHashMap<String, Integer> getSortedMap() {
   //do stuff
}

(not necessarily public)

Now the design principle says, the method signature should instead be

public Map<String, Integer> getSortedMap() {
   //do stuff
}

The problem is, where I'm creating sortedMap above, I need the map to
retain the insertion order. If what's returned actually is a Map,
rather than a LinkedHashMap, then the results the user actually sees
are going to be in the wrong order. Making things worse, in this case,
nothing would actually break, only the end user would notice anything
was actually wrong.

So in this case, it seems to me, that using LinkedHashMap in the
method signature makes sense. The fact that the return retains the
insertion order is an integral part of what the method does.

If nothing else, it's going to save Fred Developer down the line from
looking at the code around this

Map<String, Integer> sortedMap = this.getSortedMap();

and thinking "wait, how do I know getSortedMap() is going to return a
result with the right ordering?", and having to waste time digging
into that method.