Les articles de Papydall

Je sais bien, j'y ais juste pensé et j'aime bien faire semblant de râler.
En fait j'ai relu les articles et j'ai plein de commentaire ou de proposition de modifications de tournures de phrases, voir quelques corrections, mais je crois que je les enverrais en message privé pour que les auteurs puissent décider ce qu'ils ont envie de prendre dedans ou non. Qu'en pensez-vous ?

En MP si tu veux, mais sache que je ne suis pas opposé à tes critiques (même publics). Le rédacteur en chef, c'est son boulot.

A+

OK, alors je post ici, comme ça tout le monde pourra donner son avis

Pour l'article "Conseils de programmation en Panoramic"

Pour les titres, je pense que ce serait mieux de les avoir soit tous à l'infinitif (Simplifier, Présenter, Découper, Commenter, Déclarer, Définir les propriétés, ...)

Je remplacerais la tournure de phrase de "Déclarer les variables": les langages qui tolèrent la non nécessité de déclarer... en les langages qui n'obligent pas à déclarer

A la fin du chapitre sur les Propriétés des variables, je modifierais: "chose qu'il impossible de faire" par "chose qu'il est impossible de faire"

Juste en dessous à la fin de la phrase "... lui donne la valeur 0" je rajouterais "ou vide pour les chaines de caractères"

Je remplacerais le dernier sous-titre "Choix des identificateurs" par "Quelques derniers conseils pour bien commencer"

Dans ton article, je ne vois pas la nécessité d'ajouter des illustrations utiles. Peut être une petite illustration amusante, je ne sais pas quoi par contre peut être un truc du genre :

OK chef!

@Ygeronimi
La date de mon second article est toujours celle du 07/06/2013 !
Moi, je n’ai pas fais un « bon bond » dans le futur comme tu l’as fait.

Tu n' as plus que deux jours d' avance...

J'ai fais un petit truc si ça peu contribuer à l'article:

Programmation procédurale:

Définitions :
• La programmation procédurale est un paradigme de programmation basé sur le concept d'appel procédural.
• Une procédure (aussi appelée routine, sous-routine, méthode ou fonction) contient simplement une série d’instructions à réaliser.
• N'importe quelle procédure peut être appelée à n'importe quelle étape de l'exécution du programme, incluant d'autres procédures (dans certains langages la procédure peut même s’appeler elle-même (récursivité), mais pas dans Panoramic).

Avantages :
• La possibilité de réutiliser le même code à différents emplacements dans le programme sans avoir à le retaper.
• La création d'un code plus modulaire et structuré.
• Une façon plus simple de suivre l'évolution du programme.

Exemple de code de déclaration des procédure Procédure0 et Procédure1 :
Sub Procédure0()
‘ici Traitement0
Procédure1()
End Sub

Sub Procédure1()
‘ ici Traitement1
End Sub


Programmation évènementielle :



Les composants d'une application évènementielle interagissent entre eux et avec l'environnement.
Ils communiquent en réponse à des évènements. Ces évènements peuvent correspondre à une action de l'utilisateur : un click sur un bouton de commande, une écriture dans une zone de texte, un choix dans une case d'option ou une case à cocher, le déplacement d'un objet, ... Ils peuvent aussi être déclenchés par le système : Fermeture d'une fenêtre, un top déclenché par l'horloge (Timer), ...

Les évènements sont captés par le système d'exploitation, sont mis en file d'attente ce qui signifie que les évènements sont séquentialisés. Ils sont ensuite pris en charge par la boucle de gestion des évènements.
La boucle de gestion des évènements prend le premier évènement à traiter dans la file et le traite.
Le traitement consiste en l'exécution des procédures évènement associées à celui-ci s'il en existe.
C'est le programmeur qui doit prévoir la procédure à exécuter en réponse à un évènement donné. P
ar exemple, le déclenchement de l’évènement clic sur un bouton quitter doit terminer l'exécution du programme, le choix d'un élément dans un menu doit déclencher certaines opérations, un top d'horloge doit modifier le contenu d'une zone d'image...

Exemple de code d’une procédure de traitement :
Clic_Bouton1:
‘ Traiter l’évènement…
Return

Hello Jicehel.

C’est bien, mais
L’identificateur d’un objet et en particulier d’une procédure SUB, ne doit pas comporter des caractères interdis : Le é dans le nom de la procédure SUB Procédure0() est interdit.

