Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

« Le langage J offre une meilleure approche de l'itération que le C et d'autres »
D'après ses concepteurs

Le , par Patrick Ruiz

44PARTAGES

7  2 
Le langage J existe depuis une bonne trentaine d’années. C’est un langage de programmation fonctionnelle développé par Kenneth Iverson (un ex IBM fellow) et Roger Hui (désormais employé de Dyalog Ltd) en 1990. Le langage est connu comme un successeur du langage APL dont il propose une synthèse.

« J est un langage de programmation évolué à usage général particulièrement adapté à l'analyse mathématique, statistique et logique des données. C'est un outil puissant pour développer des algorithmes et explorer des problèmes qui ne sont pas encore bien compris », précisent ses concepteurs.

J est écrit en C portable et est disponible pour Windows, Linux, Mac, iOS, Android et Raspberry Pi. J peut être installé et distribué gratuitement. Les sources sont fournies sous licence commerciale et sous licence GPL 3.

Quelle plus-value par rapport à l’existant ?

En plus de la programmation fonctionnelle, le langage J propose les paradigmes tacite, objet et matriciel. C’est sur le dernier que, d’après ses concepteurs, repose sa singularité. En effet, ces derniers proposent aux habitués de langages comme le C d’abandonner le paradigme de boucles au profit d’expressions matricielles équivalentes. En guise d’exemple, la seule ligne de code mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@:|))^:(i.20) y) i. 0'"0 dans le bloc qui suit permet de provoquer l’exécution, une vingtaine de fois, de l’équation z_(n+1) = z_n**2 + C.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
load'viewmat'

size =: 100

NB. z_0 = C
NB. z_(n+1) = z_n**2 + C
NB. 
NB. We iterate this equation at most 20 times
NB. but short-circuit out (and return inf "_") if the value is > 2
NB. Then we compute the magnitudes of every value
NB. And find the first result that is > 2
mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@:|))^:(i.20) y) i. 0'"0

plane =: (j.i.size) + (size, size) $ i.size
center =: (0.75 * size) j. (0.5 * size)
scale =: % 0.35 * size

NB. Run `mandel` over out coordinate plane and plot it
viewmat mandel scale * plane – center
En fait, pour un problème dans lequel il est question de faire la somme de chaque élément au sein d’une liste x à chaque nombre dans la ligne correspondante d'un tableau bidimensionnel y, un programmeur J écrirait simplement x+y quand un programmeur C monterait le bloc de code :

Code : Sélectionner tout
1
2
3
4
5
for(i = 0;i<sizeof(x)/sizeof(x[0]);++i)
  for(j = 0;j<sizeof(y)/sizeof(y[0]);++j)
    z = x[i] + y[i][j];
  }
}

D’après les concepteurs du langage, l’approche J est meilleure pour plusieurs raisons : un code plus court est plus aisé à comprendre ; l’utilisation du paradigme matriciel permet de s’appuyer sur des expressions (au sens d’expressions littérales) plutôt que sur des instructions, ce qui permet d’obtenir des blocs de code beaucoup plus compact là où il aurait fallu d’imbriquer plusieurs structures de boucles.

« Le code C exige que le programmeur descende au niveau des éléments individuels du tableau. Un programmeur J pense en termes de tableaux entiers, en les combinant à l'aide de primitives qui permettent une manipulation directe des tableaux », ajoute l’équipe de développement. En fait cette dernière est d’avis que « l’approche que J adopte pour l’itération est bien meilleure que celle des autres langages. » Ce développement des concepteurs du J suggère que les structures de boucles n’ont pas leur place dans les langages de programmation impératifs. Le langage donne néanmoins la possibilité aux programmeurs d’écrire du code dans un style impératif proche du C en mettant sur pied des boucles. Ci-dessous, la liste des structures de contrôle disponibles avec le langage.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
assert. T
break.
continue.

for.     T do. B end.
for_xyz. T do. B end.

goto_name.
label_name.

if. T do. B end.

if. T do. B else. B1 end.

if.     T  do. B
elseif. T1 do. B1
elseif. T2 do. B2
end.

return.

select. T
 case.  T0 do. B0
 fcase. T1 do. B1
 case.  T2 do. B2
end.

throw.

try. B catch. B1 catchd. B2 catcht. B3 end.

while.  T do. B end.
whilst. T do. B end.
Une plus-value qui n’en est pas vraiment une ?

