[GOE] Les changements brusques dans l'environnement de l'entreprise, exemple d'actualité

L'inconvénient principal des deux écoles (classique) et (relation humaine) est l'absence de toute analyse de l'environnement de l'entreprise. L'école classique s'est concentrée sur l'aspect technique et sur la mise en oeuvre et la définition des fonctions de base de l'entreprise. L'école des relations humaines s'est concentrée sur la dimension humaine des employés. Les axiomes et les principes de ces deux écoles ne font aucune référence à l'environnement de l'entreprise.

Cet inconvénient a coûté cher à un grand nombre d'entreprises. En effet, avec l'arrivée de la concurrence et des changements technologiques, économiques et sociaux rapides et brusques, la grande majorité des entreprises n'arrivaient pas à survivre.

L'école managériale, actuellement suivie, qui repose sur une planification du changement et l'utilisation avancée des technologies de l'information et de la communications, a prouvé son efficacité dans des conditions très difficiles et dans des environnements très hostiles.

Le prince Walid ben Talal

Nous prenons à titre d'exemple, un fait très récent qui date le 04 Novembre 2017, le groupe saoudien "kingdom", propriété du prince Walid ben Talal, a connu un choque particulier avec l'arrestation de son propriétaire suite à des accusation de corruption. Et malgré que les investigations n'ont pas donné de résultats et qu'il s'agit au stade actuel des "accusations" et que le principe n'a pas été trouvé "coupable", les rumeurs et les analyses sur le marché ne laisse pas la place à une deuxième possibilité; ce qui représente un changement très brusque et une pression particulière imposée sur le groupe "kingdom".

C'est à ce stade que nous pouvons voir l'utilité d'une vision stratégique d'un côté et d'une séparation entre les deux acteurs : managers et actionnaires. Au cours de la journée du 05 Novembre 2017, les cours du groupe ont connu une chute libre dans la bourse saoudienne au début de la journée. Néanmoins, une amélioration remarquable a pu être constatée au fur et à mesure; cette amélioration ne peut être justifiée que par les efforts des managers encore sur le terrain malgré l'absence de l'actionnaire principal. Nous pouvons supposer avec une grande certitude qu'il s'agissait essentiellement d'un effort fourni pour assurer les autres actionnaires et les autres acteurs que le groupe "kingdom" peut continuer avec les mêmes performances.

La chute des cours du groupe "kingdom" et la récupération au cours de la journée.

Les cours du groupe en connu des pertes d'environ 7%, mais les dégâts pouvaient être plus graves.

[GOE] "Suicide Nets" en Chine : une tentative de limiter les cas du suicides

Les "Suicide Nets" sont très répondus en Chine. Leur objectif principal est de limiter les cas de suicide dans les lieux du travail; une solution pour l'entreprise pour éviter de payer les compensations.
Cette solution est loin d'être une solution correcte pour ne pas dire loin d'être scientifique dans des usines qui fabriquent des appareils à la pointe technologique et pour les grandes firmes comme Apple.

Droits d'auteur résérvés à Reuters et Daily Mail.

Si les journalistes insistent sur le fait que ces tâches sont "répétitives" et "ennuyeuses", c'est qu'ils ne sont pas loin de la vérité; au moins pour la théorie des organisations. Néanmoins, les deux questions qui restent posées sont :

• Pourquoi maintenant ? La génération précédente, les parents de ces employés, a passé par des conditions similaires mais les employés ne présentaient pas la mếme réaction.
• Pourquoi les entreprises technologiques en particulier ? Plusieurs autres mplentreprises traitentleurs employés de la même mannière,mais elles ne présentent âs le même phénomène de suisices.

Le point essentiel ignoré est la qualification des employés. Les tâches répétitives sont le résultat de l'application des principes de spécialisation maximale définis dans le cadre de l'école classique. Dans cette époque (début de 20ème siècle), la non qualification des employés et l'absence totale des outils d'automatisation ont poussé les managers (les ingénieurs) à concevoir des chaînes de production basées sur une spécialisation maxiale et un découpage maximal des processus de production.
Face à l'instabilité d'avant la révolution industrielle, supporter ces conditions de travail était un sacrifice acceptable par cette génération. Garantir un revenu stable était un priorité.
Ces facteurs ont changé pour la deuxième génération qui n'ont pas connu l'instabilité et qui ont bénéficié d'un niveau respectable de formation. Les employés trouvaient plus de difficultés à s'adapter avec les anciens processus de production. Sous la pression, l'employé peut comettre l'action de suicide.

Lectures supplémentaires :
Article de Daily Mail
Article de The Guadrian

[ABD] Sujets et Corrigés

Dans ce dossier, vous pouvez trouver les sujets d'examen et d'interrogation de l'année universitaire 2016/2016. Quelques solutions ne sont pas détaillées et nécessitent des explications; nous en reviendrons plus tard.

