J'aimerais bien qu'on m'explique?

[Forthman]

@Ludwig! Merci pour l'éclairage.
Effectivement, pouvoir créer des mots qui vont permettre de créer des mots, est un outil assez puissant et agréable à utiliser.

Je ne suis pas sûr que l'on puisse comparer ça avec la POO telle qu'elle est pratiquée en C++ par exemple, et d'ailleurs je n'ai
jamais utilisé le terme d'objet en parlant de la pile système. pour moi ce sont toujours des valeurs 16,32, ou 64 bits qui correspondent
à quelque chose, mais c'est au programmeur de savoir justement quoi en faire. Il n'y a aucun garde-fou (je viens de voir qu'avec swift Forth
il y en a un en ce qui concerne les accès mémoires)

Par exemple, j'ai dans mon Forth le mot SPRITE_BMP qui me permet de créer mes mots de type "sprite" en provenance d'une image bmp

par exemple : image.bmp 100 150 45 23 SPRITE_BMP TOTO
va créer le mot TOTO qui est un sprite récupéré sur l'image "image.bmp"
le point de départ est en X100 Y150, la largeur vaut 45 et la hauteur 23 pixels
et si je tape :
20 40 TOTO
mon sprite s'affiche en X20 Y40
(ça c'était pour dire que je savais utiliser ces choses là )

Si je créé deux variables POSITION_X et POSITION_Y pour positionner mon sprite,
je peux m'en servir en faisant : POSITION_X @ POSITION_Y @ TOTO
mais si j'oublie un "@" : POSITION_X POSITION_Y @ TOTO
rien ne va m'avertir de la boulette, juste l'affichage ne fonctionnera pas car X vaudra l'adresse de POSITION_X

Bon, ok, j'ai pris un exemple extrêmement simple à débugger, mais c'est parfois plus pervers car le "compilateur" ne vérifie
pas grand chose (à part l'était de la pile avant/après)

Si je tape : CREATE TRUC_BIDULE 4 ALLOT
pour créer un petit tableau de 4 octets
que j'initialise les 4 valeurs avec 12 34 56 et 78 :
12 TRUC_BIDULE 0 + C!
34 TRUC_BIDULE 1 + C!
56 TRUC_BIDULE 2 + C!
78 TRUC_BIDULE 3 + C!


mais que plus loin dans mon programme, pensant effacer le premier octet je fais : 0 TRUC_BIDULE 0 + ! ( ! au lieu de C! )
et bien en fait je viens de mettre à 0 tout le tableau car ! fonctionne sur 32 bits et non 8

Pour un programmeur venant d'un langage de haut niveau ça peut perturber
-----

[pm42]

Effectivement, pouvoir créer des mots qui vont permettre de créer des mots, est un outil assez puissant et agréable à utiliser.
Je ne suis pas sûr que l'on puisse comparer ça avec la POO telle qu'elle est pratiquée en C++

Cela n'a rien à voir avec la programmation objet en effet. On appelle plutôt cela de la méta-programmation et là aussi, cette possibilité existe dans différents langages.

[invite2800a7c8]

Re salut,

@Ludwig! Merci pour l'éclairage.
Effectivement, pouvoir créer des mots qui vont permettre de créer des mots, est un outil assez puissant et agréable à utiliser.

Je ne suis pas sûr que l'on puisse comparer ça avec la POO telle qu'elle est pratiquée en C++ par exemple, et d'ailleurs je n'ai
jamais utilisé le terme d'objet en parlant de la pile système. pour moi ce sont toujours des valeurs 16,32, ou 64 bits qui correspondent
à quelque chose, mais c'est au programmeur de savoir justement quoi en faire. Il n'y a aucun garde-fou (je viens de voir qu'avec swift Forth
il y en a un en ce qui concerne les accès mémoires)

Ce que je viens de te montrer c'est la POO par prototype telle qu'elle à toujours existée dans la VM.
Par la suite, il s'est rajouté la POO Par classe made in C++. Personnellement j'utilise seulement cette façon de faire (C++) pour du fenêtrage sous Windows (Faut bien puisque Windows de MS veut des déclarations de classes etc...)
Mais dans les deux styles de programmation les infos transitent toujours par la pile de données.
Il y a des règles toutes simples que tu dois appliquer.

- Considère que les données et seulement les données sont des objets.
- Considère que pour chaque objet il existe une série de méthodes permettant de faire des opérations sur les dits objets.
- Considère que l'accès à la structure d'un objet, aussi complexe soit 'il se fera toujours avec un pointeur qui est délivré lors
de l'appel de cet objet.

Quand tu fais de l'usinage tu distingues bien les pièces et les outils me semble t'il, alors pourquoi ceci devrai être autrement
avec une machine à "usiner" des informations?

En clair, la programmation consistera à:

1) Mettre sur la pile les données dans l'ordre requis
2) Appel de la méthode qui va faire le traitement qui va ou non restituer un résultat sur la pile de données
lequel résultat servira comme données à une nouvelle méthode qui va etc...

