Discussion :

[la.lune]

Pour la deuxième (qui en C++ est une déclaration de fonction ) et la troisième, le problème c'est que, par exemple, pour le retour anonyme et il faudra faire comme en C++ cad :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return decimal(100, 2)

Non pas forcement à quoi ça sert l’inférence de type mais la fonction possède un type de retour non? Il va obligatoirement me refuser de retourner quelque chose qui ne correspond pas au type c'est simple je je retourne (100,2), quand même il sait vérifier que le type de retour est un décimal et qu'il existe un constructeur qui prend deux paramètres dont deux entier, de la même manière qu'il ne refuse pas de faire decimal salary=(100,3) il va accepter les deux valeur entre parenthèses et tout est réglé. La JVM sait faire de l’inférence de type depuis l'entrée des generic et maintenant avec les lambda il sait bien reconnaître les types des paramètres des fonction.

La bonne chose que j'ai aimé quand j'ai vu le document c'est le fait de ne pas être obligé d'utiliser la fonction equals pour comparer, certes on la crée pour la définir mais on peut utiliser l'operateur == au lieu de équals. Moi si on m'a dit de proposer j'aurais proposé à ce qu'on nous donne la possibilité de ne pas être toujours obligé de définir un constructeur, et éxiger un constructeur primaire, un peu comme en C# 6 mais pas forcement la même chose car ici ça doit être le critère de reconnaissance d'un Value Type. Tout se fait automatiquement après, et vu qu'ici le plus important c'est simplifier la manipulation des valeurs il faut toujours simplifier les choses. Voila comment je vois que les choses devraient être:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
final class Point(int x, int y){ //Le reste se fait automatiquement x et x sont public
private int c;//Si je veux avoir une valeur privé
boolean equals(Point p){
return this.x==p.x&&this.y==p.y}
public static Point manipuler(){
int a; int b;
//traitement
return (a,b); //inférence de type
}
public static void maFunction(Point p, boolean b, double b){
//traitement
}
} 
final class MaClass(char a, double f, boolean b){
}//ça peut suffir déjà, si c'est pour manipuler un value Type de maClass

Manipulation;

Code Java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Point p1=(2,4),p2=(5,6),p3=(2,4);
boolean b=p1==p3;
boolean b2=p1==(2,4);//inférence de type
boolean b3=p1.equals((2,3));//inférence de type
/*ERROR*/ boolean b2=(2,4)==p1;// Possible de faire de l’inférence de type mais en fait il faut qu'on sache que c'est la fonction equals qui est appelé 
//alors ça sera moche qu'en compilation il va transformer (2,4)==p1 en p1.equals((2,4)) ou tout simplement il va créer une nouvelle Value Type
/*ERROR*/ boolean b4=(2,4)==(2,4)// pas de base pour une inférence de type
Point a=Point.manipuler();
//Si après import statc Point
Point a=manipuler();
maFunction((3,5),true,2.4);//inference de type
//On peut faire du casting
Point2D p=(Point2D)(Point)(2,3);
//Je ne peux pas faire
/*ERROR*/ Point2D p=(Point2D)(2,3);//ERROR il ne connait pas (2,3) et s'il existe déjà un contructeur pas besoin de casting alors
MaClass M=('d',4.5,true);

Si quelqu'un sait comment soumettre une proposition j'allais envoyer ça, qu'en dites vous de cette proposition?

[foetus]

Ok donc retour à la struct ou à l'union...

Pas forcèment

Comme l'a dit 23JFK, en C++, il y a la surcharge des opérateurs (+, -, -, +=, ==, /=, ...), et on peut faire des constructeurs pour les conversions implicites.

Et toujours en C++, il y a les opérateurs pour transformer une classe vers un POD (int float, ...) ou une autre classe.

Ainsi, avec le jeux des conversions, la JVM pourrait stocker des types point2D avec juste un entier, et le récupérer en type Point2D.
Ou que la classe BigInteger se comporte comme un type primitif.