Dossier des sujets.

A. U : 2017/2018 :

Corrigés des mico-interros que nous n'avons pas eu la chance de corrigé en salle :

[ABD] Structure primaire du fichier : Hachage avec chaînage externe

Le fichier dans une base des données est vu comme une suite ou un ensemble d'enregistrements. Ces enregistrements sont répartis sur plusieurs blocs. Vu la différence entre la taille de la base des données et le buffer utilisé par le SGBD dans la mémoire centrale pour effectuer les différentes opérations, il est nécessaire de choisir l'organisation la plus adéquate pour limiter le nombre d'accès disque qui sont des milliers de fois moins rapide que les accès à la mémoire centrale.
Cet objectif peut être atteint en utilisant deux approches :

• Par jouer sur l'arrangement des enrtegistrements dans le fichier. En effet, l'approche la plus intuitive est de ranger les enregistrements dans l'ordre de leur arrivée. Cette approche est la moins performante si elle n'est pas associée à une autre approche : la recherche devient très coûteuse parce qu'il faut parcourir tout le fichier à chaque fois. Alors, il faut ranger les enregistrements d'une manière à limiter les accès disque et rendre la recherche plus efficace.
• Par l'ajout d'une structure secondaire. Cette structure n'aura pas comme rôle le stockage des données comme le fichier primaire mais elle facilitera l'accès à ces données. Les index sont un exemple de ces structures.

Dans cet exemple de core, nous visons à simuler l'utilisation du hachage : une méthode qui s'inscrit dans la première appoche. Le hachage range les enregistrements suivant la valeur de l'un de ses champs, appelé clé de hachage. Ainsi, la position du nouvel enregistrement à insérer n'est pas la prochaine position vide, mais, c'est la position donnée par la fonction de hachage sur la valeur de la clé du hachage (généralement la clé primaire) pour le nouvel enregistrement. Par conséquent, les deux opérations d'écriture et de lecture se limitent à un seul accès disque.
Cette approche a deux inconvénients majeurs :

• Il faut avoir, au préalable, une estimation sur les données à sauvegarder. Il est aussi nécessaire de réserver un certain nombre de blocs même si le fichier est vide.
• Les collisions (les conflits) : lorsque deux enregistrements différents auront la même positions (les deux clés de hachage donnent la même valeur), on parle d'une collision (conflit). La résolution des conflit (quelque soit la méthode) peut limiter les performances obtenues par l'utilisation du hachage.

Dans le code du projet, nous allons utiliser le chaînage externe pour résoudre les conflits. Cette solution consiste à créer une liste linéaire chaînée dans cahque position. Cette liste va contenir toutes les valeurs en collision. Pour lire d'avantage sur cette approche, vous pouvez vous référer au cours de M. Zegour par ici.
Le projet est construit sur une seule classe : Page. Cette classe nous permet de stocker des données (des enregistrements) et de faire la recherche (une recherche séquentielle rapide). La Page contient aussi un pointeur vers la Page suivante : cela peut être utilisé pour le chaînage ou bien, tout simplement, ignoré.

public class Page {
    
    /**
     * La taille de la page.
     * Le nombre des enregistrements que la page peut contenir (le facteur de blocage, bfr).
     */
    public static final int TAILLE = 2;
    
    /**
     * Le contenu de la page.
     * Dans cet exemple, le contenu est réduit à une simple valeur (la clé de hachage) mais, en réalité, on parle d'un
     * enregistrement complet.
     */
    public int[] contenu;
    
    /**
     * Le degrée de remplissage de la page.
     * Pour connaître est ce qu'une page est pleine ou pas.
     */
    public int placesOccupees;
    
    /**
     * Un pointeur vers la page suivante.
     * Ce pointeur est nécessaire pour créer des listes linéaires chaînées des pages.
     */
    public Page suivant;

    /**
     * Constructeur par défaut.
     */
    public Page() {
        contenu = new int[TAILLE];
        for (int i = 0; i < contenu.length; i++) {
            contenu[i] = -1;
        }
        placesOccupees = 0;
        suivant = null;
    }

    public int[] getContenu() {
        return contenu;
    }

    public void setContenu(int[] contenu) {
        this.contenu = contenu;
    }

    public int getPlacesOccupees() {
        return placesOccupees;
    }

    public void setPlacesOccupees(int placesOccupees) {
        this.placesOccupees = placesOccupees;
    }

    public Page getSuivant() {
        return suivant;
    }

    public void setSuivant(Page suivant) {
        this.suivant = suivant;
    }

    /**
     * Vérifie si la page contient une valeur ou pas.
     * @param valeur La valeur à rechercher dans la page.
     * @return Vrai si la page contient la valeur, faux autrement.
     */
    public boolean contient(int valeur){
        boolean contient = false;
        int i = 0;
        while(i < TAILLE && !contient){
            if(contenu[i] == valeur)
                contient = true;
            i++;
        }
        return contient;
    }
    
