Projet de Java Avancé INFO2 2020

Le but du projet SupaOptimizer est d'écrire un super optimizateur de code. Un super optimizateur de code est un programme qui prend un programme en paramètre et essaye de le faire aller plus vite même si cela rend l'exécution du programme fausse.
Note: historiquement, dans les années 90, les super optimizateurs étaient en vogue mais le faite que cela puisse changer l'exécution d'un programme veut dire que l'exécution est pas safe.
L'application supa-optimizer est composé

• d'un mode rewrite qui permet de ré-écrire une application en fonction soit d'appel à une API spécifique soit de données recoltées par le mode learn
• d'un mode learn qui permet d'essayer de trouver automatiquement où une application peut être optimisée en collectant des données et vérifiant que les données ne change pas soit pour la durée de vie d'un programme soit entre plusieurs appels au même programme.

• Pour lire et modifier le bytecode, vous utiliserez la librarie ASM.
• Pour collecter les données entre plusieurs exécution, vous utiliserez la base de donnée h2 qui n'est pas une base de données très efficace mais qui à l'avantage d'avoir un moteur d'exécution très petit et d'être écrite en Java, donc facilement déployable.
• Pour voir une ligne d'une table de base de données, vous utiliserez la librarie jdbi.
• Pour modifier le bytecode à l'exécution, vous pourrez utiliser le package java.lang.instrument.
• Vous devez utiliser Maven comme outil de build.
• Vous devez utiliser IntelliJ IDEA comme outil pour écrire et changer votre code.
• Les test unitaires Java doivent être effectués avec JUnit 5, vous pouvez vous référer au guide d'utilisation.
• Le code est hébergé sur gitlab.com.
  Il est vivement encouragé d'utiliser le mécanisme de merge request entre les deux membres d'un binôme pour augmenter la qualité du code.
  Tout commit trop gros (qui introduit plusieurs features d'un coup) sera revert par un des enseignants.

Pour la soutenance, voilà les fichiers de tests que nous allons utiliser.

package fr.umlv.supaoptimizer.api;

public final class SupaOptimizer {
  private SupaOptimizer() {
    throw new AssertionError();
  }

  public static <T> T constant(T value) {
    return value;
  }
  public static boolean constant(boolean value) {
    return value;
  }
  public static byte constant(byte value) {
    return value;
  }
  public static char constant(char value) {
    return value;
  }
  public static short constant(short value) {
    return value;
  }
  public static int constant(int value) {
    return value;
  }
  public static long constant(long value) {
    return value;
  }
  public static float constant(float value) {
    return value;
  }
  public static double constant(double value) {
    return value;
  }

  public static <T< T dispatch(T value) {
    return value;
  }

  @FunctionalInterface
  public interface ValueFactory<T, X extends Throwable> {
    T create() throws X;
  }
  @FunctionalInterface
  public interface ToIntValueFactory<X extends Throwable> {
    int create() throws X;
  }
  @FunctionalInterface
  public interface ToLongValueFactory<X extends Throwable> {
    long create() throws X;
  }
  @FunctionalInterface
  public interface ToDoubleValueFactory<X extends Throwable> {
    double create() throws X;
  }

  public static <T, X extends Throwable> T lazy(ValueFactory<? extends T, ? extends X> factory) throws X {
    return factory.create();
  }
  public static <X extends Throwable> int lazyToInt(ToIntValueFactory<? extends X> factory) throws X {
    return factory.create();
  }
  public static <X extends Throwable> long lazyToLong(ToLongValueFactory<? extends X> factory) throws X {
    return factory.create();
  }
  public static <X extends Throwable> double lazyToDouble(ToDoubleValueFactory<? extends X> factory) throws X {
    return factory.create();
  }
}
  

Calendrier des rendus.
TODO

Pour vous aider, si vous ne respectez pas les indications de "sudden death" suivantes, votre projet sera considéré comme mort et noté 0.
Pour la partie Java, le programme doit être écrit en utilisant correctement les différents concepts vus lors du cours de Java Avancé (sous-typage, polymorphisme, lambdas, classes internes, exceptions, types paramétrés, annotations, collections, entrées/sorties).

• Il ne doit pas y avoir de warnings lorsque l'on charge le code dans Eclipse avec tous les warnings activés !
• Il ne doit pas y avoir de warnings lorsque l'on compile avec javac -Xlint:all.
• Dans un module, les packages d'implantation ne doivent pas être exportés et requires transitive doit être utilisé là où c'est nécessaire.
• Il ne doit pas y avoir de raw types, de @SuppressWarning non justifié, de cast non justifié.
• Le principe d'encapsulation doit être respecté.
• Il ne doit pas y avoir de champs ou méthodes protected.
• Il ne doit pas y avoir d'instanceof/switch/if...else sur des types là où il est possible d'utiliser le polymorphisme.
• Chaque interface devra être nécessaire.
• Aucune classe abstraite ne doit être publique ou utilisée comme un type.
• Chaque méthode devra être appelée (pas de code mort).
• Aucune méthode ne doit faire plus de 10 lignes sans une vraie justification.
• Il est interdit d'utiliser des champs static typés par un objet (pas de variables globales), seules les constantes (static final) de type primitif sont autorisées.