Mais, le seul truc c'est que la surcharge des opérateurs n'est pas triviale et demande de la réflexion. Surtout que l'on peut "casser" la langage

[Gugelhupf]

La surcharge des opérateurs ne serait utile qu'avec des objets tels que String, BigInteger & BigDecimal...
Ils auraient pu ajouter la surcharge d'opérateur il y a très longtemps je pense, mais Java est un langage strict, et ne laisse pas les développeurs faire n'importe quoi, comme additionner deux animaux oiseau et chat (cela n'a pas de sens même si on peut le faire en C++ et C#, cf ce qu'a dit thelvin).

La première proposition n'est pas possible en java, sinon on n'a plus la distinction entre un pointeur et une valeur (en C++ on déclare un pointeur decimal * salary(0); ). Pour la deuxième (qui en C++ est une déclaration de fonction ) et la troisième, le problème c'est que, par exemple, pour le retour anonyme et il faudra faire comme en C++ cad :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

return decimal(100, 2)

Et là on se retrouve avec l'impression d'appeler une fonction (d’ailleurs un analyseur syntaxique n'est pas capable de faire la différence) et non de créer un objet (en JS c'est là même chose, mais c'est une autre philosophie ). Même si j'adore le C++, je n'ai pas envie de me retrouver avec la complexité de la syntaxe du C++ en Java. A mon sens, la syntaxe de Java doit rester compréhensible sans le contexte (localisation, symbole), rester simple.

Oui il peut y avoir risque de confusion pour la première solution, mais c'est comme confondre une interface avec une classe, cela s'utilise de la même manière. La première solution ne me parait pas absurde dans le sens où il n'y a pas de distinction entre la déclaration d'une variable primitive et un objet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
int var;
Object ob;

Pour la 2ème et 3ème je suis d'accord, et j'ai trouvé une alternative meilleure sur internet, au lieu que ce soit l'objet qui prenne les paramètres, c'est le type qui pourrait le prendre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
decimal d1;
decimal(100, 2) d2;
return decimal(100, 2);

Et le tour est joué

[Invité]

Je suis développeur sur mainframe IBM z/OS et en COBOL principalement. Ce langage est ancien et rustique, mais facile à apprendre et pour l'informatique de gestion, c'est suffisant, et même idéal, mieux que PL/1.
Java devient un langage de plus en plus difficile à apprendre. On va bientôt arriver à des choses ésotériques qui ne seront faites que pour leur créateurs. Ce langage est assez verbeux, peu performant et franchement mal sécurisé. C'est sur ces points qu'il faut l'améliorer, pas à ajouter des choses qui ne seront pas bien comprises, donc mal employées, et probablement ajouteront des problèmes de sécurité de manière très inattendues. J'ai juste une expérience personnelle de Java, pas en milieu professionnel. Il est trop technique : il faut 3 ans au moins pour faire un bon développeur Java, en COBOL, 6 mois suffisent, à condition de bosser avec des gens compétents et qui aiment leur job, bien entendu.

[thelvin]

What ?

- Assez verbeux : bon ça c'est dans sa nature, l'idée c'est qu'on peut pas ignorer ce qu'on fait quand on code. C'est pas parfait mais les résultats sont bons. Encore faut-il vouloir ça.
Mais les derniers ajouts qui y ont été faits, servent justement à le rendre moins verbeux. 'Faudrait savoir ce que tu veux.

- Peu performant : mais bien sûr, et t'as des preuves bien entendu.
L'aspect principal sur lequel Java est peu performant, c'est ce que la présente amélioration essaie d'enlever. À nouveau, 'faudrait savoir ce que tu veux.
Les autres aspects sur lesquels Java peut être peu performant si on les exploite vraiment à fond, sont inévitables pour son architecture sécurisée. Ils n'existent pas si on s'amuse à compiler du Java pour une architecture qui ne sécurise la cohérence du modèle mémoire. Donc encore, 'faudrait savoir ce que tu veux.

- Mal sécurisé : Ben voyons, et par comparaison avec quel autre langage/architecture ?

[adiGuba]

- Mal sécurisé : Ben voyons, et par comparaison avec quel autre langage/architecture ?

"Java c'est mal sécurisé", c'est le nouveau "Java c'est lent".

Un gros mythe qui s'installe au vue des différentes news catastrophiques sur les problèmes de sécurité des applets.
La plupart des gens n'arrivant pas à faire la distinction entre le plugin Java et le langage Java...


a++

[Gugelhupf]

Je suis développeur sur mainframe IBM z/OS et en COBOL principalement. Ce langage est ancien et rustique, mais facile à apprendre et pour l'informatique de gestion, c'est suffisant, et même idéal, mieux que PL/1.
Java devient un langage de plus en plus difficile à apprendre. On va bientôt arriver à des choses ésotériques qui ne seront faites que pour leur créateurs. Ce langage est assez verbeux, peu performant et franchement mal sécurisé. C'est sur ces points qu'il faut l'améliorer, pas à ajouter des choses qui ne seront pas bien comprises, donc mal employées, et probablement ajouteront des problèmes de sécurité de manière très inattendues. J'ai juste une expérience personnelle de Java, pas en milieu professionnel. Il est trop technique : il faut 3 ans au moins pour faire un bon développeur Java, en COBOL, 6 mois suffisent, à condition de bosser avec des gens compétents et qui aiment leur job, bien entendu.

Houlà, cela fait vraiment peut venant d'une personne qui gère les programmes derrière mon compte en banque...
Si 6 mois suffisaient pour avoir de bons développeur COBOL, ils ne couteraient pas aussi chère

[thelvin]

Ce n'est pas pour ton compte en banque, ça ils s'en fichent. C'est pour investir ton argent comme si c'était le leur, sans se faire arnaquer par l'endroit où ils l'investissent.

[bouye]

On va bientôt arriver à des choses ésotériques qui ne seront faites que pour leur créateurs.

Je reste cependant un poil attentif a ce point la.

Depuis le passage au JDK8, outre le fait que parfois la syntaxe des streams peut s’avérer pas trop parlante / difficile a digérer par rapport a de simples boucles, je me suis plusieurs fois repris a devoir simplifier en urgence du code que j'avais écrits pour mes articles en préparation (articles qui sont plus destinés a des débutants / utilisateurs confirmés qu'a des experts).
En effet, j'avais, sur le coup, abusé des lambdas, interfaces fonctionnelle et références de méthode et me trouvais a passer en paramètres de certains traitements devenus très génériques des allocateur, desallocateur, comparateur, etc. Donc, j’étais en train d’écrire en Java une sorte d’équivalents du code, très efficace mais totalement inabordable pour le néophyte, qu'on peut trouver dans ces bon vieux bouquins "The C++ Programming Language" de Stroustrup ou "Effective STL" de Meyers.