Il est vrai qu'il faut une certaine rigueur et avoir fait auparavant une analyse approfondie. Mais ceci ne devrai pas te
poser de PB, tu as l' habitude de l'usinage, tu vas pas appeler un taraud M20 quand t'as auparavant percé un trou de 8.
C'est la casse assurée.
Ben ici c'est pareil, il faut aussi réfléchir à ce que l'on fait.

Pour un programmeur venant d'un langage de haut niveau ça peut perturber

C'est vrai, pour ceux qui viennent d'un langage classique, ça peut perturber, mais en général on s'y fait assez vite, surtout
quand on s'aperçoit que le temps de développement a sensiblement diminué.


Cordialement

Ludwig

[invite2800a7c8]

Salut

Cela n'a rien à voir avec la programmation objet en effet. On appelle plutôt cela de la méta-programmation et là aussi, cette possibilité existe dans différents langages.

Montre un exemple
d'abord compil time à la compilation
Puis Run time à l'exécution

Cordialement
Ludwig

[pm42]

Montre un exemple
d'abord compil time à la compilation
Puis Run time à l'exécution

J'ai renoncé à combler ton ignorance abyssale.
Il suffit de te voir raconter qu'un objet ce ne sont que des données puis des méthodes dessus...

Tu as inventé les objets sans polymorphisme, sans encapsulation. Encore un grand moment.

[invite2800a7c8]

Re

J'ai renoncé à combler ton ignorance abyssale.
Il suffit de te voir raconter qu'un objet ce ne sont que des données puis des méthodes dessus...

Tu as inventé les objets sans polymorphisme, sans encapsulation. Encore un grand moment.

Disons que tu ne sais pas c'est plus simple

Cordialement

Ludwig

[pm42]

Disons que tu ne sais pas c'est plus simple

Oui, oui. Si ça te rassure... De la part de quelqu'un pour qui on a créé un fil parking afin de l'empécher de polluer ailleurs, à qui on l'a dit et qui se fait avoir quand même, c'est très amusant.

Et ça t'évite de savoir ce que veulent dire encapsulation et polymorphisme.
Et là, tu vas aller vite chercher l'info, revenir pour expliquer en racontant n'importe quoi et finir par citer "ton cher collègue X" pour essayer d'impressionner

[invite2800a7c8]

Salut

Et ça t'évite de savoir ce que veulent dire encapsulation et polymorphisme.

https://www.forth.com/download/

Lancer, puis help, puis References Manuel, à partir de la page 159, c'est bien expliqué, peut 'être pourras tu apprendre quelque chose.

Cordialement
Ludwig

[pm42]

Comme prévu, tu as sorti une référence pour éviter le fait que tes explications plus haut étaient un grand n'importe quoi.
J'attends la suite, tu dois encore :

- t'enfoncer en montrant que tu ne sais de quoi tu parles
- parler d'un de tes distingués et prestigieux collègues pour nous faire croire que tu es quelqu'un qui a dépassé le "Hello World" . sans bug

[Forthman]

Messieurs, si youplait, restons courtois

J'ai imprimé les fameuses pages concernant le "SWOOP" (pages 159 à 174)
et j'ai lu ça à table (oui, c'est pas poli, mais ma femme lisait ses bouquins sur le droit social alors ... )

