Discussion :

[thelvin]

Damn j'avais essayé de le chercher, pourtant. Merci.

[la.lune]

......

Premièrement au début je n'avais pas compris que tu t'interroges sur la valeur par défaut d'une variable de type Value peut prendre une fois crée.
Ce qui fait qu'on tournait sur les mots et on ne se comprenait pas? Sinon moi j'ai bien dis que la variable de type string qui a la valeur null". Tu penses quand je disais que la variable pointe vers null ça veut dire qu'elle est vide ou qu'elle pourrait avoir autre valeur que null? Mais là je confirme bien qu'une valeur par défaut est assigné.

Mais moi quand je parle de valeur par défaut aux yeux du développeur, c'est le fait par exemple si le développeur appel un constructeur sans paramètre à l'instant T on sait que l'instance possèdent ces valeurs une fois crée, alors bien sur qu'il n y a pas de valeur aléatoire en Java, la spécification définit cela, il n'existe pas aussi le vide en programmation, et si il n y avait pas d’initialisation des membres on sait bien sûr ce qu'il y a, mais si on avait initialisé les membres on sait ce qu'il y a une fois l'instance crée, dans tous les deux cas ce qui reste valeur par défaut pour un Objet (pas une variable de type référence) au yeux du développeur c'est ce que l'objet porte une fois crée et aucun affectation n'a eu lieu dans un constructeur ou un setter.

Selon toi quels sont les valeurs par défaut des instances de cette classe, je ne parle pas des variables de type Tab2Entier

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
16
17
18
19
20
21
22
23
24
class Tab2Entier{
private int tab[]=new int[]{-1,-1};
private int val=-2;
 
 
public Tab2Entier() {
    }
public Tab2Entier(int t[],int v) {
        this.tab=t;
        this.val=v;
    }
    public int[] getTab() {
        return tab;
    }
    public void setTab(int[] tab) {
        this.tab = tab;
    }
    public int getVal() {
        return val;
    }
    public void setVal(int val) {
        this.val = val;
    }   
}

[la.lune]

...

Mais là j'ai confondu un peu les choses, alors les variables ne sont pas pas des références vu qu'ils ne sont pas de type référence et ils ne sont pas de type primitive, mais quand j'ai une variable comment je peux la catégoriser en programmation, car moi je les ai confondu aux variables de type références étant aussi conscient qu'ils sont totalement différents mais je pensais comme s'ils auront en partie le même comportement, du coup ça reste encore vague pour moi. J'ai bien compris dans le document que je ne peux pas faire var=null. Seulement sans regarder bien l'introduction de la section que j'ai pris une phrase là, car je n'ai pas eu à lire tout le document, j'ai pris cette phrase en un simple passage comme s'il concerne les Vlues Type même si c'était absurde en réalité

• Null. Null is a valid value of every reference type, meaning “no instance”. But assignment to, and comparison to, null for value types should be disallowed.

Dans un titre là déjà où se trouve cette phrase ils ont dit "Life without pointers" mais est ce que ça veut dire que le problème que j'ai posé là aura lieu, par exemple une méthode

Code :

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

public static  Matrix10x10 calcule(Matrix10x10 m1,Matrix10x10 m2){}

sera-il obliger de faire au moins 3 copies de tous les éléments des matrice de 100 éléments sachant que Matrix10x10 est de type Value , je ne sais pas ou que je ne comprend pas mais ça ça se ne contribue pas aux performances mais à l'explosion sur les performances. Ou bien dans les méthodes on pourra faire des casting vers des références ou je ne sais pas. Mais on a pas de pointeur en Java, et là je ne pige rien...

[adiGuba]

@la.lune : l'idée du type Value ce n'est pas de faire des "gros" type de données, mais de modéliser des types de bases "simples", qui à les encapsuler dans des objets plus complexes (ou des tableaux).

A “soft” restriction on values is that they are “not too large”. Values with tens of components, though legal, are not the design center of this proposal. Since values are passed, well, by value, the overhead of copying many components is increasingly likely to overwhelm any savings obtained by removing the overhead of a pointer and an object header, as the number of components grows. Large groups of component values should usually be modeled as plain classes, since they can be passed around under single pointers.

L'intérêt étant de limiter l'utilisation mémoire et le travail du GC.



Exemple, si tu as un tableau de 100 000 Point :

Code :

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

Point[] points = new Point[100_000];

Si Point est un Object :