Donc j'adore toutes ces nouvelles fonctionnalités mais j'ai de plus en plus l'impression d’écrire du C++ plutôt que du Java

[la.lune]

Je reste cependant un poil attentif a ce point la.

Depuis le passage au JDK8, outre le fait que parfois la syntaxe des streams peut s’avérer pas trop parlante / difficile a digérer par rapport a de simples boucles,
....

Pour la question du fait que la syntaxe des steams est difficile à digéré par rapport au simples boucles, je ne pense pas. Moi je pense plutôt que c'est une question de maîtrise d'un nouveau paradigme qu'on avait pas en Java. Le même argument peut être donné par un fan du procédural devant l'Objet. Mais une fois on maîtrise l'objet on trouve moche de faire du procédural.

Focaliser son esprit sur les boucles est pour moi n'est pas la bonne chose, car si on se dit que le but du programmeur est d'atteindre ces objectifs, à quoi ça sert vraiment se se focaliser sur le changement d'état que sur le comportement que j'attend de mon programme. Avec la programmation impérative je me soucis plus sur l’enchaînement des instructions de ma boucle, et le changement d'état de mes variables, que faire une fois j'ai tel donné dans tel valeur, et parfois avec plein d'indices surtout pour les boucles imbriqués dont le soucis est de savoir par quoi je dois initialisé, où la boucle va finir est ce que c'est i<n ou i<=n , j=i+1 ou j=i, j<i ou j<=i, des truc comme ça pour moi je ne pense pas que ça sert vraiment à quelque chose que de rendre la vie du développeur difficile au lieu de se concentrer sur les traitements que mon programme doit réaliser.