Alors oui, ça ressemble déjà plus à de la POO comme un ami me l'avait expliqué (mais n'ayant
jamais touché à ça, je serai bien incapable de l'expliquer à mon tour ).

Pour reprendra l'alogie sur l'usinage, je trouve que les forthiens passent beaucoup trop de temps à affûter
leurs outils et pas assez de temps pour réaliser des pièces...
Sûrement un problème lié au chômage

[invite2800a7c8]

Salut,

Pour reprendra l'analogie sur l'usinage, je trouve que les forthiens passent beaucoup trop de temps à affûter
leurs outils et pas assez de temps pour réaliser des pièces...
Sûrement un problème lié au chômage

T'as raison on fait bien des outils, mais on fait aussi des pièces.

{ ====================================================================

Composant ChoicePath-EW300F50AB40.FTH

ChoicePath-EW300F50AB40.FTH is a computer component developed by I.C.M.
This component is for free use and made available to users by I.C.M.
I.C.M. Assumes no responsibility for the implementation of this component.

==================================================================== }

PACKAGE OFN-DIALOGS



{ --------------------------------------------------------------------

GONE makes a control disappear from the ofn common dialog and
TEXT sets a new text value on an ofn common dialog control.

-------------------------------------------------------------------- }

: GONE S( id --- )
   
   
   HWND GetParent CDM_HIDECONTROL ROT 0 SendMessage DROP 


;


: TEXT S( id z --- )

   HWND GetParent CDM_SETCONTROLTEXT 2SWAP SendMessage DROP ;