• Un objet Point occupera environ entre 16 et 22 octets en mémoire (4 pour chacun des deux int, puis entre 8 et 16 pour l'header de l'objet). Bien sûr cela peut varier selon la JVM...
• Le tableau "points" va comporter 100 000 références de 4 octets soit une utilisation mémoire de 400 000 octets (voir même 800 000 octets selon la JVM en 64bits où les références peuvent occuper 8 octets).
• Lorsque tu affectes un Point dans le tableau (points[0] = new Point(1,2);), la mémoire occupé par le tableau ne va pas changer (tu changes juste la valeur de la référence).
  Par contre tu va créer un objet Point en mémoire dans le heap, en restant sur un objet de 16 octets cela peut occuper jusqu'à 1 600 000 octets si ton tableau comporte des références distinctes.
• Et à chaque nouvelle affectation sur le tableau, tu crées un nouvel objet et tu en libère un nouveau, ce qui donnera du travail au GC.

D'une part la consommation mémoire est importante (400 000 + 1 600 000 soit 2 000 000 octets si le tableau est remplit), mais l'utilisation mémoire peut varier selon les manipulations effectués sur le tableau, car cela implique la création d'objet dans le heap (et donc de donner du travail au GC).



Si Point est un type Value :

• Une value Point occupera juste 8 octets (4 pour chaque int). Il n'y a pas besoin de stocker des informations sur l'header...
• Le tableau de "points" va directement comporter 100 000 valeur "Point" de 8 octets, soit une utilisation de 800 000 octets (quel que soit la JVM).
• Lorsque tu affectes un type value Point dans le tableau (points[0] = __MakeValue Point(1,2);), tu écraseras directement la valeur dans le tableau.
  Aucun nouvel objet ne sera crée en mémoire, donc le GC n'aura aucun travail à faire (si ce n'est à gérer la référence du tableau).