La programmation fonctionnelle essaye de nous donner un autre mode de codage que l'impérative, il nous permet de regarder le programme comme un ensemble de comportement(fonctions) que mon programme évalue. Non seulement ça contribue fortement sur la sémantique de mon code du moment où il est simple de comprendre un programme fonctionnelle que des boucles dont il faut plein d'effort pour savoir vraiment le comportement, mais ça offre à mon programme plus de choix sur comment attaquer mon programme (évaluation paresseuses et autres..) et permet aussi de réduire le nombre de lignes de code à écrire, même si ce n'est pas toujours. Mais offre la facilité de l'intégration de la programmation parallèle.

Donc pour moi c'est une question d'habitude et une bonne maîtrise du paradigme fonctionnel et puis c'est tout. Personnellement, je ne retournerais jamais aux boucles en Java que si je n'ai pas de choix. Je ne trouve aucune gêne d'abuser des expressions lambda et des référence de méthode (oui ça ressemble à C++ mais je vois pas la gêne) ils sont bon pour la santé du code que les classes anonymes.

[foetus]

Focaliser son esprit sur les boucles est pour moi n'est pas la bonne chose, car si on se dit que le but du programmeur est d'atteindre ces objectifs, à quoi ça sert vraiment se se focaliser sur le changement d'état que sur le comportement que j'attend de mon programme. Avec la programmation impérative je me soucis plus sur l’enchaînement des instructions de ma boucle, et le changement d'état de mes variables, que faire une fois j'ai tel donné dans tel valeur, et parfois avec plein d'indices surtout pour les boucles imbriqués dont le soucis est de savoir par quoi je dois initialisé, où la boucle va finir est ce que c'est i<n ou i<=n , j=i+1 ou j=i, j<i ou j<=i, des truc comme ça pour moi je ne pense pas que ça sert vraiment à quelque chose que de rendre la vie du développeur difficile au lieu de se concentrer sur les traitements que mon programme doit réaliser.

Je ne sais pas vraiment si c'est de cela dont tu parles, mais tu oublies un [gros] truc

En C, il n'y a qu'une seule façon simple de créer des tableaux avec les crochets []: mais cela crée en gros un bloc contiguë en mémoire.
Donc 1 seule façon de le parcourir de 0 à N.

Mais en POO, les collections sont plus complexes, mais elles sont nettement plus flexibles et nettement plus adaptées aux besoins.
Mais les données ne sont pas contiguës en mémoire. Donc on est obligé de passer par une classe itérateur spécifique à chaque collection parce qu'elle seule sait comment parcourir la collection.

D’ailleurs cela se voit que tu n'as jamais travaillé avec des fichiers (images, vidéos, ...), parce que pour parser les headers, tu es obligé de faire des boucles pour récupérer les différentes informations

La programmation fonctionnelle essaye de nous donner un autre mode de codage que l'impérative

Non la première raison des fonctions c'est de regrouper les traitement afin d'être appelés plusieurs fois, et non pas faire des copier/ collé ou des GOTO

[23JFK]