{ --------------------------------------------------------------------

[OFN-CHILD is shorthand for [MODAL with (+STYLE ...) and (-STYLE ...)

-------------------------------------------------------------------- }

PACKAGE DLGCOMP


(OR
   WS_MAXIMIZEBOX
   WS_MAXIMIZE
   WS_CHILD
   WS_CLIPSIBLINGS
   WS_VISIBLE
   DS_3DLOOK
   DS_CONTROL)
DIALOG-HEADER [OFN-CHILD

END-PACKAGE

{ --------------------------------------------------------------------

This dialog overlays the selected filename dialog.

-------------------------------------------------------------------- }




DIALOG OFN-OVERLAY

   [OFN-CHILD 100 50 280 160 (FONT 8, MS Sans Serif) ]
   [PUSHBUTTON " &Cancel"   IDCANCEL 230  90  45 15 ]
   [PUSHBUTTON " &Utiliser" IDOK     180  90  45 15 ]
   [EDITTEXT   " C:\TEST"   102        5  90 170 15 (+STYLE ES_READONLY) ]
   [LTEXT      " NOTHING"   103        5 112 170 15 (-STYLE WS_VISIBLE) ]

{ --------------------------------------------------------------------

SHOW-PATH writes the current ofn path to the text control.

ACCEPT-PATH jams the current path into the filename field of the
OPENFILENAME data strcuture.

REJECT-PATH clears the filename field, so we can detect a cancel.

NOTIFIED handles the folder change notification so we can update the
text field of the dialog.

DONE send a close message to the parent, ie the ofn dialog.

-------------------------------------------------------------------- }


: SHOW-PATH S( --- )

   HWND GetParent CDM_GETFOLDERPATH 260 PAD SendMessage DROP
   HWND 102 PAD SetDlgItemText DROP
  

 ;

: ACCEPT-PATH S( --- )

   HWND 103 0 0 GetDlgItemInt
   [OBJECTS OPENFILENAME NAMES OFN OBJECTS]
   HWND 102 OFN zFILE @ OFN MaxFile @ GetDlgItemText 

\ Get FolderPath

   HWND GetParent CDM_GETFOLDERPATH 260 PAD SendMessage DROP
  
   PAD ZCOUNT 
   ( #Base Tas #ScanPath )Base!		\ The name of the selected file is attached to the label
					\ #ScanPath in the  database named TAS


;



: REJECT-PATH S( --- )

   HWND 103 0 0 GetDlgItemInt
   [OBJECTS OPENFILENAME NAMES OFN OBJECTS]
   0 OFN zFILE @ C! ;



: NOTIFIED S( --- res )
   LPARAM 2 CELLS + @ CASE
      CDN_FOLDERCHANGE OF SHOW-PATH ENDOF
   ENDCASE 0 ;

: DONE S( --- )
   HWND GetParent WM_CLOSE 0 0 SendMessage DROP ;

{ --------------------------------------------------------------------

This is the message switch hook for my dialog overlay. It hides
some of the ofn dialog controls, manages notification messages, and
deals with our buttons for cancel or accept.

-------------------------------------------------------------------- }



:NONAME S( --- res )

   INHERIT-SEARCHORDER MSG CASE
      WM_INITDIALOG OF
         Z" C:\" SetCurrentDirectory DROP
         edt1 GONE                      \ file selection
         stc3 GONE                      \ file selection label
         cmb1 GONE                      \ filter selection
         stc2 GONE                      \ filter selection label
         IDOK GONE                      \ open button
         IDCANCEL GONE                  \ cancel button
         HWND 103 LPARAM 0 SetDlgItemInt DROP
         SHOW-PATH
      ENDOF
      WM_NOTIFY OF
         NOTIFIED
      ENDOF
      WM_COMMAND OF
         WPARAM LOWORD CASE
            IDCANCEL OF  REJECT-PATH DONE  ENDOF
            IDOK     OF  ACCEPT-PATH DONE  ENDOF
         ENDCASE 0
      ENDOF
      DUP OF S( unknown)   0  ENDOF
   ENDCASE ;   4 CB: MYHOOK

{ --------------------------------------------------------------------

CHOOSE-PATH-DIALOG extends the OFN-DIALOG class to use the dialog
overlay and the hook procedure.

-------------------------------------------------------------------- }

OFN-DIALOG SUBCLASS CHOOSE-PATH-DIALOG

   : CUSTOM S( --- title filter flags )
      MYHOOK HOOK !  OFN-OVERLAY INSTANCE !
      Z" [ I. C. M. ] International  Cloud Machines   Sélection Répertoire"  ALL-FILES
      DEFAULT-OPEN-FLAGS
      OFN_ENABLETEMPLATEHANDLE OR
      OFN_EXPLORER OR
      OFN_ENABLEHOOK OR ;

END-CLASS

END-PACKAGE

{ --------------------------------------------------------------------

TESTING

-------------------------------------------------------------------- }

OFN-DIALOGS +ORDER

: ChoicePath-EW300F50AB40 S( --- )

  
   [OBJECTS CHOOSE-PATH-DIALOG MAKES CPD OBJECTS]
   CPD CHOOSE 
   DROP

;

' ChoicePath-EW300F50AB40 Last_Cmd !

  OFN-DIALOGS -ORDER




 

\\

Voici un composant prêt à l'emploi. Il permet de récuperer l'Explorer et de l'intégrer dans ton application. Ainsi tu disposes dans ton application de toutes les fonctionnalités de l'explorer.
Comme tu peux constater on fait largement appel à POO par classes
[OBJECTS CHOOSE-PATH-DIALOG MAKES CPD OBJECTS].
(Windows oblige)

Cordialement
Ludwig

[Forthman]

ok, je me suis fait avoir...
quand j'ai écrit pièces je pensais à des pièces "finies"

Donc nous avons : outils -> pièces -> machines finies

Et ce sont les machines finies qui manquent alors

[invite0324077b]

j'ai apprécié le forth sur commodore vic20 , a l'epoque ou a l'université de Besançon on faisait du fortran sur l'ordinateur bull du centre de calcul ... il a fallu attendre quelque année de plus pour voir les ibm pc

je trouve le forth très efficace pour faire rapidement des programme simple ... ensuite ça se complique pour s'y retrouver

je me suis amusé a ecrire en forth un programme de decompilation : le compilateur du vic 20 etant facile a comprendre il est possible de programmer ce qu'il faut pour decompiler et faire un programme source ou il manque juste les nom que le programeur a choisi et qui n'on pas été mis dans la version compilé ... et je me suis apercu que ça pouvait decompiler du langage machine pas du tout ecris en forth !

ça ne peut pas exactement traduire en forth n'importe quel langage machine avec n'importe quel branchement conditionnel : j'ai donc du inventer quelques structure de contrôle que le forth n'avait pas pour pouvoir decompiler n'importe quoi sans exeption

mais pendant que je faisait cela les ibm pc arrivaient avec beaucoup plus de puissance , et des langages de programation qui savaient calculer en virgule flottante , alors que le forth du vic ne connaissait que 8 ou 16 bit

je suis convaincu de certaine qualité du forth ... mais a quoi bon depuis que les ordinateur sont assez puissant pour que d'autre langages fassent exactement ce que l'on veut

quand il faut choisir un langage actuellement , je prefere choisir un langage gratuit , disponible pour tout le monde , avec des bibliotheque disponible pour tous les périphérique ... par exemple le python ... même si la synthaxe du python me fait pleurer en comparaison avec le forth

mais puisque les version gratuite du forth ne font pas ce dont j'ai besoin , il faut bien faire avec ce qui est disponible

ça n'empeche que je continue a penser au forth , pour en faire une version pedagogique , avec traduction automatique entre forth python ou C , les programme simple sont plus vite ecris en forth , et traduit en python ou c il seront plus facile a comprendre pour celui qui ne les a pas ecris

[invite2800a7c8]

Salut,

j'ai apprécié le FORTH sur commodore vic20 , a l'époque ou a l'université de Besançon on faisait du fortran sur l'ordinateur bull du centre de calcul ... il a fallu attendre quelque année de plus pour voir les ibm pc

je trouve le FORTH très efficace pour faire rapidement des programme simple ... ensuite ça se complique pour s'y retrouver

J'ai également vécu cette époque, Forth était déjà une machine virtuelle contenant éditeur, Interprète, compilo, Assembleur du processeur hôte etc..etc... c.a.d. un système de développement complet.
Puis arrivèrent les PC avec DOS puis tout de suite derrière des systèmes Forth parfaitement adaptés à la nouvelle donne, package graphique, FpMath en virgule flottante, etc... etc.. Puis arriva 3.11 puis encore adaptation puis Win95 etc... etc.. pour aujourd'hui tourner avec Windows 10, Mac OS ou encore Linux.
Par contre, les instructions normalisées de la machine Virtuelle Forth n'ont pas bougées d'un Iota, DUP duplique toujours le sommet de la pile de données.
Au début ça dupliquais 8 bits puis ensuite 16 puis 32 puis 64 également 80 pour le coprocesseur Math.
Au fur et à mesure, le jeu d'instruction de la machine Virtuelle s'étoffait de nouvelles Instructions, les anciennes étant maintenues. L'instruction C@ met toujours un octet sur le sommet de la pile de données, même si celle-ci est actuellement de 32/64 bits.
Ce que je veux dire avec tout ça, c'est qu'il y a une certaine constance, ce que j'ai appris il y a 30 ans est toujours vrai, que je travaille sous DOS ou Windows 10 ça ne change pas grand-chose au niveau des instructions de la machine virtuelle.
Réserver de la mémoire par exemple se fait avec Allocate que ce soit sous DOS ou WIN 10 n'y change rien. Le résultat des courses est que la machine actuelle fonctionne sous tous les systèmes d'exploitation WIN 95, NT, XP, WIN 10 etc...

je me suis amusé à écrire en FORTH un programme de décompilation : le compilateur du Vic 20 étant facile à comprendre il est possible de programmer ce qu'il faut pour décompiler et faire un programme source ou il manque juste les nom que le programmeur a choisi et qui n'ont pas été mis dans la version compilé ... et je me suis aperçu que ça pouvait décompiler du langage machine pas du tout écris en FORTH !
ça ne peut pas exactement traduire en FORTH n'importe quel langage machine avec n'importe quel branchement conditionnel : j'ai donc du inventer quelques structure de contrôle que le FORTH n'avait pas pour pouvoir décompiler n'importe quoi sans exception

Mais pendant que je faisais cela les ibm pc arrivaient avec beaucoup plus de puissance, et des langages de programmation qui savaient calculer en virgule flottante, alors que le FORTH du Vic ne connaissait que 8 ou 16 bit

Le concept de la machine virtuelle Forth contient des ressources insoupçonnées, je pratique depuis bien 40 ans, mais encore aujourd'hui il m'arrive de constater que je n'en ai pas fait le tour. Je me suis souvent demandé si Chuck a trouvé l’inspiration en regardant les étoiles.

je suis convaincu de certaine qualité du FORTH ... mais à quoi bon depuis que les ordinateur sont assez puissant pour que d'autre langages fassent exactement ce que l'on veut.
Quand il faut choisir un langage actuellement, je préfère choisir un langage gratuit, disponible pour tout le monde, avec des bibliothèques disponible pour tous les périphérique ... par exemple le python ... même si la syntaxe du python me fait pleurer en comparaison avec le Forth

Le fait est que chaque langage contient ses particularités. Mais comme Forth est une machine informatique virtuelle, il me semble difficile de comparer les deux choses.
Le fait est que la machine actuelle que j'utilise ne fais pas appel à des bibliothèques, elle comporte des dictionnaires dans lesquels on trouve tout ce dont on à besoin pour développer. La concision du code d'une routine faite avec la machine virtuelle est légendaire. En fait, comme tu sais, la " Compilation" ne produit pas du code au sens strict du terme, elle produit une liste de pointeurs qui sont les points d'entrés des fonctions (CFA), donc pas vraiment du code machine du processeur hôte.
Du coup, tu dis qu'une pareille liste porte le nom d'applet, tu t'arranges pour que le code source ne ressemble pas vraiment aux instructions de la machine virtuelle Forth, puis tu t'arranges pour que la machine virtuelle qui va exécuter la liste des pointeurs ne soit plus accessible au travers de son interpréteur de commande ni de plus rien d’autre d’ailleurs et tu décrète que tout ça, ça s’appelle maintenant JAVA.
Evidement pour noyer le poisson, tu vas t’arranger pour que la syntaxe du code source soit le plus possible similaire à celle de CPP par exemple.

Mais puisque les versions gratuites du Forth ne font pas ce dont j'ai besoin, il faut bien faire avec ce qui est disponible

Il existe des Versions d’évaluation, elles contiennent toutes les ressources des versions professionnelles. Mais je crois qu’on ne peut pas demander à quelqu’un de travailler gratuitement.
Si tu veux quelque chose qui est gratuit, regarde ce que Tom Zimmer et ses compères ont fait. Ou regarde du côté de Bernd Paysan à la Forth Gesellschaft.
Tu peux aussi poser des questions ici.
https://groups.google.com/forum/#!forum/comp.lang.forth

Ça n'empêche que je continue à penser au FORTH, pour en faire une version pédagogique, avec traduction automatique entre FORTH python ou C, les programme simple sont plus vite écris en FORTH, et traduits en python ou C ils seront plus facile à comprendre pour celui qui ne les a pas écrit

Je pense qu’ici on pourra discuter très très longtemps sur la notion d’auto documentation des programmes.
Par exemple, ça c’est du Forth

(   #Base Tas #Size  32  #Header 2 )CreateBase 		

\ Création d’une base de données de nom tas
\ Taille 32 blocs de 4096 Octets
\ Entête 2 blocs de 64 octets


Tas Open 

\ Ouverture de celle-ci

Egalement ceci c’est du FORTH

(   #M1 15 #M2 Une étiquette #M3 125.92  #M4   Une liste    )List	

\ Enregistrement dans la base 
\ active, d’une liste d’étiquettes et de leurs valeurs associées.


(   #M4   )Getval,        

\ Dans la base active, cherche l’étiquette #M4 et 
\ La valeur attachée, ici  la chaine  ‘’  Une liste ‘’

Et là je dois avouer que je vois mal comment on va traduire ceci en PYTHON ou en C ? Par contre l’inverse est plus simple à faire me semble-t-il. (Cross compilation de PYTHON vers Forth) par exemple. ( Forth contient déjà au moins 80 % des outils nécessaires pour ce genre d’exercice.

Le fait est qu’avec FORTH tu peux écrire des procédures avec le langage machine du processeur hôte, mais tu peux aussi écrire des instructions comme celle-ci

( #File C:\EasyWindows\User\CreateApplication-EW300F50AB40.FTH )Loadbase

Cordialement

Ludwig