Et si le « gap » pouvait être comblé à l’aide de bibliothèques appropriées ? Armadillo par exemple en est rendu à sa version 9.8. C’est une bibliothèque C++ dédiée aux mathématiques matricielles. Elle met à la disposition des programmeurs une syntaxe et des fonctionnalités similaires à celles qu’offre le langage de script Matlab. Les programmeurs Haskell pour leur part disposent de la bibliothèque « linear » conçue pour la manipulation de vecteurs. Avec de tels outils en main, le programmeur doit pouvoir arriver à penser comme le suggèrent les créateurs du langage J : faire usage de structures matricielles pour résoudre des problèmes auxquels on apporte généralement solution à l’aide de structures de contrôles, notamment, des boucles. Deux camps s’opposent : les langages avec paradigme de programmation matriciel et ceux auxquels on adjoint des bibliothèques. Après, il faut ajouter les aptitudes de l’opérateur qu’est le programmeur.

Source : jsoftware

Et vous ?

Qu’en pensez-vous ?

Avez-vous fait usage de ce langage ? Si oui, dans quel type de projet et pour quelles raisons ?

La plus-value mise en avant par ses concepteurs sort-elle de l’ordinaire ?

Que pensez-vous de l’approche matricielle pour la résolution des problèmes en informatique ?

Voir aussi :

Quel langage pourrait remplacer C ? Après avoir comparé Go, Rust et D, le choix d'Andrei Alexandrescu se porte sur D

Pourquoi les langages C et C++ auraient-ils encore de nombreuses années devant eux ? Donnez votre avis

Quel avenir pour le langage C ? Un développeur expérimenté fait ses adieux au langage et livre ses inquiétudes quant à son avenir

C2 : un langage qui se présente comme une évolution de C, plus rapide, sans fichiers d'en-tête, avec système de build intégré et d'autres changements

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de tomlev
Rédacteur/Modérateur https://www.developpez.com
Le 21/10/2019 à 10:39
D’après les concepteurs du langage, l’approche J est meilleure pour plusieurs raisons : un code plus court est plus aisé à comprendre
Euh, c'est une blague j'espère ? C'est vrai dans certains cas, par exemple quand on appelle une fonction avec un nom explicite plutôt que de faire un calcul compliqué "inline", mais franchement quand je vois un truc imbitable comme mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@:|))^:(i.20) y) i. 0'"0, je vois mal comment on pourrait faire plus difficile à comprendre. La syntaxe est vraiment complètement absconse.
16  0 
Avatar de François DORIN
Expert éminent sénior https://www.developpez.com
Le 21/10/2019 à 11:52
Citation Envoyé par Patrick Ruiz Voir le message
« Le langage J offre une meilleure approche de l’itération que le C et d’autres »,
D'après ses concepteurs

D’après les concepteurs du langage, l’approche J est meilleure pour plusieurs raisons : un code plus court est plus aisé à comprendre ;
Premièrement, je vois mal des concepteurs essayer de vendre leur produit en disant "regarder, c'est de la m*****"

Deuxièmement, un code plus court n'est absolument pas plus aisé à comprendre. C'est une croyance populaire qui est loin d'être vrai ! Un code plus court peut être plus aisé à comprendre... comme plus compliqué !
Et quand je vois ce que cela donne ici, j'ai juste envie de dire "au mon dieu"... Je préfère mille fois un code bien écrit, verbeux, indenté et lisible que ce type de profil sismique que même un pharmacien (pourtant habitué à ce genre d'écriture) ne pourrait déchiffrer !

Personnellement, j'aimerai qu'une personne m'explique, en détail et en décomposant chaque opérateur, comment cette ligne mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@:|))^:(i.20) y) i. 0'"0 peut être l'équivalent de z_(n+1) = z_n**2 + C pour n de 1 (ou 0) à 20, ainsi que la démarche pour réussir à l'écrire.

