No sé cuánto tiempo se dedica a otros temas, pero teniendo en cuenta que apenas un 2% de las Web usan applets, un mes de tiempo me parece una exageración.
Creo que se continúa con la errónea idea de que Java es "apenas algo más que un plugin de un navegador de Internet", y de ahí el tiempo que se dedica a enseñar los applets.

Sería un completo absurdo que se dedicase menos tiempo, o equivalente incluso, a enseñar las Collections, o Concurrency, por ejemplo.
Mejor no hablemos de Swing, que a pesar de que está en el JDK, apenas si se sabe usar con un mínimo de corrección. ¿Es posible que a estas alturas todavía de inicialicen en los main componentes de Swing fuera del EDT?.

¿Se enseña adecuadamente a conocer y manejar el API de Java?. Porque, por lo que veo, da la impresión de que es un completo desconocido, hasta el punto de que ni se sabe buscar en él lo que se necesita.

¿Se dedica tiempo a analizar e investigar las causas de las exceptions?.

Este foro, como otros, es un buen ejemplo de la razón de las preguntas anteriores.

Es decir, tu ves un código como el que sigue:

private transient List<Path> userPaths;
private transient final ReentrantLock lock = new ReentrantLock();
private transient final Lookup.Result<BrowserUserPathsData> browserUserPathsData = LookupBusServices.getLookupBus().getSubscriber(BrowserUserPathsData.class, new LookupListener() {

@Override
public void resultChanged(final LookupEvent evt) {
final Collection<? extends BrowserUserPathsData> items = browserUserPathsData.allInstances();
if (!items.isEmpty()) {
final List<Path> pathList = items.iterator().next().getPathList();
if (pathList != null) {
lock.lock();
try {
if (userPaths == null) {
userPaths = new ArrayList<>(pathList);
doUpdate();
} else {
pathList.removeAll(userPaths);
// in case no new paths added...
if (!pathList.isEmpty()) {
userPaths.addAll(pathList);
// all descendant paths from a given path get removed
final List<Path> toRemove = new ArrayList<>(2 * userPaths.size());
for (Iterator<Path> its = userPaths.iterator(); its.hasNext();) {
final Path source = its.next();
for (Iterator<Path> itt = userPaths.iterator(); itt.hasNext();) {
final Path target = itt.next();
if (!target.equals(source) && target.startsWith(source)) {
toRemove.add(target);
}
}
}
if (!toRemove.isEmpty()) {
userPaths.removeAll(toRemove);
}
doUpdate();
}
}
} finally {
lock.unlock();
}
}
}
}
});


aparte de que no tienes por qué conocer lo relativo a Lookup (que es específico de NetBeans Platform), ¿Qué impresión te causa todo lo demás?.

La idea de poner ese código no era que entendieses exactamente qué hace y por qué lo hace. Para ello tendrías que conocer las especificaciones, y las razones lógicas por las que se construye así; lo que no es el caso.

Ésto es lo que me preocupa:

"eso es lo que entiendo desde mi ignorancia pero vamos que no nos han enseñado nada de eso"

Para no haberte enseñado nada de eso, creo que lo comprendes mejor que bien ;)
Lo grave es que se dedique un mes a applets, y termines el curso sin reconocer las Collections donde las ves, y lo que se supone que deben hacer, por lo que te hayan enseñado de ellas, y no teniendo que hacer deducciones lógicas a partir de los identificadores.

Como no habéis visto nada de concurrencia, es natural que un ReentrantLock te suene a chino, como poco ;)

Creo que te refieres a estas líneas con tu comentario posterior:
if (!toRemove.isEmpty()) {
userPaths.removeAll(toRemove);

Lo que hace es eliminar de userPaths todo el contenido de toRemove, en caso de que toRemove no esté vacío.