Dans le dernier paragraphe, le mot par exemple, tu l’as écrit : P puis à la ligne, puis ar exemple.

Comme quoi il faut toujours des correcteurs et je suis sûr que j'aurais fortement besoin de vous quand je pondrais mon article.

Dans les articles prioritaires qu'il faudrait faire pour ce numéro 1, voilà les thèmes que j'ai identifié:

Présentation du langage basic et de Panoramic
Glossaire du vocabulaire de base
Les structures de base (les différents type de boucles, si alors sinon, et la structure "case")
Utiliser l'interface de l'éditeur intégré de Panoramic


Après dans les moins pressée, je verrais bien:
Faire des calculs et utiliser des fonctions mathématiques avec Panoramic
Manipuler des chaines de caractères
Manipuler des fichiers
Faire des dessin en 2D
Utiliser la 3D

Voilà, j'ai fais ce premier jet entre autre pour moi pour définir ce que je devais écrire ... mais j'espère que ça pourra servir et être complété.

Je peux faire un truc sur les structures de programmation :
• Le bloc ou la séquence
• Le choix ou la structure alternative : IF … THEN … ELSE…END_IF ; et SELECT…CASE…END_SELECT
• La boucle ou la structure itérative : FOR … TO…NEXT ; WHILE ….END_WHILE ; REPEAT…UNTIL

Mais si tu t'es déjà mis dans le bain, je t'y laisse finir ton truc.

Je n'ai rien commencé, j'ai essayé de penser à ce qu'il y avait d'important à aborder dans les premiers numéros, mais j'en ai sans doute oublié beaucoup

Disons que c'est une réservoir d'idées avec une estimation de la priorité pour aborder ces sujets.

Perso, j'essayerais bien de reprendre un tuto de jack comme le casse brique que j'avais repris et de l'expliquer pas à pas en partant de la création de l'espace 3D puis en rajoutant des choses (les bords et la balle) dedans, puis en faisant bouger la balle et en la faisant rebondir sur les murs, puis en rajoutant la raquette et en expliquant comment la faire bouger, puis en rajoutant les briques et en expliquant les collisions (c'est là que mon programme n'était pas très bon mais ça devrait suffire pour le tuto) puis en rajoutant la gestion de la sortie de la balle et l'affichage des compteurs de score et de vie

Je pense que je vais le commencer, mais c'est un peu tôt. Là je me dis, bon un nouvel arrivant verra ce que l'on peut faire avec quelques lignes de code. En même temps, il n'aura pas encore les bases pour bien comprendre...

Du coup de pense que je vais en effet faire un des éléments de base et en effet, je me prendrais bien les structures de programmation.

Tu ne veux pas faire l'utilisation de l'interface Panoramic ? C'est assez simple, je pense, mais ce serait bien de l'avoir sous forme d'article bien complet avec les astuces d'utilisation, les raccourcis clavier, l'explication des outils et de l'aide intégrée.
Ça laisse de quoi faire un bel article (voir un article sur 2 numéros ...)

@yannick

Dans mon second article :Premier contact avec Panoramic :
Ligne 11, à corriger :

Citation :

Le FORM est un objet sur lequel seront affichées les sorties de PANORAMIC

