¿Los métodos predeterminados de Java 8 rompen la compatibilidad de fuentes?

Generalmente ha sido el caso de que el código fuente de Java haya sido compatible con forward. Hasta Java 8, que yo sepa, las clases compiladas y source han sido compatibles con versiones posteriores de JDK/JVM. [Actualización: esto no es correcto, ver comentarios re 'enum', etc, a continuación.] Sin embargo, con la adición de métodos predeterminados en Java 8, esto ya no parece ser el caso.

Por ejemplo, una biblioteca que he estado usando tiene una implementación de java.util.List que incluye un List<V> sort(). Este método devuelve una copia del contenido de la lista ordenada. Esta biblioteca, implementada como una dependencia de archivos jar, funcionó bien en un proyecto que se estaba construyendo utilizando JDK 1.8.

Sin embargo, más tarde tuve ocasión de recompilar la propia biblioteca usando JDK 1.8 y Encontré que la biblioteca ya no compila: la clase List-implementing con su propio método sort() ahora entra en conflicto con el método predeterminado de Java 8 java.util.List.sort(). El método predeterminado Java 8 sort() ordena la lista en su lugar( devuelve void); sort() el método - ya que devuelve una nueva lista ordenada - tiene una firma incompatible.

Así que mi pregunta básica es:

• ¿JDK 1.8 no introduce una incompatibilidad hacia adelante para el código fuente de Java debido a los métodos predeterminados?

También:

• ¿Es este el primer cambio forward incompatible?
• ¿Se consideró o discutió esto cuando se diseñaron e implementaron los métodos por defecto? ¿Está documentado en alguna parte?
• Fue el (ciertamente pequeño) inconvenientes descontados frente a los beneficios?

El siguiente es un ejemplo de un código que compila y se ejecuta bajo 1.7 y se ejecuta bajo 1.8 - pero no compila bajo 1.8:

import java.util.*;

public final class Sort8 {

    public static void main(String[] args) {
        SortableList<String> l = new SortableList<String>(Arrays.asList(args));
        System.out.println("unsorted: "+l);
        SortableList<String> s = l.sort(Collections.reverseOrder());
        System.out.println("sorted  : "+s);
    }

    public static class SortableList<V> extends ArrayList<V> {

        public SortableList() { super(); }
        public SortableList(Collection<? extends V> col) { super(col); }

        public SortableList<V> sort(Comparator<? super V> cmp) {
            SortableList<V> l = new SortableList<V>();
            l.addAll(this);
            Collections.sort(l, cmp);
            return l;
        }

    }

}

Lo siguiente muestra este código siendo compilado (o fallando) y siendo ejecutado.

> c:\tools\jdk1.7.0_10\bin\javac Sort8.java

> c:\tools\jdk1.7.0_10\bin\java Sort8 this is a test
unsorted: [this, is, a, test]
sorted  : [this, test, is, a]

> c:\tools\jdk1.8.0_05\bin\java Sort8 this is a test
unsorted: [this, is, a, test]
sorted  : [this, test, is, a]

> del Sort8*.class

> c:\tools\jdk1.8.0_05\bin\javac Sort8.java
Sort8.java:46: error: sort(Comparator<? super V>) in SortableList cannot implement sort(Comparator<? super E>) in List
                public SortableList<V> sort(Comparator<? super V> cmp) {
                                       ^
  return type SortableList<V> is not compatible with void
  where V,E are type-variables:
    V extends Object declared in class SortableList
    E extends Object declared in interface List
1 error