■ ■ ■ SOMMAIRE ■ ■ ■
- Simulation
- Algorigramme LCP
- Programme post_itBDD.ace
- Méthodologie « Logique de Construction de Programme (LCP)
- LCP et le programme post-itBDD.ace
- Billets LCP
En l’absence de liens hypertexte intra-document, je propose comme palliatif d’utiliser la fonctionnalité de votre navigateur
« Rechercher dans la page » :
Ctrl/F.
Chaque chapitre correspondant à un item du menu est précédé d’un signet «
§ ».
Vous saisissez dans la fenêtre de recherche le symbole typographique
Paragraphe "
§" puis vous naviguer dans le message à l’aide des flèches de direction de la fenêtre
˄ /
˅ ou à l’aide des raccourcis clavier
Ctrl+MaJ+G /
Ctrl+G.
- Affichage du message
- Rechercher dans la page : Ctrl/F
- Saisie du symbole typographique Paragraphe : "§"
- [Entrée] ou ˄ / ˅ ou Ctrl+MaJ+G / Ctrl+G
§ 01 : Simulation
ec_place = Plus grand numéro de place = nombre de candidats = 22 (pour ce jeu d’essai)
Numéro de post-it = Numéro de la pile + (Numéro de la page précédente * 4)
=> initialiser le numéro de page à zéro
TRI / NUMÉRO DE PLACE TRI / NUMÉRO DE POST-IT
┌───────┬───────┬───────┬───────┐ ┌───────┬───────┬───────┬───────┐
│ Place │Post-it│ Pile │ Page │ │ Place │Post-it│ Pile │ Page │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 1 │ 1 │ 1 │ 1 │ │ 1 │ 1 │ 1 │ 1 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 2 │ 5 │ 1 │ 2 │ │ 7 │ 2 │ 2 │ 1 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 3 │ 9 │ 1 │ 3 │ │ 13 │ 3 │ 3 │ 1 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 4 │ 13 │ 1 │ 4 │ │ 18 │ 4 │ 4 │ 1 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 5 │ 17 │ 1 │ 5 │ │ 2 │ 5 │ 1 │ 2 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 6 │ 21 │ 1 │ 6 │ │ 8 │ 6 │ 2 │ 2 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 7 │ 2 │ 2 │ 1 │ │ 14 │ 7 │ 3 │ 2 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 8 │ 6 │ 2 │ 2 │ │ 19 │ 8 │ 4 │ 2 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 9 │ 10 │ 2 │ 3 │ │ 3 │ 9 │ 1 │ 3 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 10 │ 14 │ 2 │ 4 │ │ 9 │ 10 │ 2 │ 3 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 11 │ 18 │ 2 │ 5 │ │ 15 │ 11 │ 3 │ 3 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 12 │ 22 │ 2 │ 6 │ │ 20 │ 12 │ 4 │ 3 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 13 │ 3 │ 3 │ 1 │ │ 4 │ 13 │ 1 │ 4 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 14 │ 7 │ 3 │ 2 │ │ 10 │ 14 │ 2 │ 4 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 15 │ 11 │ 3 │ 3 │ │ 16 │ 15 │ 3 │ 4 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 16 │ 15 │ 3 │ 4 │ │ 21 │ 16 │ 4 │ 4 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 17 │ 19 │ 3 │ 5 │ │ 5 │ 17 │ 1 │ 5 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 18 │ 4 │ 4 │ 1 │ │ 11 │ 18 │ 2 │ 5 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 19 │ 8 │ 4 │ 2 │ │ 17 │ 19 │ 3 │ 5 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 20 │ 12 │ 4 │ 3 │ │ 22 │ 20 │ 4 │ 5 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 21 │ 16 │ 4 │ 4 │ │ 6 │ 21 │ 1 │ 6 │
├───────┼───────┼───────┼───────┤ ├───────┼───────┼───────┼───────┤
│ 22 │ 20 │ 4 │ 5 │ │ 12 │ 22 │ 2 │ 6 │
└───────┴───────┴───────┴───────┘ └───────┴───────┴───────┴───────┘
§ 02 : Algorigramme LCP
Le programme gère deux compteurs que l’on peut assimiler à des tables (voir la simulation ci-dessus) dont le contenu est leur rang (numéro), autrement dit leur indice courant (i_page et i_pile) :
- une table des pages (nombre d’items = (nombre d’inscrits + 3) /4)
- et une table des piles de 4 items.
Numéro de post-it = Numéro de la pile + (Numéro de la page précédente * 4)
=> initialiser le numéro de page à zéro
Initialisations :
LET j_page = ec_place / 4 -> j_page = 22 / 4 = 5
LET v_reste = ec_place - (j_page * 4) -> v_reste = 22 – (5 * 4) = 2 -> v_reste = 2
LET j_page = (ec_place + 3) / 4 -> j_page = (22 + 3) /4 = 6 -> j_page = 6
LET i_page = 0 -> i_page = 0
LET i_pile = 1 -> i_pile = 1
LET v_place = 1 -> v_place = 1
┌─────────────────────┐
│ v_reste = 2 │
│ j_page = 6 │
D-PRG │ i_page = 0 │
│ i_pile = 1 │
│ v_place = 1 │
└──────────┬──────────┘
├────────────────────────────────────────────────────────────────────┐
┌──────────┴──────────┐ │
D-PLACE │ ON EVERY ROW │ │
└──────────┬──────────┘ │
├─────────────────────────────────────────────────────────────────┐ │
┌──────────┴──────────┐ │ │
D-PLACE LIBRE │ v_place < cec_place │ │ │
non └──────────┬──────────┘ oui │ │
┌───────────────◊───────────────────┐ │ │
│ ┌──────────┴──────────┐ │ │
│ D_PAGE │ i_page = j_page │ │ │
│ non └──────────┬──────────┘ oui │ │
│ ┌───────────────◊───────────────┐ │ │
│ │ ┌──────────┴──────────┐ │ │
│ │ │i_pile = i_pile + 1 │ │ │
│ │ D_PILE │i_page = 0 │ │ │
│ │ │v_reste > 0 │ │ │
│ │ non └──────────┬──────────┘ oui │ │
│ │ ┌───────────────◊──────────────┐ │ │
┌──────┴──────┐ ┌──────┴──────┐ ┌──────┴──────┐ ┌───────────┴───────────┐ │ │
│ Ø │ │ Ø │ │ Ø │ │v_reste = v_reste - 1 │ │ │
└──────┬──────┘ └──────┬──────┘ └──────┬──────┘ └───────────┬───────────┘ │ │
│ │ └───────────────┬──────────────┘ │ │
│ │ ┌──────────┴──────────┐ │ │
│ │ INTER │ v_reste = 0 │ │ │
│ │ non └──────────┬──────────┘ oui │ │
│ │ ┌───────────────◊──────────────┐ │ │
│ │ ┌──────┴──────┐ ┌───────────┴───────────┐ │ │
│ │ │ Ø │ │j_page = ec_place / 4 │ │ │
│ │ └──────┬──────┘ └───────────┬───────────┘ │ │
│ │ └───────────────┬──────────────┘ │ │
│ │ ┌──────────┴──────────┐ │ │
│ │ F_PILE │ Ø │ │ │
│ │ └──────────┬──────────┘ │ │
│ └───────────────┬───────────────┘ │ │
│ ┌──────────┴──────────┐ │ │
│ F_PAGE │i_page = i_page + 1│ │ │
│ │v_place = v_place + 1│ │ │
│ └──────────┬──────────┘ │ │
└───────────────────┬───────────────┘ │ │
┌──────────┴──────────┐ │ │
F-PLACE LIBRE │ v_place < cec_place │ │ │
└──────────┬──────────┘ oui │ │
◊─────────────────────────────────────────────────────────────┘ │
┌──────────┴──────────┐ │
INTER │ i_page = j_page │ │
non └──────────┬──────────┘ oui │
┌───────────────◊───────────────┐ │
│ ┌──────────┴──────────┐ │
│ │i_pile = i_pile + 1 │ │
│ D_PILE │i_page = 0 │ │
│ │v_reste > 0 │ │
│ non └──────────┬──────────┘ oui │
│ ┌───────────────◊──────────────┐ │
┌──────┴──────┐ ┌──────┴──────┐ ┌───────────┴───────────┐ │
│ Ø │ │ Ø │ │v_reste = v_reste - 1 │ │
└──────┬──────┘ └──────┬──────┘ └───────────┬───────────┘ │
│ └───────────────┬──────────────┘ │
│ ┌──────────┴──────────┐ │
│ INTER │ v_reste = 0 │ │
│ non └──────────┬──────────┘ oui │
│ ┌───────────────◊──────────────┐ │
│ ┌──────┴──────┐ ┌───────────┴───────────┐ │
│ │ Ø │ │j_page = ec_place / 4 │ │
│ └──────┬──────┘ └───────────┬───────────┘ │
│ └───────────────┬──────────────┘ │
│ ┌──────────┴──────────┐ │
│ F_PILE │ Ø │ │
│ └──────────┬──────────┘ │
└───────────────┬───────────────┘ │
┌────────────────┴────────────────┐ │
│v_post_it = i_pile + (i_page * 4)│ │
│PRINT v_post_it │ │
F-PLACE │i_page = i_page + 1 │ │
│v_place = v_place + 1 │ │
│v_place > ec_place │ │
└────────────────┬────────────────┘ non │
◊────────────────────────────────────────────────────────────────┘
┌────────────────┴────────────────┐
F-PRG │ ON LAST ROW │
│ PRINT v_post_it (flagué ˮ-ˮ) │
└─────────────────────────────────┘
§ 03 : Programme post_itBDD.ace
Cet exercice d’algorithmie n’est autre que le programme post_itBDD.ace d’une application Examens-Concours développée avec le SGBD Informix de 1992 à 2007.
Si le programme a été écrit le 10/03/1992, son logigramme a été réalisé le 26/06/2019 comme support pédagogique d’un billet de blog consacré à la Méthodologie de programmation LCP.
{================================= post_itBDD =================================}
{ }
{ ACE : post_itBDD.ace }
{ }
{ SHELL : ../shell_1/post_itBDD }
{ }
{ AUTEUR : APL-AML }
{ }
{ Objet : Création du fichier "$(LOGNAME).out" à loader dans la table tmp }
{ pour mise à jour de l'information cec.post_it }
{ à l'aide du sql "post_itBDD.sql" }
{ }
{ L'édition des post_it s'effectue à l'aide du shell "post_itALL" }
{ }
{ post_itBDD et post_itALL gèrent les places libres. }
{ Il est donc possible de relancer éventuellement cette chaine. }
{ }
{ Date : 10 Mars 1992 }
{ }
{==============================================================================}
{========================}
{==========================} DATABASE concours END {==========================}
{========================}
{================================} DEFINE {==================================}
{} {}
{} PARAM[1] p_c_ec CHAR(5) {}
{} PARAM[2] p_t_ec CHAR(2) {}
{} PARAM[3] p_s_ec CHAR(2) {}
{} PARAM[4] p_logname CHAR(8) {}
{} {}
{} VARIABLE j_page INTEGER {}
{} VARIABLE i_page INTEGER {}
{} VARIABLE i_pile INTEGER {}
{} VARIABLE v_post_it INTEGER {}
{} VARIABLE v_place INTEGER {}
{} VARIABLE v_reste INTEGER {}
{} {}
{==================================} END {===================================}
{================================== INPUT ===================================}
{} {}
{ PROMPT FOR v_dp USING " CONCOURS : " }
{} {}
{=================================== END ====================================}
{================================} OUTPUT {==================================}
{} {}
{ REPORT TO PRINTER }
{} REPORT TO PIPE "cat > ${LOGNAME}.out" {}
{} TOP MARGIN 0 {}
{} BOTTOM MARGIN 0 {}
{} LEFT MARGIN 0 {}
{} PAGE LENGTH 58 {}
{} {}
{==================================} END {===================================}
{=================================} SELECT {=================================}
ec.cts ec_cts,
ec.c_ec ec_c_ec,
ec.t_ec ec_t_ec,
ec.s_ec ec_s_ec,
ec.place ec_place,
cec.n_cec cec_n_cec,
cec.place cec_place
FROM ec,
cec,
ln
WHERE ec.c_ec = $p_c_ec
AND ec.t_ec = $p_t_ec
AND ec.s_ec = $p_s_ec
AND ec.cts = cec.cts
AND (cec.c_decision = "A" OR cec.c_decision = "C")
AND cec.place IS NOT NULL
AND ln.logname = $p_logname
AND (ln.service IS NULL OR ln.service = ec.service)
{===============================} ORDER BY {================================}
ec_cts,
cec_place
{==================================} END {===================================}
{=================================} FORMAT {=================================}
{------------------------} BEFORE GROUP OF ec_cts {-----------------------}
LET j_page = ec_place / 4
LET v_reste = ec_place - (j_page * 4)
LET j_page = (ec_place + 3) / 4
LET i_page = 0
LET i_pile = 1
LET v_place = 1
{---------------------------- FIRST PAGE HEADER ----------------------------}
{------------------------------ PAGE HEADER ------------------------------}
{------------------------------- PAGE TRAILER -------------------------------}
{------------------------------} ON EVERY ROW {------------------------------}
WHILE v_place < cec_place
DO BEGIN
IF i_page = j_page
THEN BEGIN
LET i_pile = i_pile + 1
LET i_page = 0
IF v_reste > 0
THEN LET v_reste = v_reste - 1
IF v_reste = 0
THEN LET j_page = ec_place / 4
END
LET i_page = i_page + 1
LET v_place = v_place + 1
END
IF i_page = j_page
THEN BEGIN
LET i_pile = i_pile + 1
LET i_page = 0
IF v_reste > 0
THEN LET v_reste = v_reste - 1
IF v_reste = 0
THEN LET j_page = ec_place / 4
END
LET v_post_it = i_pile + (i_page * 4)
PRINT cec_n_cec USING "<<<<<<<<<<<<", "||",
ec_c_ec CLIPPED, "|", ec_t_ec, "|", ec_s_ec, "|-|-|-|-|||",
cec_place USING "<<<<", "||", v_post_it USING "<<<<", "|||||||||"
LET i_page = i_page + 1
LET v_place = v_place + 1
{-------------------------- TRAITEMENT FIN DE PAGE --------------------------}
{------------------------ TRAITEMENT EN-TETE DE PAGE ------------------------}
{------------------------ TRAITEMENT LIGNE COURANTE ------------------------}
{------------------------- AFTER GROUP OF ec_cts -------------------------}
{------------------------------} ON LAST ROW {-------------------------------}
PRINT cec_n_cec USING "<<<<<<<<<<<<", "||",
ec_c_ec CLIPPED, "|", ec_t_ec, "|", ec_s_ec, "|-|-|-|-|||",
cec_place USING "<<<<", "||", v_post_it USING "<<<<", "||||||||-|"
{ - Reinitialisation de l'imprimante "HP LASERJET III Si" }
{==================================} END {===================================}
§ 04 : Méthodologie « Logique de Construction de Programme » (LCP)
LCP procède par structuration :
La structure hiérarchique d'un programme se déduisant logiquement de la structure des données utilisées (FLS/FLE), la construction du programme commence par la structuration des données qu'il doit produire en sortie.
Au-delà de la structuration hiérarchique du programme déterminée par la structure des données, le degré de décomposition algorithmique peut descendre jusqu’au niveau de l’instruction. Cela dépend de la capacité d’abstraction du programmeur. La seule règle qui régit la réflexion :
| « Penser hiérarchiquement par traitements, autrement dit : raisonner du plus global vers le plus détaillé, par décompositions hiérarchiques successives sur la base des actions et non sur celle des conditions ». |
Concernant ce programme post_itBDD, la structuration classique LCP est rudimentaire puisqu’il s’agit de créer une seule information en sortie (post_it) à partir d’une seule information en entrée (place).
- Structuration des données de sortie (informations présentes).
Les données de sortie ne sont pas exclusivement des données destinées à être imprimées. Ce peut être des données de la BDD (écran de saisie) ou le résultat d’un traitement particulier comme c’est le cas pour le programme post_itBDD proposé.
- Structuration des données d’entrée (informations utiles).
LCP est une méthode de programmation conçue à l’origine dans un contexte batch où le Fichier Logique en Entrée (FLE) était constitué en amont du programme. Dans un contexte BDD, c’est le développeur qui constitue et structure le FLE dont le programme a besoin.
C’est la conception et la structuration préalable du FLS qui inspire la conception et la structuration du FLE.
- Structuration du programme.
La structuration du programme se déduit de celle du FLE pour ce qui concerne les Ensembles De Données (EDD), mais la décomposition structurelle du programme peut devoir être poussée plus finement, au-delà des EDD, tout en respectant la logique LCP qui consiste à penser par traitements. C’est le cas pour ce programme post_itBDD.
§ 05 : LCP et le Programme post_itBDD.ace
- Structuration des données de Sortie (FLS)
Représentation des Ensembles De Données (EDD) sous forme de patatoïdes :
┌───────────────────────────────────────────────────────────────────────────────────┐
│ EDD FLS (ensemble universel) │
│ ┌───────────────────────────────────────────────────────────────────────────────┐ │
│ │ EDD PLACE CEC (P fois) (Niveau 1) │ │
│ │ ┌───────────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ EDD CANDIDATURE (1 fois) (Niveau 2) │ │ │
│ │ │ │ │ │
│ │ │ cec.n_cec (N° de la candidature) │ │ │
│ │ │ cec.cts (code du concours = code + type + session) │ │ │
│ │ │ cec.place (place attribuée au candidat lors du placement par ordre alpha.)│ │ │
│ │ └───────────────────────────────────────────────────────────────────────────┘ │ │
│ └───────────────────────────────────────────────────────────────────────────────┘ │
└───────────────────────────────────────────────────────────────────────────────────┘
┌ ┌
│ │ CEC_N_CEC
│ │ CEC_C_EC
│ EDD │ CEC_T_EC
EDD FLS < PLACE (P) < CEC_S_EC
│ │ CEC_PLACE
│ │ CEC_POST_IT
│ │
└ └
Niveau : Niveau 1 Niveau 2
Référentiel : Place CEC Candidature
- Structuration des données d’Entrée (FLE)
┌ ┌
│ │ CEC_N_CEC
│ EDD │
EDD FLE < PLACE (P’) < CEC_CTS
│ │
│ │ CEC_PLACE
└ └
Niveau : Niveau 1 Niveau 2
Référentiel : Place CEC Candidature
- Structuration du Programme (PROG)
┌
│ D-PRG
│
PRG < T-PLACE (P')
│
│ F-PRG
└
Niveau : Niveau 1
Référentiel : Place CEC
- Algorigramme
┌─────────────┐
010 │ D-PRG │
└──────┬──────┘
├─────────┐
┌──────┴──────┐ │
020 │ T-PLACE │ │
└──────┬──────┘ │
◊─────────┘
┌──────┴──────┐
030 │ F-PRG │
└─────────────┘
- Structuration in extenso du Programme
Les candidatures supprimées n’apparaissent pas bien sûr dans le FLE. La structuration du programme prenant en compte les places libres générées par la suppression possible de certaines candidatures ne peut se réaliser que par la réflexion, tout comme la détermination du numéro de post_it. Symboliser cette réflexion sous forme d’un diagramme avec des accolades peut s’avérer très vite compliqué.
Traduction d’un début de cette réflexion sous forme d’un diagramme avec des accolades :
┌ ┌ ┌ ┌
│ D-PRG │ D-PLACE │ D-PLACE LIBRE │ D-PAGE
│ │ │ PLACE (0,1) │ T-PAGE (0,1)
│ │ PLACE LIBRE (PL) < PAGE (0,1) <
│ │ │ │ T-PAGE (0,1)
│ │ │ F-PLACE LIBRE │ F-PAGE
PRG < PLACE (P’) < INTER └ └
│ │
│ │ T-PAGE (0,1)
│ │ T-PAGE (0,1)
│ │
│ F-PRG │ F-PLACE
└ └
Niveau : Niveau 1 Niveau 2 Niveau 3 Niveau 4
Référentiel : Place CEC Place Référente Place libre Page
- Algorigramme détaillé au niveau de l’instruction
Lorsque la Logique de Construction de Programme est acquise, les structurations et le logigramme restent à l’état de construction mentale quasi inconsciente. Le programme post_itBDD n’utilise qu'une vingtaine d'instructions, gère deux tables (page et pile) et 3 variables (v_post_it, v_place, v_reste).
Si le programme a été écrit le 10/03/1992, soit il y a près de 30 ans, son logigramme a été réalisé le 26/06/2019 pour créer un billet de blog, soit 27 ans plus tard. Dans un souci pédagogique plus rigoureux, les structurations FLS, FLE et PRG ont quant à elles été réalisées encore plus récemment en juillet 2021, suite à la découverte sur internet d’un ancien support de cours LCP qui se transforme progressivement en tutoriel : Logique de Construction des Programmes
- Les traitements :
- PLACE : Le traitement « PLACE » correspond au « CANDIDAT ». Un numéro de place a été affecté aux candidats lors du placement par ordre alphabétique avant l’envoi des convocations.
- PLACE LIBRE : Le traitement « PLACE_LIBRE » est en fait le traitement d’un numéro de place référent qui palie les éventuelles candidatures supprimées.
- PAGE : Lorsque la dernière place ne correspond pas à un multiple de 4, le nombre de pages n’est pas le même selon la pile.
- PILE : C’est le nombre de pages qui détermine le changement de pile.
§ 06 : Billets LCP
Pour en savoir davantage sur LCP, vous trouverez trois billets dans mon blog dont le billet Méthodologie de programmation LCP qui m'a permis d'alimenter cette discussion. Ce billet est une ébauche de tutoriel LCP en cours de rédaction.
Adepte LCP, j’expose dans ce billet mon expérience de la méthode en respectant au mieux la pédagogie originelle. Certains aspects de cette pédagogie qui se réfèrent à des supports de cours des années 70 peuvent décourager le lecteur. Il suffit de les survoler ou de passer outre en utilisant la navigation internet « Rechercher dans la page ».
Les 3 billets consacrés à LCP :
Fin de mon devoir de vacances
Sujet d’algorithmie original : imprimer des numéros de table en piles
Répondre avec citation
Envoyé par mach1974
Partager