Enfin, pour le debug, on fait comment ??
6  0 
Avatar de earhater
Membre éclairé https://www.developpez.com
Le 21/10/2019 à 10:51
Citation Envoyé par tomlev Voir le message
Euh, c'est une blague j'espère ? C'est vrai dans certains cas, par exemple quand on appelle une fonction avec un nom explicite plutôt que de faire un calcul compliqué "inline", mais franchement quand je vois un truc imbitable comme mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@:|))^:(i.20) y) i. 0'"0, je vois mal comment on pourrait faire plus difficile à comprendre. La syntaxe est vraiment complètement absconse.
J'en aurai appris plus sur le langage J et un nouveau mot de la langue française aujourd'hui
4  0 
Avatar de beeboo
Membre confirmé https://www.developpez.com
Le 21/10/2019 à 14:36
Quand je vois ce genre de syntaxe :
mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@))^i.20) y) i. 0'"0
autant programmer en brainfuck.
4  0 
Avatar de psykokarl
Membre confirmé https://www.developpez.com
Le 24/10/2019 à 2:05
Citation Envoyé par François DORIN Voir le message
Personnellement, j'aimerai qu'une personne m'explique, en détail et en décomposant chaque opérateur, comment cette ligne mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@:|))^:(i.20) y) i. 0'"0 peut être l'équivalent de z_(n+1) = z_n**2 + C pour n de 1 (ou 0) à 20, ainsi que la démarche pour réussir à l'écrire.
C'est précisément parce qu'il faut décomposer chaque caractère, pour retrouver chaque operateur, pour retrouver chaque instruction que ce langage offre une meilleur approche de l'iteration. Il faut en effet iterer un nombre de fois bien supérieur la lecture du code et les allez-retour vers la doc avant d'avoir la ne serait ce qu'une vague idée de ce que le code fait. Celui qui maitrise ce code aura à coup sur capter l'essence de ce qu'est une iteration !

Et pensez aux avantages lors de la mise en oeuvre !
Les fuites memoires et autres débordement n'impacterons plus les machines mais les developpeurs. Si on est soucieux de leur bien être, on peut coupler J à la solution "B". En effet, J&B offrira aux developpeurs faisant trop d'heures sup un moyen commode de se flusher la memoire àpres le boulot avant de se faire garbage collecter par une patrouille de flic (ou un camion poubelle) au petit matin ...
4  0 
Avatar de Bousk
Rédacteur/Modérateur https://www.developpez.com
Le 21/10/2019 à 14:56
Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
NB. z_0 = C
NB. z_(n+1) = z_n**2 + C
NB. 
NB. We iterate this equation at most 20 times
NB. but short-circuit out (and return inf "_") if the value is > 2
NB. Then we compute the magnitudes of every value
NB. And find the first result that is > 2
mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@:|))^:(i.20) y) i. 0'"0
1 ligne de code et 6 de commentaires qui sont, pour ma part en tous cas, obligatoires pour comprendre ce qu'il se passe ici

En fait, pour un problème dans lequel il est question de faire la somme de chaque élément au sein d’une liste x à chaque nombre dans la ligne correspondante d'un tableau bidimensionnel y, un programmeur J écrirait simplement x+y quand un programmeur C monterait le bloc de code :
Code : Sélectionner tout
1
2
3
4
5
for(i = 0;i<sizeof(x)/sizeof(x[0]);++i)
  for(j = 0;j<sizeof(y)/sizeof(y[0]);++j)
    z = x[i] + y[i][j];
  }
}
4 lignes de code que n'importe quelle personne un tant soit peu logique (mettons qu'il faille connaître for et sizeof, le reste sont des opérations mathématiques qu'un éleve de primaire connait) peut comprendre d'une simple lecture.

J'ai du mal à voir via cet exemple l'avantage de J (dont je n'avais jamais entendu parler)
3  0 
Avatar de yahiko
Rédacteur/Modérateur https://www.developpez.com
Le 21/10/2019 à 16:15
Le logo est très moche. C'est pour moi rédhibitoire.
4  1 
Avatar de octal
Membre éclairé https://www.developpez.com
Le 21/10/2019 à 10:51
Citation Envoyé par tomlev Voir le message
Euh, c'est une blague j'espère ? C'est vrai dans certains cas, par exemple quand on appelle une fonction avec un nom explicite plutôt que de faire un calcul compliqué "inline", mais franchement quand je vois un truc imbitable comme mandel =: 3 : '(2 > | (y + _&[`*: @.(2&>@:|))^:(i.20) y) i. 0'"0, je vois mal comment on pourrait faire plus difficile à comprendre. La syntaxe est vraiment complètement absconse.
Yes, you can do it ... faire plus compliqué à comprendre, il suffit d'écrire des expression Perl avec ses regex
3  1 
Avatar de archqt
Membre confirmé https://www.developpez.com
Le 21/10/2019 à 16:41
Moi j'ai toujours vu J avec K, même qu'il ne voulait pas qu'il conduise (ok je sors)
1  0 
Avatar de hyakosm
Nouveau membre du Club https://www.developpez.com
Le 21/10/2019 à 21:15
Le jour où ce langage et/ou cette syntaxe devient la norme, je change de métier et je me reconvertis dans le fromage de chèvre.
0  0