    /**
     * Ajouter une valeur à la page.
     * A la fin  de l'exécution, la page va contenir la valeur (soit elle l'a contenue dès le début ou bien après son ajout).
     * Si la page est pleine, la valeur faux est retournée pour indiquer que l'opération d'ajout à échoué.
     * @param valeur La valeur à ajouter à la page.
     * @return Vrai si l'opération d'ajout a réussi, Faux autrement.
     */
    public boolean ajouterValeur(int valeur){
        boolean reponse = false;
        
        if(contient(valeur))
            reponse = true;
        
        if(!contient(valeur) && placesOccupees < TAILLE){
            contenu[placesOccupees] = valeur;
            placesOccupees++;
            reponse = true;
        }
        
        return reponse;
    }
    
    /**
     * Une représentation du contenu de la page sous forme d'une chaîne de caractère.
     * Seulement le contenu est inclu.<br/>
     * Si la page suivante n'est pas null, elle sera aussi inclue. Le chaînage est représenté par le symbole "==>".
     * @return La chaîne qui représente la page.
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        
        sb.append("Page {\n");
        for (int i = 0; i < contenu.length; i++) {
            sb.append("\t" + contenu[i] + "\n");
        }
        sb.append("}");
        
        if(getSuivant() != null){
            sb.append(" == > " + getSuivant().toString());
        }
        sb.append("\n");
        
        return sb.toString();
    }
        
}

Le projet contient deux gestionnaires :

• Un gestionnaire séquentiel : qui range les enregistrements dans l'ordre de leur arrivée.
• Un gestionnaire qui utilise le hachage par chaînage externe.

Ce dernier voit chaque position comme une liste linéaire chaînée et tente d'ajouter la nouvelle valeur au fichier en commençant par la première page et en passant vers la page suivante en utilisant le pointeur "suivant".
Si on arrive à la fin de la liste (suivant == null) sans pouvoir ajouter l'élément, alors un nouveau noeud est ajouté à la liste et l'élément est ajouté à ce dernier noeud :

    public void ajouterValeur(int valeur) {
        int position = hach(valeur);
        Page page = pages[position];

        while(!page.ajouterValeur(valeur)){
            if(page.getSuivant() == null)
                page.setSuivant(new Page());
            page = page.getSuivant();
        }
    }

Le code source du projet peut être obtenu par ici. Dans ce projet, nous allons créer les deux gestionnaires, faire des insértion et ensuite effectuer des recherches (on recherche les même éléments. On peut voir rapidement que l'approche séquentielle peut atteindre 7 accès disques tant dit que l'appproche par hachage ne dépasse jamais 2 accès disques.
Il est possible d'exécuter directement le fichier jar du projet qui se trouve dans le dossier "dist":

java -jar ABD06.jar 

Si l'affichage est trop vite, il est possible de mettre la sortie du projet dans un fichier texte par la commande suivante.

java -jar ABD06.jar >> test.txt

[ABD] Gestion du buffer : FIFO vs. LRU

Le buffer est un espace mémoire dans la mémoire centrale (généralement, la RAM) qui est utilisé pour stocker temporairement les pages chargées à partir des fichiers qui constituent la base de données. Il est très similaire, dans son principe, au principe de pagination et de la mémoire virtuelle utilisées par les Systèmes d'Exploitation.
Il est utilisé parce que la taille de la base de données dépace largement l'espace disponible dans la mémoire centrale pour effectuer les différents traitements.
Néanmoins, le problème est beaucoup plus simple vu que la pagination concerne seulement des données et non pas un mélange de données et de traitements (les processus) tel qu'il est le cas avec les Systèmes d'Exploiatation. Pour cela, les algorithmes largement utilisés sont seulement deux : FIFO et LRU.
Les deux algorithme visent à choisir la page à remplacer lorsqu'on veut accéder à une nouvelle page et le buffer est plein (ne contient pas d'emplacements vides).
L'algorithme FIFO consiste à remplacer la page la plus ancienne. Il est intuitive et simple : lorsqu'une nouvelle page arrive, on remplace la page qui a passé le plus du temps dans la mémoire. Il est simple à implémenter : il suffit d'utiliser une structure de file simple. Néanmoins, il n'est pas adapté à un contexte de données. En effet, des données telles que les comptes des utilisateurs et leurs privilèges et droits d'accès sont chargées dès le lancement du système et doivent rester toujours disponibles.
L'algorithme LRU est notre deuxième algorithme et l'algorithme le plus utilisé dans le contexte des données. Il se base sur l'affirmation qui dit que : "Si on accède à une donnée à un instant t, il est très probable qu'on aura besoin d'accéder à la même donnée à un moment proche t + dt". Par exemple, il est possible de lire des informations d'un client pour lui vérifier son état financier pour ensuite lui accorder un nouveau crédit et qu'on aura besoin à nouveau de ses informations pour imprimer les états de sortie.
Pour implémenter ces deux algorithmes, plusieurs approches peuvent être suivies. Dans cet article, nous nous intéressons à une approche très simple qui n'utilise pas la structure de file mais sur un simple compteur associé à un tableau d'indices pour pouvoir connaître la page la plus ancienne dans le cas de l'algorithme FIFO ou bien la page la moins récemment utilisée dans le cas de l'algorithme LRU.
Entre les deux approches, quelques lignes de codes changent seulement. En effet, la différence réside dans la mise à jour de l'indice d'une page :

• Dans le cas de l'algorithme FIFO : l'indice prend sa valeur au moment de chargement de la page et ne change pas. Le compteur n'est incrémenté que dans le cas d'un défaut de page. La page avec l'indice le plus petit est la page la plus ancienne.

public void chargerPage(int numero) {

        // Recherche si la page est déjà chargée
        int i = 0;
        boolean trouve = false;
        while (i < pagesOccupees && !trouve) {
            if (pages[i] == numero) {
                trouve = true;
            } else {
                i++;
            }
        }

        if (trouve) {
            // On ne fait rien
        } else {
            
            // Voir est ce qu'il y a des places vides
            if (pagesOccupees < TAILLE_MEMOIRE) {
                
                pages[pagesOccupees] = numero;
                indices[pagesOccupees] = compteur;
                pagesOccupees++;

            } else {
                // Si le buffer est déja rempli

                // Recherche de l'indice minimale
                int valeurMin = indices[0];
                int positionMin = 0;
                for (int j = 0; j < indices.length; j++) {
                    if(indices[j] < valeurMin){
                        positionMin = j;
                        valeurMin = indices[j];
                    }
                }
                
                // On la remplace
                pages[positionMin] = numero;
                indices[positionMin] = compteur;
            }
            
            defautsDePage++;
            compteur++;
        }
}

• Dans le cas de l'algorithme LRU : le compteur doit garder trace de l'utilisation de la page et non pas du moment de son chargement ainsi le compteur est incrémenté à chaque opération d'accès même s'il ne s'agit pas d'un défaut de page et dans ce cas l'indice de la page est mis à jour même si la page est déjà dans le buffer. La page avec l'indice le plus petit est la page la moins récemment utilisée.

public void chargerPage(int numero) {

        // Recherche si la page est déjà chargée
        int i = 0;
        boolean trouve = false;
        while (i < pagesOccupees && !trouve) {
            if (pages[i] == numero) {
                trouve = true;
            } else {
                i++;
            }
        }

        if (trouve) {
            // L'unique différence entre FIFO et LRU
            // L'indice de la page est mis à jour et le compteur est incrémenté même si la page est déjà en mémoire.
            indices[i] = compteur;
            compteur++;
        } else {
            
            // Voir est ce qu'il y a des places vides
            if (pagesOccupees < TAILLE_MEMOIRE) {
                
                pages[pagesOccupees] = numero;
                indices[pagesOccupees] = compteur;
                pagesOccupees++;

            } else {
                // Si le buffer est déja rempli

                // Recherche de l'indice minimale
                int valeurMin = indices[0];
                int positionMin = 0;
                for (int j = 0; j < indices.length; j++) {
                    if(indices[j] < valeurMin){
                        positionMin = j;
                        valeurMin = indices[j];
                    }
                }
                
                // On la remplace
                pages[positionMin] = numero;
                indices[positionMin] = compteur;
            }
            
            defautsDePage++;
            compteur++;
        }
}

Le code complet peut être téléchargé par ici
Le dossier contient un projet NetBeans ouvrable, sinon, vous avez toujours la possibilité de construire un nouveau projet dans les autres éditeurs en utilisant le dossier "src".
Il est possible d'exécuter le jar directement, sans recompilation, il suffit d'utiliser la commande :

java -jar ABD05.jar 

Si vous pensez que l'affichage est un peu rapide, vous pouvez mettre la sortie dans un fichier texte si vous exécutez la commande suivante :

java -jar ABD05.jar >> test.txt

Le dossier ./dist/javadoc contient la documentation générée si vous voulez voir les différentes structures utilisées.
Le code contient un bug : les valeurs initiales sont des "0" à ne pas confondre avec la page numéro "0".

[ABD] Charte à respecter

Charte dactylographique et structure du rapport.

ABD [Mise à Jour - 2020 - CoVid-19] - Administration des Bases des Données (Présentation générale - Les présentations du cours)

"Montrer les tendances actuelles dans le domaine d'administration des bases des données".