ça ne serait pas plus simple d'introduire la surcharge d'opérateurs comme en C++ , les machines modernes étant suffisamment puissantes pour "cacher" les lourdeurs de la gestion des objets ?

[marsupial]

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
* sans titre.c
 * 
 * Copyright 2014 marsupio <marsupio@marsupio>
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 * 
 * 
 */
 
 
#include <stdio.h>
 
 
 
 
 
#ifndef _ASM_GENERIC_ERRNO_BASE_H
#define _ASM_GENERIC_ERRNO_BASE_H
 
#define EPERM        1  /* Operation not permitted */
#define ENOENT       2  /* No such file or directory */
#define ESRCH        3  /* No such process */
#define EINTR        4  /* Interrupted system call */
#define EIO      5  /* I/O error */
#define ENXIO        6  /* No such device or address */
#define E2BIG        7  /* Argument list too long */
#define ENOEXEC      8  /* Exec format error */
#define EBADF        9  /* Bad file number */
#define ECHILD      10  /* No child processes */
#define EAGAIN      11  /* Try again */
#define ENOMEM      12  /* Out of memory */
#define EACCES      13  /* Permission denied */
#define EFAULT      14  /* Bad address */
#define ENOTBLK     15  /* Block device required */
#define EBUSY       16  /* Device or resource busy */
#define EEXIST      17  /* File exists */
#define EXDEV       18  /* Cross-device link */
#define ENODEV      19  /* No such device */
#define ENOTDIR     20  /* Not a directory */
#define EISDIR      21  /* Is a directory */
#define EINVAL      22  /* Invalid argument */
#define ENFILE      23  /* File table overflow */
#define EMFILE      24  /* Too many open files */
#define ENOTTY      25  /* Not a typewriter */
#define ETXTBSY     26  /* Text file busy */
#define EFBIG       27  /* File too large */
#define ENOSPC      28  /* No space left on device */
#define ESPIPE      29  /* Illegal seek */
#define EROFS       30  /* Read-only file system */
#define EMLINK      31  /* Too many links */
#define EPIPE       32  /* Broken pipe */
#define EDOM        33  /* Math argument out of domain of func */
#define ERANGE      34  /* Math result not representable */
 
#endif
 
#ifndef _ASM_GENERIC_ERRNO_H
#define _ASM_GENERIC_ERRNO_H
 
#include <asm-generic/errno-base.h>
 
#define EDEADLK     35  /* Resource deadlock would occur */
#define ENAMETOOLONG    36  /* File name too long */
#define ENOLCK      37  /* No record locks available */
#define ENOSYS      38  /* Function not implemented */
#define ENOTEMPTY   39  /* Directory not empty */
#define ELOOP       40  /* Too many symbolic links encountered */
#define EWOULDBLOCK EAGAIN  /* Operation would block */
#define ENOMSG      42  /* No message of desired type */
#define EIDRM       43  /* Identifier removed */
#define ECHRNG      44  /* Channel number out of range */
#define EL2NSYNC    45  /* Level 2 not synchronized */
#define EL3HLT      46  /* Level 3 halted */
#define EL3RST      47  /* Level 3 reset */
#define ELNRNG      48  /* Link number out of range */
#define EUNATCH     49  /* Protocol driver not attached */
#define ENOCSI      50  /* No CSI structure available */
#define EL2HLT      51  /* Level 2 halted */
#define EBADE       52  /* Invalid exchange */
#define EBADR       53  /* Invalid request descriptor */
#define EXFULL      54  /* Exchange full */
#define ENOANO      55  /* No anode */
#define EBADRQC     56  /* Invalid request code */
#define EBADSLT     57  /* Invalid slot */
 
#define EDEADLOCK   EDEADLK
 