Salut tout le monde.
Voici mon troisième article (qui n'est pas encore fini)
Je vous le soumets pour correction (et plus si affinité).
Merci à tous ceux qui veulent zieuter mon article.


STRUCTURES D’UN PROGRAMME EN PANORAMIC
Dans un programme, on peut rencontrer les trois structures suivantes :
•Le bloc ou la séquence
•Le choix ou la structure alternative
•La boucle ou la structure itérative

La séquence
C’est un ensemble d’instructions exécutées une fois et une seule, instruction après instruction
de façon séquentielle.
Voici un exemple de programme qui demande à l’utilisateur de saisir son nom, puis il affiche
un texte de bienvenue.

Code:

' ******************************************************************************
' sequence.bas
' Exemple de programme utilisant une séquence d'instructions
' ******************************************************************************
dim nom$ : ' Variable du type chaîne de caractères qui recevra le Nom
' On défini ici deux objets ALPHA
' un alpha permet de visualiser un texte statique que l'utilisateur ne peut pas
' modifier. C'est une alternative bien plus commode à l'instruction PRINT
' On défini sa position (TOP et LEFT) ainsi que la couleur et la taille du texte
alpha 1 : top 1,50 : left 1,50 : font_color 1,255,0,0 : font_size 1,16
alpha 2 : top 2,150 : left 2, 50: font_color 2,0,0,255 : font_size 2, 14
' Saisie du nom
' Pour cela on utilise au lieu de INPUT, MESSAGE_INPUT$ qui nous permet de
' traiter d'une façon confortable un texte saisi par l'utilisateur
nom$ = message_input$("Donnez-moi votre nom","Votre est ","")
nom$ = upper$(nom$) : ' on transforme le nom en majuscules
' Affichage par caption plus souple que par PRINT
caption 1,"Bienvenue " + nom$ + chr$(13) + "et bonne programmation en PANORAMIC"
caption 2,"Vous avez testé la structure séquentielle"
end : ' fin du programme; cette instruction n'est pas obligatoire DANS CE CAS.
' Mais dans d'autres cas, elle doit ABSOLUMENT figurer.
' Alors, autant prendre les bonnes habitudes et la faire figurer toujours.
' ******************************************************************************

Le choix ou la décision ou la structure alternative
Nous pouvons attendre d'un programme qu'il prenne des décisions dont dépendra son
déroulement.
Panoramic dispose de deux structures de prises de décision :
1 – La structure IF … THEN ... ELSE ... END_IF
2 – La structure SELECT ... CASE … END_SELECT

Décision type IF ... THEN … ELSE ... END_IF
Panoramic distingue trois possibilités dans une structure IF.
• IF condition THEN intruction(s)
Si la condition est vrai, l'instruction ou le groupe d'instructions après THEN est exécuté, sinon
l'exécution saute à la ligne suivante.
• IF condition
instruction(s)
END_IF
Dans ce cas, si la condition est vrai, l'instruction ou le groupe d'instructions jusqu'à END_IF
est exécuté. Autrement, l'exécution saute à l'instruction après IF.
• IF condition
instruction(s)
ELSE
instruction(s)
END_IF
Dans ce cas, si la condition est vraie, l'instruction ou le groupe d'instructions entre IF et ELSE
est exécuté. Autrement, l'instruction entre ELSE et END_IF est exécuté.
Remarque : Les décisions peuvent s'imbriquer. De plus, chacune des branches de ces décisions
peut à son tour recevoir une structure IF ... THEN ... ELSE … END_IF. Cette possibilité offerte
permet de construire des structures de prises de décisions extrêmement puissantes.
Voici, pour illustrer la structure alternative, un programme de calcul du salaire imposable à
partir du salaire brut et du statut de la personne, saisis par l'utilisateur.

Code:

' **************************************************************************
' Calcul du salaire imposable : Salaire_Imposable.bas
' **************************************************************************
dim taux_pension_ouvrier : taux_pension_ouvrier = 0.08
dim taux_pension_employe : taux_pension_employe = 0.08
dim taux_maladie_ouvrier : taux_maladie_ouvrier = 0.0415
dim taux_maladie_employe : taux_maladie_employe = 0.024
dim statut$, salaire_brut, salaire_imposable
dim rep$
' saisie du salaire brut
' Deux boucles REPEAT imbriquées :
' La boucle intérieure pour s'assurer que la saisie soit numérique et
' la boucle extérieure pour s'assurer que la valeur soit positive
repeat
repeat
rep$ = message_input$("Saisie du salaire brut","Salaire brut =","")
until numeric (rep$) > 0
salaire_brut = val(rep$)
until salaire_brut > 0
' Saisie du statut
' Une seule boucle REPEAT pour s'assurer que la saisie soit E pour employé
' ou O pour ouvrier.
' Vous pouvez faire votre saisie indifféremment en minuscule ou en majuscule.
' De toute façon, le système la transforme en majuscule.
repeat
rep$ = message_input$("Saisie du statut","Employé = E ; Ouvrier = O","E")
until (upper$(rep$) = "E") or (upper$(rep$) = "O")
statut$ = upper$(rep$)
' Calcul du salaire imposable
if statut$ = "E"
' Calculer le salaire imposable relatif à un employé
salaire_imposable = salaire_brut * ((1 - taux_pension_employe) - taux_maladie_employe)
else
' Calculer le salaire imposable relatif à un ouvrier
salaire_imposable = salaire_brut * ((1 - taux_pension_ouvrier) - taux_maladie_ouvrier)
end_if
' Arrondir à deux chiffres après le point décimal
salaire_imposable = int(100 * salaire_imposable + 0.5) / 100
' Afficher le résultat
message "Salaire imposable : " + str$(salaire_imposable)
end
' **************************************************************************

Décision type SELECT … CASE … END_SELECT
Une prise de décision multiple se programme beaucoup plus rapidement et de manière plus
lisible au moyen de l'instruction SELECT … CASE … END_SELECT.
Voici sa structure générale :
SELECT expression_arithmetique
CASE valeur1 : commande1
CASE valeur2 : commande2
…....
CASE valeurN : commandeN
END_SELECT
Lors d'un SELECT, Panoramic évalue l'expression arithmétique (également nomée
« selecteur ») et compare le resultat avec les valeurs (on dit aussi marques ou constantes de
cas). Le nombre de marque est indifférent.
Lorsque la valeur du selecteur correspond à celle d'une marque, alors le système exécute la
commande ou le bloc de commandes qui la suivent. Les autres marques sont sautées.
Lorsque Panoramic ne trouve pas de marque dont la valeur correspond au selecteur, le
programme se poursuit par la commande qui suit END_SELECT.
Le type de données du selecteur doit correspondre à celui des marques.
En Panoramic, n'est valide que le type entier et la valeur du selecteur doit être positive.
Veuillez à ce qu'une marque donnée n'apparaisse qu'une seule fois dans une même structure
SELECT.
Voici, pour illustrer l'emploi de SELECT … CASE … END_SELECT, un programme d'écriture en
chiffres romains, des entiers de 1 à 999 écrits en chiffres arabes.

Code:

' **************************************************************************
' Chiffres romains de 1 à 999
' **************************************************************************
dim i%,n$
alpha 1 : top 1,5 : left 1, 20 : color 1,0,0,0 : font_color 1,255,255,0
font_size 1,14 : caption 1," Liste de chiffres romains de 1 à 999 "
list 2 : top 2,40 : left 2,100 : height 2,400
for i% = 1 to 999
Romain(i%)
if n$ = "" then exit_for
next i%
end
' **************************************************************************
SUB Romain(n%)
if n% > 999
n$ = " !!! Ce nombre est trop grand pour moi !!!" + chr$(13)
n$ = n$ + "Mon programmeur m'a enseigné les chiffres romains de 1 à 999 seulement !"
message n$ : n$ = "" : exit_sub
end_if
n$ = ""
select int(mod(n%,1000)/100)
case 9 : n$ = n$ + "CM"
case 8 : n$ = n$ + "DCCC"
case 7 : n$ = n$ + "DCC"
case 6 : n$ = n$ + "DC"
case 5 : n$ = n$ + "D"
case 4 : n$ = n$ + "CD"
case 3 : n$ = n$ + "CCC"
case 2 : n$ = n$ + "CC"
case 1 : n$ = n$ + "C"
end_select
select int(mod(n%,100)/10)
case 9 : n$ = n$ + "XC"
case 8 : n$ = n$ + "LXXX"
case 7 : n$ = n$ + "LXX"
case 6 : n$ = n$ + "LX"
case 5 : n$ = n$ + "L"
case 4 : n$ = n$ + "XL"
case 3 : n$ = n$ + "XXX"
case 2 : n$ = n$ + "XX"
case 1 : n$ = n$ + "X"
end_select
select mod(n%,10)
case 9 : n$ = n$ + "IX"
case 8 : n$ = n$ + "VIII"
case 7 : n$ = n$ + "VII"
case 6 : n$ = n$ + "VI"
case 5 : n$ = n$ + "V"
case 4 : n$ = n$ + "IV"
case 3 : n$ = n$ + "III"
case 2 : n$ = n$ + "II"
case 1 : n$ = n$ + "I"
end_select
item_add 2,str$(n%) + " = " + n$
END_SUB
' **************************************************************************

La boucle ou la structure itérative
A suivre ...

EDIT : Le forum a chambardé ma mise en page !

Excellent début

Merci Jicehel

J'essayerai de le finir demain, pardon aujourd'hui, puisque nous sommes déjà demain!

Je souhaite que vous vouliez bien tester les codes.
« Si le débogage est l’art d’enlever les bogues, alors la programmation doit être l’art de les créer. » - Anonyme

Cela commence bien, ne t' en fait pas pour la présentation.

Ygeronimi, c’est toi qui porte le plus lourd fardeau!
Tu as prouvé qu’il est possible de bosser 25 heurs par jour !
Tu me rappelle un peu ma jeunesse.

Bonne nuit.

Non, non çà c' était avant...

mais tu peux rajouter donc un "e" à :

Citation :

heurs

s' il te plait ?
...cela fera plus sérieux...

PS: un "s" à "rappelle" aussi...

Bonjour.

On doit quand même ôter quelque chose à 25 heures pour retrouver une journée, sinon le compte ne sera jamais bon.

Tiens papydall, quelques considérations d'ordre orthographique sur ton article (uniquement la forme, pas le fond):

Citation :

Panoramic dispose de deux structures de prises de décision :
ça se discute, j'aurais mis prise de décision, il n'y en a qu'une à la fois, mais bon...

• IF condition THEN intruction(s) instruction(s)
Si la condition est vrai, l'instruction ou le groupe d'instructions après THEN est exécuté, sinon
l'exécution saute à la ligne suivante.
• IF condition
instruction(s)
END_IF
Dans ce cas, si la condition est vrai, l'instruction ou le groupe d'instructions jusqu'à END_IF

Dans ce cas, si la condition est vraie, l'instruction ou le groupe d'instructions entre IF et ELSE
est exécuté. Autrement, l'instruction entre ELSE et END_IF est exécuté.... exécutée
condition vrai ou vraie ? je mettrais vraie...

SELECT expression_arithmetique ... arithmétique

Lors d'un SELECT, Panoramic évalue l'expression arithmétique (également nomée ... nommée
« selecteur ») et compare le resultat avec les valeurs (on dit aussi marques ou constantes de
et suivantes: sélecteur au lieu de selecteur

Veuillez à ce qu'une marque donnée n'apparaisse qu'une seule fois dans une même structure ... Veillez

Je pinaille, ce sont des détails. Et je vois bien que ce sont des fautes d'inattention, dans le feu de l'action.

Salut JL35
Non tu ne pinailles pas.
Si j’ai posté mon article, c’est pour que vous puissiez (si vous le voulez bien) donner vos avis et corriger les éventuelles fautes aussi bien de forme (vocabulaire, grammaire, etc.) que de fond (justesse du propos, absence des bêtises, etc.)
Merci pour les fautes d’orthographe (j’en tiendrai compte)
Pour la valeur (ou la condition) vrai ou vraie, j’opte pour vrai et faux au lieu de vraie et fausse car je suppose que ces valeurs sont du type booléen (TRUE ou FALSE, VRAI ou FAUX) et ne doivent pas s'accorder ni en nombre ni en genre!
Mais ça se discute.

En tout cas merci.

Hé, vous autres, qu’en pensez-vous ?

NP : écrire un article à 2 heures du matin, c’est garantir la présence de belles perles dans le texte !

Cela dit, sur le fond ça me paraît impeccable et clair.

Je n'avais pas regardé les exemples de code de près (toujours pour l'orthographe):
Exemple 1: On défini ... -> On définit (deux fois)
Exemple 2: ... en minuscule ou en majuscule... le système transforme en majuscule ...
je dirais en minuscules ou en majuscules (il y en a plusieurs)
Exemple 3: ... mince, j'ai rien trouvé !

VIII.VI.MMXIII JL35 fecit.

@ Papydall,

Tu as mis comme titre "Structure d' un programme en Panoramic"

Je me pose la question suivante : Est vraiment spécifique à ce langage, n' y en a t il pas d' autres avec cette structure ?

Bonjour

Citation :

Pour la valeur (ou la condition) vrai ou vraie, j’opte pour vrai et faux au lieu de vraie et fausse car je suppose que ces valeurs sont du type booléen (TRUE ou FALSE, VRAI ou FAUX) et ne doivent pas s'accorder ni en nombre ni en genre!

Une simple question ou remarque. On dit vrai ou faux. OK mais TRUE = -1, il me semble. Pour Panoramic je ne pense pas qu'il s'agit de TRUE. Qu'en pensez-vous?

Salut Cosmos,
C'est vrai qu'en Panoramic on ne parle pas de True ni de False (selon les langages, ça peut être 1 True, 0 False), donc ça n'entre pas en ligne de compte ici.
C'est pourquoi je dirais quand même, malgré les arguments de papydall, qu'on dit qu'une condition est vraie ou fausse (et non pas qu'une condition est vrai ou faux, ce qui fait bizarre).