• A chaque nouvelle affectation du tableau, la valeur est modifier directement dans le tableau (pas d'allocation de mémoire).

L'utilisation mémoire est fixe quel que soit le contenu du tableau, et limité au strict minimum (800 000 octets), là où le tableau d'objet peut utiliser 2 fois plus de mémoire.
La manipulation du tableau de type Value n'implique aucune création d'objet dans le heap, et limite donc le travail du GC.


a++

[thelvin]

Mais moi quand je parle de valeur par défaut aux yeux du développeur, c'est le fait par exemple si le développeur appel un constructeur sans paramètre à l'instant T on sait que l'instance possèdent ces valeurs une fois crée,

Oui mais ce qu'il y a c'est que "valeur par défaut," ça veut dire quelque chose de précis. Ça veut pas dire autre chose que ça.

Selon toi quels sont les valeurs par défaut des instances de cette classe, je ne parle pas des variables de type Tab2Entier

Y a pas de selon moi.
tab est un tableau, donc de type objet, donc sa valeur par défaut est null.
Lorsque ce tableau sera instancié, il sera de longueur 2, et contiendra par défaut les valeurs 0 dans tous ses emplacements.
val est de type int, sa valeur par défaut est zéro jusqu'à la première assignation.

[la.lune]

L'intérêt étant de limiter l'utilisation mémoire et le travail du GC.

Merci j'ai bien compris.
Alors si j'ai bien saisis les choses pour ce qui des structures de données là ils se limitent aux tableaux, car on a pas de référence alors comment faire des listes dynamiques. Je ne vois pas la place des Collections ici, que d'emballer les données de type Values dans des Objets, et passer la référence à la collection. Mais là encore revient le problème des Generic sur ces joujoux on aura pas la possibilité de spécifier le type. Déjà j'ai lu un peu à propos des generic là, ça n'enchante pas dutout

Generics over values. It is persistent irritant that generics do not work over primitive types today. With value types, this irritation will increase dramatically; not being able to describe List<Point> would be even worse. Still worse would be having it mean “today’s list, containing boxed points”. Supporting generics over primitives and values, through specialization, is the topic of a separate investigation.

Il faudra qu'en Java on revoit un peu les choses comme C++ et C# qu'on pusse faire des generic sur les types primitives, pour moi java est encore jeune sur ce monde.

@thelvin
Tout ce que tu dis est vrai mais ça reste qu'on a droit de dire que nos objet possèdes des valeur par défaut autres que ce que tu as cité, dans la mesure où 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. Est ce qu'il y a un champion qui peut lire les valeur avant l’instruction 4 de ce bytecode

Code :

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

1
2
3
4
 
0: new           #4                  // class Tab2Entier       
3: dup           
4: invokespecial #5                  // Method Tab2Entier."<init>":()V

[thelvin]

Il y a deux champions en titre :
- Un débuggeur... Mais bon, celui-là à la limite, on n'a pas de raison de s'en inquiéter.
- La magie du réagencement de code et de la mauvaise synchronisation de threads. chose.tab = new Tab2Entier(), si jamais l'objet chose est accessible par plusieurs threads à la fois et que l'accès à sa variable tab est mal synchronisé, il est tout à fait possible que les autres threads voient l'objet tel qu'il est après le new et avant le invokespecial.... Mais les mauvaises synchronisations de thread peuvent potentiellement provoquer tout un tas d'états incohérents de mémoire, et les valeurs par défaut n'y arrangent pas grand-chose.

Donc ma foi, il est vrai que ces deux champions ne justifient pas spécialement le concept de valeur par défaut en Java.
Mais elles existent pour une raison. Prenons un exemple moins arrangeant :

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
16
public class Tab2Entier {
 
	int aFromSub = new Sub().otherA;
	int a = 2;
 
	private class Sub {
		int otherA = a;
	}
 
	public static void main(String[] args) {
		Tab2Entier tab = new Tab2Entier();
		System.out.println("a = " + tab.a);
		System.out.println("aFromSub = " + tab.aFromSub);
	}
 
}

Certes la valeur de a n'a pas été lue avant l'appel d'invokespecial, elle a été lue pendant l'exécution de <init>, avant que <init> l'ait initialisée.

Alors certes, ce code n'est pas du tout une bonne pratique. Et il est bien normal qu'à première vue un développeur hésite, ou se trompe, sur la valeur que devrait avoir aFromSub.
Mais du point de vue de Java, cette valeur est parfaitement définie et prédictible. Et cela vient du fait de la valeur par défaut de a, qui est zéro puisque c'est un int.

[la.lune]

Il y a deux champions en titre :
- Un débuggeur... Mais bon, celui-là à la limite, on n'a pas de raison de s'en inquiéter.

Explique moi comment avec un debugger je peux faire un breakpoint en dissociant entre l'appel de new et l'invokspecial de <init>, pour que je pusse voir les valeurs non celles initialisés?

- La magie du réagencement de code et de la mauvaise synchronisation de threads. chose.tab = new Tab2Entier(), si jamais l'objet chose est accessible par plusieurs threads à la fois et que l'accès à sa variable tab est mal synchronisé, il est tout à fait possible que les autres threads voient l'objet tel qu'il est après le new et avant le invokespecial....

Impossible!!!! La JVM doit finir son instruction avant d'affecter quoi que se soit.
Comment si je fais chose.tab = new Tab2Entier() tab peut avoir des valeurs par défaut de Tab2Entier autre que les valeur initiales que j'ai initialisé par défaut?
Tu penses que que la JVM est aussi foule de vouloir affecter quelque chose à tab alors qu'il n a même pas fini avec new Tab2Entier() si tu me dis qu'en mémoire il peut exister des objets de type Tab2Entier avec des valeurs par défaut avant initialisation et que des instructions ont eu lieu avant l'invokspecial oui je comprendrais. Mais tab de chose gardera toujours une référence vers un objet complet avant qu'il change. Nous avons dans l'exemple précédant:

Code :

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

1
2
public static void main(String[] args) {
     Tab2Entier tab1=new Tab2Entier();

j'ai le byecode suivant:

Code :

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

1
2
3
4
5
6
7
 public static void main(java.lang.String[]);    Code:
       0: new           #4                  // class Tab2Entier
       3: dup           
       4: invokespecial #5                  // Method Tab2Entier."<init>":()V
       7: astore_1      
       8: return        
}

Montre moi un seul cas en Java qu'un invokspecial peut venir après un astore, alors que cette affectation a besoin de la nouvelle instance . Ainsi quelque soit le thread où la variable chose se trouve et qui a besoin d'une nouvelle instance de Tab2Entier, alors invokspécial finira son job avant que l'objet reçoit la nouvelle instance, que l’opération d'instanciation soit interrompu par un autre thread avant l'invokspecial cela ne veut pas dire qu'une affectation aura lieu avant la fin. Le défi est de lire ces valeurs et les afficher avant affectation des valeurs par défaut que j'ai fourni.

Pour le dernier cas que tu as donné avec l'exemple

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
public class Tab2Entier { 
    int aFromSub = new Sub().otherA;
    int a = 2;
 
    private class Sub {
        int otherA = a;
    }
 
    public static void main(String[] args) {
        Tab2Entier tab = new Tab2Entier();
        System.out.println("a = " + tab.a);
        System.out.println("aFromSub = " + tab.aFromSub);
    }
 
}

Il faut comprendre d'abord que c'est logique à ce qu'on affiche 0 tab.aFromSub, car tout se passe par l'ordre des instructions. Il ne faut pas penser que si je dis de faire

Code :

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

1
2
3
4
class Tab2Entier{
private int tab[]=new int[]{-1,-1};
private int val=-2;
//.....

que cela est différent de

Code :

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

1
2
3
4
5
6
7
8
class Tab2Entier{
public int tab[];
public int val;
public Tab2Entier() {
    tab=new int[]{-1,-1};
    val=-2;
    }
}

C'est la même chose, et la JVM fait exactement la même chose dans les deux cas, car toutes les initialisations se font après invokspecial alors ce que tu fais c'est tout simplement:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class Tab2Entier{
 
public int aFromSub;
public int a;
 
 
public Tab2Entier() {
    aFromSub=a;
    a=2;
}
}

Que ce qui est bizarre dans le comportement de aFromSub? Alors que tu lui affecte la valeur par défaut avant que a soit initialisé. Pour moi la valeur par défaut de aFromSub c'est 0 qui est la valeur initiale d'un int

[adiGuba]

@la.lune : Concernant les Generics le document indique clairement le problème, mais également que cela concerne une étude distincte.
Bref la résolution de cela passera par une étude sur les Generics, et non pas dans le document sur les type Value...



Toutefois la solution mise en place par les Generics dans Java 5.0 est loin d'être mauvaise.
Et si elle ne supporte pas les primitifs, elle apportent également son lots d'avantages (pas de duplication de code, covariance/contravariance efficace, retrocompatibilité).







Sinon il y a déjà des valeurs par défaut pour les primitives et les références, donc il est logique que ce soit la même chose pour les type-valeurs.
Je ne vois pas le problème là dedans...


Et pas la peine d'aller chercher midi à quatorze heure, il suffit de ne pas initialiser le champs pour qu'il prennent une valeur par défaut :

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
16
class DefaultValue {
	private int intValue;
	private boolean booleanValue;
	private Object referenceValue;
 
	public int getIntValue() {
		return intValue;
	}
 
	public Object getReferenceValue() {
		return referenceValue;
	}
	public boolean getBooleanValue() {
		return booleanValue;
	}
}

Sinon il est quand même possible d'accéder à la valeur d'un attribut avant son initialisation, par exemple lorsqu'on utilise l'héritage et des méthodes virtuelles dans le constructeur :

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Parent {
	public Parent() {
		printAll();
	}
	protected void printAll() {
 
	}
}
 
class Child extends Parent {
	private final int monInt;
	private final boolean alwaysTrue;
	private final double pi;
	private final String hello;
	private final Date date;
 
	public Child() {
		 this.monInt = 356;
		 this.alwaysTrue = true;
		 this.pi = Math.PI;
		 this.hello = "Hello World";
		 this.date = new Date();
	}
 
	protected void printAll() {
		System.out.println("monInt = " + this.monInt);
		System.out.println("alwaysTrue = " + this.alwaysTrue);
		System.out.println("pi = " + this.pi);
		System.out.println("hello = " + this.hello);
		System.out.println("date = " + this.date);
	}
}

Bien sûr c'est crade et il ne faut pas le faire !




a++

[la.lune]

Sinon il y a déjà des valeurs par défaut pour les primitives et les références, donc il est logique que ce soit la même chose pour les type-valeurs.
Je ne vois pas le problème là dedans...

Je n'ai pas refusé qu'il y a des valeurs par défaut et j'ai dis que la spécification de Java défini cela, mais je disais que pour une instance donnée une fois j'ai initialisé les membres je peux dire que les valeur par défaut de mes Objet sont tels. Et je me disais qui pourrait lire autre que ce que j'ai initialisé et fourni par défaut. Comme dans ton exemple il suffit de faire comme ça pour ne pas voir ces valeurs par défauts une fois qu'on instancie un Child()

Code :

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

1
2
3
4
5
6
7
class Child extends Parent {    
    private final int monInt= 356;
    private final boolean alwaysTrue=true;
    private final double pi=Math.PI;
    private final String hello="Hello World";
    private final Date date=new Date();
//...........

Déjà je me dis que si c'était pour afficher les valeur par défaut, il suffit de les faire dans le constructeur avant initialisation. Dans l'exemple j'ai compris que comme le constructeur de la classe mère est appelé avant tout instruction dans le constructeur de la classe fille, alors je ne vois pas la différence entre cela et ceci avec une seule classe.

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
16
17
18
19
class Child {	private final int monInt;
	private final boolean alwaysTrue;
	private final double pi;
	private final String hello;
	private final Date date;
 
	public Child() {
                 System.out.println("monInt = " + this.monInt);
		 System.out.println("alwaysTrue = " + this.alwaysTrue);
		 System.out.println("pi = " + this.pi);
		 System.out.println("hello = " + this.hello);
		 System.out.println("date = " + this.date);
		 this.monInt = 356;
		 this.alwaysTrue = true;
		 this.pi = Math.PI;
		 this.hello = "Hello World";
		 this.date = new Date();
	}
}

[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.

[adiGuba]

Désolé mais je ne vois toujours pas l'intérêt du code, ni son rapport avec le sujet...


a++

[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.

[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 ?

[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