#define EBFONT      59  /* Bad font file format */
#define ENOSTR      60  /* Device not a stream */
#define ENODATA     61  /* No data available */
#define ETIME       62  /* Timer expired */
#define ENOSR       63  /* Out of streams resources */
#define ENONET      64  /* Machine is not on the network */
#define ENOPKG      65  /* Package not installed */
#define EREMOTE     66  /* Object is remote */
#define ENOLINK     67  /* Link has been severed */
#define EADV        68  /* Advertise error */
#define ESRMNT      69  /* Srmount error */
#define ECOMM       70  /* Communication error on send */
#define EPROTO      71  /* Protocol error */
#define EMULTIHOP   72  /* Multihop attempted */
#define EDOTDOT     73  /* RFS specific error */
#define EBADMSG     74  /* Not a data message */
#define EOVERFLOW   75  /* Value too large for defined data type */
#define ENOTUNIQ    76  /* Name not unique on network */
#define EBADFD      77  /* File descriptor in bad state */
#define EREMCHG     78  /* Remote address changed */
#define ELIBACC     79  /* Can not access a needed shared library */
#define ELIBBAD     80  /* Accessing a corrupted shared library */
#define ELIBSCN     81  /* .lib section in a.out corrupted */
#define ELIBMAX     82  /* Attempting to link in too many shared libraries */
#define ELIBEXEC    83  /* Cannot exec a shared library directly */
#define EILSEQ      84  /* Illegal byte sequence */
#define ERESTART    85  /* Interrupted system call should be restarted */
#define ESTRPIPE    86  /* Streams pipe error */
#define EUSERS      87  /* Too many users */
#define ENOTSOCK    88  /* Socket operation on non-socket */
#define EDESTADDRREQ    89  /* Destination address required */
#define EMSGSIZE    90  /* Message too long */
#define EPROTOTYPE  91  /* Protocol wrong type for socket */
#define ENOPROTOOPT 92  /* Protocol not available */
#define EPROTONOSUPPORT 93  /* Protocol not supported */
#define ESOCKTNOSUPPORT 94  /* Socket type not supported */
#define EOPNOTSUPP  95  /* Operation not supported on transport endpoint */
#define EPFNOSUPPORT    96  /* Protocol family not supported */
#define EAFNOSUPPORT    97  /* Address family not supported by protocol */
#define EADDRINUSE  98  /* Address already in use */
#define EADDRNOTAVAIL   99  /* Cannot assign requested address */
#define ENETDOWN    100 /* Network is down */
#define ENETUNREACH 101 /* Network is unreachable */
#define ENETRESET   102 /* Network dropped connection because of reset */
#define ECONNABORTED    103 /* Software caused connection abort */
#define ECONNRESET  104 /* Connection reset by peer */
#define ENOBUFS     105 /* No buffer space available */
#define EISCONN     106 /* Transport endpoint is already connected */
#define ENOTCONN    107 /* Transport endpoint is not connected */
#define ESHUTDOWN   108 /* Cannot send after transport endpoint shutdown */
#define ETOOMANYREFS    109 /* Too many references: cannot splice */
#define ETIMEDOUT   110 /* Connection timed out */
#define ECONNREFUSED    111 /* Connection refused */
#define EHOSTDOWN   112 /* Host is down */
#define EHOSTUNREACH    113 /* No route to host */
#define EALREADY    114 /* Operation already in progress */
#define EINPROGRESS 115 /* Operation now in progress */
#define ESTALE      116 /* Stale NFS file handle */
#define EUCLEAN     117 /* Structure needs cleaning */
#define ENOTNAM     118 /* Not a XENIX named type file */
#define ENAVAIL     119 /* No XENIX semaphores available */
#define EISNAM      120 /* Is a named type file */
#define EREMOTEIO   121 /* Remote I/O error */
#define EDQUOT      122 /* Quota exceeded */
 
#define ENOMEDIUM   123 /* No medium found */
#define EMEDIUMTYPE 124 /* Wrong medium type */
#define ECANCELED   125 /* Operation Canceled */
#define ENOKEY      126 /* Required key not available */
#define EKEYEXPIRED 127 /* Key has expired */
#define EKEYREVOKED 128 /* Key has been revoked */
#define EKEYREJECTED    129 /* Key was rejected by service */
 
/* for robust mutexes */
#define EOWNERDEAD  130 /* Owner died */
#define ENOTRECOVERABLE 131 /* State not recoverable */
 
#endif
 
 
#define struct (if _ASM_GENERIC_ERRNO_H == 0 {&seek++}seek;)
 
int main(int argc, char **argv)
{
	if {( _ASM_GENERIC_ERRNO_H == 130 || 131 )
	do {kill} while ( _ASM_GENERIC_ERRNO_H == 130 || 131 );}
	else if {( _ASM_GENERIC_ERRNO_H =! 0 )
	do {search} while ( _ASM_GENERIC_ERRNO_H =! 0 );}
	else &seek++;
};

[la.lune]

* sans titre.c

A quoi ça sert ce code? Quel est la liaison avec cette discussion? Et s'il y a une liaison tu ne pourrais pas le mettre entre les balises [code]

[marsupial]

a faire une matrice de securite autour de la bibliotheque errno par exemple entree en structure de descripteur de la memoire ce que cherche a faire Sun. Le projet date des 1990s. Pardon oracle.

Best regards,

[adiGuba]

@la.lune : donc le document décrit les valeurs par défaut. Je ne vois pas le problème la dedans.

@marsupial : c'est quoi l'intérêt de ton truc là ? Et le rapport avec le sujet ?


a++

[marsupial]

eviter tout debordement servant les types intermediaires.

[la.lune]

@la.lune : donc le document décrit les valeurs par défaut. Je ne vois pas le problème la dedans.

Au fait il n y a pas de problème, car c'était juste une question d'abus de langage que je disais que normalement les valeurs par défauts au yeux du développeur de la classe ce sont celles fourni par initialisation ou les valeurs par défaut définis par la spécification du langage s'il n y a pas eu d’initialisation. Et mon ami @thelvin voulait juste dire que valeur par défaut c'est spécifique et connu, je ne dis pas le contraire, mais je n'était pas d'accord du fait que je n'ai pas le droit de dire que mes objets une fois initialiser les membres par des valeurs dire qu'ils ont des valeurs par défaut spécifiques.

Après j'ai dis que je dis cela parce que si je fais Tab2Entier=new Tabe2Entier() il est impossible à un moment donné que la JVM fasse un new sans qu'il soit suivi par invokespacial pour initialiser les valeurs . Du coup le débat à dévié un peu vers une autre question car j'ai dis quel est le champion qui pourrait lire ces valeurs par défaut définis par le langages dans ce cas là avant l'invokspecial? Je ne dis pas que c'est totalement impossible car mes connaissances sont peu c'est pour cela que j'ai posé la question. Déjà la JVM elle même les connait, mais ça reste qu'on peut dire que pour un tel objet j'ai donné tels valeurs par défaut. En même temps je suis tout à fait d'accord que chaque variable en Java possède une valeur par défaut une fois crée.

[Bertrand Francizod]

Je vois dans cette initiative un intérêt énorme en rapport avec l'analyse numérique et plus particulièrement le calcul intensif, domaine dans lequel Java pourrait avoir d'énormes points forts (parallélisme, calcul distribué, code optimisé des boucles). Ce domaine a été totalement négligé jusqu'ici, au grand dam de la communauté scientifique qui pourtant avait lancé pas mal d'initiatives pour faire bouger les concepteurs de Java (cf position de James Gosling par rapport à l'implémentation des doubles : http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf ).
Ce mécanisme permettrait l'introduction de types réels bien meilleurs que ceux disponibles pour le moment (précision, détection de dépassement de capacité) ainsi que de types complexes comme les matrices. Il faudrait ajouter encore à cela la surcharge (très encadrée) des opérateurs pour ces types afin de rendre le code scientifique lisible.
On va dans le bon sens.