Discussion :

[el_slapper]

70% de mon boulot entre 2001 et 2013 a été en COBOL. ça tourne comme du papier à musique dans sa niche : les batches comptables et assimilés. Évidemment, dès qu'on s'éloigne de la niche, c'est complètement dépassé. Mais, dans sa niche, je n'ai souffert de ses limites qu'une seule fois, pour un algorithme pseudo-ensembliste. L'absence de gestion dynamique de la mémoire et de collections m'a fait pondre une horreur inmaintenable de 1200 lignes au lieu des 250 que j'aurais utilisées avec des collections et des fonctions simples(en objet, je ne sais pas, c'est bavard, l'objet - mais ça aurait au moins été plus lisible).

De la bonne came, bien spécialisée, très fiable, très performante, et qui en plus est accessible à des gens qui n'ont pas forcément l'agilité intellectuelle nécessaire pour faire du C#, et qui néanmoins font des codes de production maintenables et performants en COBOL dans un délai raisonnable. Pas étonnant que les banquiers ne veulent pas le lâcher, malgré ses évidentes lacunes.

[Invité]

Ok

tu ne le feras ni ne l'expliqueras simplement qu'avec des move et des add.

C'est ce genre de défi que je pratique tous les jours x)

[crodilus]

Je suis étonné que personne ne parle d'un vieux dinosaure de chez IBM ... Le RPG/CL Regarder moi cette beautée :



On doit respecter le collonage (sauf si on utilise le format libre (ça le rend encore plus sale ))

Petite info en passant, je n'ai pas la cinquantaine, juste 24 ans et je fais ça depuis un an full time

Je retourne faire de l'archéologie

PS : C#,Java,PHP,Javascript ... Vous me manquez

[el_slapper]

Je suis étonné que personne ne parle d'un vieux dinosaure de chez IBM ... Le RPG/CL Regarder moi cette beauté (.../...)

J'en ai fait un peu. En 2004. C'est très bien, très puissant pour l'accès aux données, la lecture de fichiers ou de bases de données. Dans certains cas, c'est même plus maintenable que le SQL - qui certes est plus puissant, mais quand on commence à faire des trucs de fou, ça devient illisible. C'est, euh, à vomir pour tout le reste. Comme je faisais des modules de garnissage de données, ça allait, je ne me suis pas tapé la tête contre les murs. Mais si j'avais eu à faire ne serait-ce qu'un peu d'algorithmique, je pense que ça m'aurait blasé. Et je suis tolérant.

[Max Lothaire]

Je suis étonné que personne ne parle d'un vieux dinosaure de chez IBM ... Le RPG/CL Regarder moi cette beautée :



On doit respecter le collonage (sauf si on utilise le format libre (ça le rend encore plus sale ))

Petite info en passant, je n'ai pas la cinquantaine, juste 24 ans et je fais ça depuis un an full time

Je retourne faire de l'archéologie

PS : C#,Java,PHP,Javascript ... Vous me manquez

Juste pour savoir : il fait quoi ce code là ?

[Théolude]

Dans cette liste il me semble ne pas avoir vu le langage RPG, qui mérite sa place quand même pas son aspect dinosauresque !!

[Théolude]

Je suis étonné que personne ne parle d'un vieux dinosaure de chez IBM ... Le RPG/CL Regarder moi cette beautée :



On doit respecter le collonage (sauf si on utilise le format libre (ça le rend encore plus sale ))

Petite info en passant, je n'ai pas la cinquantaine, juste 24 ans et je fais ça depuis un an full time

Je retourne faire de l'archéologie

PS : C#,Java,PHP,Javascript ... Vous me manquez

Mes condoléances !!
Quel est le nom de ton tortionnaire ??? Qui t'oblige encore à travailler avec des silex ???

[Tr0n33]

Ok



C'est ce genre de défi que je pratique tous les jours x)

Ca se fait (heureusement d'ailleurs !). Mais quand je vois que l'écrasante majorité des développeurs est incapable de définir la division par un décalage de bits, j'ai peur. Et quand ils le font, ils ne savent plus vraiment pourquoi. C'est problématique car en réalité, les langages de haut niveau, ont toujours des optimisations possibles notamment lorsqu'on a la connaissance mathématique complète.

Mais bon, si on va par là, l'assembleur, c'est has been en comparaison de ce que faisait Turing. Bref, quand je vois des développeurs qui ne connaissent pas les notions d'ensemble finis d'état, d'états acceptant, de transition qui permettent justement de construire une tête de lecture, une table d'action, ou un registre d'état, c'est problématique.

Allez juste pour la route : Machine de Turing en lego. Bon ok, il faut 368 ans pour faire un calcul d'une seconde sur un téléphone portable. Mais vraiment, les "macro langages" dont tu parles font des optimisations et établissent des constructions issus de modèles mathématiques fondamentaux. Une fois qu'on a compris la machine de Turing, on peut passer à de l'assembleur et ainsi de suite. L'apprentissage par palier est intéressant et j'en parlais l'autre jour dans les langages nécessaires à l'apprentissage. Chaque langage est fondé sur un ou plusieurs concepts, ils sont donc généralement tous intéressant et à ne pas négligé pour comprendre les problématiques qui ont mené à certaines évolutions. Sinon, si nous ne sommes pas curieux de tout cela, le paradigme mathématique informatique risque d'être figé et donc de ne produire que de l'assistance.

Le gain des langages n'est pas uniquement une forme d'artillerie lourde, il est conceptuellement démontré pour l'usage de nouveaux outils mathématiques. Bon certes, en informatique de gestion...

[Invité]

À t'entendre parler, on dirait que tu penses que c'est infaisable de faire des programmes en pur asm: http://menuetos.net/ - https://github.com/ReturnInfinity/BareMetal-OS - http://kolibrios.org/en/- https://sourceforge.net/projects/shaynoxhackos/- https://sourceforge.net/projects/hackengine/ - https://gitlab.com/glauxosdever/glaux-os

Cela demande plus de ressources en temps et en personnel, mais c'est faisable. (encore heureux)

Mais quand je vois que l'écrasante majorité des développeurs est incapable de définir la division par un décalage de bits, j'ai peur.

Hmm, perso je fais un vdivss et cela me suffit, ce genre de tours de passe passe sert juste pour des machines virtuelles pour cibler 100% des processeur qui n'ont pas forcément de div et/ou par curiosité.
Mais quand tu as des extensions d'instruction comme l'avx sur proc intel, je vais pas m'en priver de les utiliser x)

Et je n'ai jamais vu de compilateurs faire du shr/shl pour faire du div/mul, mais bon il faut aussi prendre en compte que cela ne marche que pour des diviseurs/facteurs de multiples de 2, sinon il faut faire des tests (cmp) pour gérer les cas "spéciaux".

C'est problématique car en réalité, les langages de haut niveau, ont toujours des optimisations possibles notamment lorsqu'on a la connaissance mathématique complète.

Pour sûr, délaisser la plus grosse partie intellectuelle servant à l'élaboration technique de précision pour un programme/compilateur (débat sur l'IA ), c'est plus facile de ne se concentrer que sur le but final du programme.

Quoique l'intellectuel servi dans la construction du but principal d'un programme soit par moments limités et des fois complexifiés, par le langage employé.

Je n’aime pas trop le ton que tu prends sur le low level ^^

[crodilus]

Juste pour savoir : il fait quoi ce code là ?

Il lit les 1000 premiers enregistrements du fichier TESTFILE qui ont comme clé composée "ATSALOT" et "1" et écrit dans le fichier NEWFILE quelque chose haha

Mes condoléances !!
Quel est le nom de ton tortionnaire ??? Qui t'oblige encore à travailler avec des silex ???

Chuuuut ça je ne peux pas le dire sinon

[Tr0n33]

À t'entendre parler, on dirait que tu penses que c'est infaisable de faire des programmes en pur asm: http://menuetos.net/ - https://github.com/ReturnInfinity/BareMetal-OS - http://kolibrios.org/en/- https://sourceforge.net/projects/shaynoxhackos/- https://sourceforge.net/projects/hackengine/ - https://gitlab.com/glauxosdever/glaux-os

Cela demande plus de ressources en temps et en personnel, mais c'est faisable. (encore heureux)



Hmm, perso je fais un vdivss et cela me suffit, ce genre de tours de passe passe sert juste pour des machines virtuelles pour cibler 100% des processeur qui n'ont pas forcément de div et/ou par curiosité.
Mais quand tu as des extensions d'instruction comme l'avx sur proc intel, je vais pas m'en priver de les utiliser x)

Et je n'ai jamais vu de compilateurs faire du shr/shl pour faire du div/mul, mais bon il faut aussi prendre en compte que cela ne marche que pour des diviseurs/facteurs de multiples de 2, sinon il faut faire des tests (cmp) pour gérer les cas "spéciaux".



Pour sûr, délaisser la plus grosse partie intellectuelle servant à l'élaboration technique de précision pour un programme/compilateur (débat sur l'IA ), c'est plus facile de ne se concentrer que sur le but final du programme.

Quoique l'intellectuel servi dans la construction du but principal d'un programme soit par moments limités et des fois complexifiés, par le langage employé.

Je n’aime pas trop le ton que tu prends sur le low level ^^

Oh si ce n'est qu'une question de ton ça m'ira alors .

Prenons l'outil ou le langage très simple : la géométrie d'Euclide. Pythagore est un théorème qui se démontre facilement.
Prenons l'outils ou le langage un peu plus évolué : les vecteurs. Pythagore est un théorème toujours valide et démontrable avec les projections.
Prenons la géodéisque de Riemann, très avancé. Pythagore existe toujours avec ds² = dx² + dy².

Et bien c'est exactement la même chose entre l'ASM, le C et le C++. C'est exactement la même chose sur lesquels nous avons greffé des concepts et des outillages mathématiques supplémentaires. Je ne critique pas du tout le bas niveau, j'ai même une nette tendance à adorer car c'est le fondement nécessaire à la compréhension du reste. D'où mon affirmation : les langages anciens, historiquement, montrent cette évolution des concepts et sont donc des mines d'or (à distinguer comme il a été dit des langages fait purement pour de la gestion par exemple).

Le langage doit donc comme tu le dis : complexifier toujours, mais rarement limiter. S'il limite c'est par un principe annexe de "besoin".

Sinon je suis quand même allé jeter un oeil aux liens que tu as mis. J'ai beaucoup aimé celui de BareMetal et je pense que je vais me faire une petite soirée lecture de code. Je suis assez curieux de voir comment ils ont géré les problématiques de temps partagé, la parallélisation et toutes les problématiques de niveau conceptuel actuel (pas juste la pagination ou les entrées sorties claviers). A priori, ils indiquent que c'est fait via une pile de gestion des processeurs. Pour les autres liens, notamment glaux-os, ça reste très "basique".

[Invité]

^^

Et kolibriOS aussi est cool (en GUI), par contre c'est du fasm et qu'en 32-bits.

Prenons l'outil ou le langage très simple : la géométrie d'Euclide. Pythagore est un théorème qui se démontre facilement.
Prenons l'outils ou le langage un peu plus évolué : les vecteurs. Pythagore est un théorème toujours valide et démontrable avec les projections.
Prenons la géodéisque de Riemann, très avancé. Pythagore existe toujours avec ds² = dx² + dy²

Oui c'est sûr, cela serras toujours gênant de transformer une équation/algorithme mathématique en asm, car il faut en même temps gérer les registres et l'équation (avec des lettres c'est plus simple ^^), mais comment dire, le fait que l'on aie cette "contrainte" ne nous détourne pas du faite qu'avant tout la programmation est l'art de dire à une machine ce qu'elle doit faire dans les moindres détails.

Et donc pas seulement d'effectuer un calcule ... c'est très complexe comme idée pour sûr, cet art de dire au proc de faire telles ou telles choses, être lié à cette machine, permet d'être toujours terre-à-terre :p
Enfin bref, c'est plus un sentiment qui découle de ce langage qu'autre chose, c'est ... religieux

Mais pour en revenir au but principal, de calculer l'équation, après une bonne dose de travail, on arrive à faire ce genre de chose, en plusieurs jours parfois (oui oui c'est buvable (quand on connait l'asm )):

2-manage_object.asm:

Code asm :

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
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
 
;==========================================================================================================================================================================================================
; FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION      FUNCTION
;==========================================================================================================================================================================================================
[section .code]
;{
        ;=============================================================================================.
        ; move_coordinate                                                                             |
        ;=============================================================================================.
       ;{
            vbroadcastf128      ymm1, [rbx + OBJ3D_COORD]
 
            vaddps          ymm0, ymm1, [rsi]
            vmovups         [rdi], ymm0
 
            vaddps          ymm0, ymm1, [rsi + _3x]
            vmovups         [rdi + _3x], ymm0
 
            vaddps          ymm0, ymm1, [rsi + _5x]
            vmovups         [rdi + _5x], ymm0
 
            vaddps          ymm0, ymm1, [rsi + _7x]
            vmovups         [rdi + _7x], ymm0
       ;}
        ;=============================================================================================.
        ; / move_coordinate                                                                           |
        ;=============================================================================================.
 
        ;============================================================================================================================================================================================.
        ; apply_rotations:                                                                                                                                                                           |
        ; Apply XYZ rotations of all those points : |[rdi + _1x]                                                                                                                                     |
        ;                                           |[rdi + _1y]                                                                                                                                     |
        ;                                           |[rdi + _1z]                                                                                                                                     |
        ;                                           |[rdi + _1color]    .Unmodified                                                                                                                  |
        ;                                           |[rdi + _2x]                                                                                                                                     |
        ;                                           |[rdi + _2y]                                                                                                                                     |
        ;                                           |[rdi + _2z]                                                                                                                                     |
        ;                                           |[rdi + _2color]    .Unmodified                                                                                                                  |
        ;                                           |[rdi + _3x]                                                                                                                                     |
        ;                                           |[rdi + _3y]                                                                                                                                     |
        ;                                           |[rdi + _3z]                                                                                                                                     |
        ;                                           |[rdi + _3color]    .Unmodified                                                                                                                  |
        ;                                           |[rdi + _4x]                                                                                                                                     |
        ;                                           |[rdi + _4y]                                                                                                                                     |
        ;                                           |[rdi + _4z]                                                                                                                                     |
        ;                                           |[rdi + _4color]    .Unmodified                                                                                                                  |
        ;                                           |[rdi + _5x]                                                                                                                                     |
        ;                                           |[rdi + _5y]                                                                                                                                     |
        ;                                           |[rdi + _5z]                                                                                                                                     |
        ;                                           |[rdi + _5color]    .Unmodified                                                                                                                  |
        ;                                           |[rdi + _6x]                                                                                                                                     |
        ;                                           |[rdi + _6y]                                                                                                                                     |
        ;                                           |[rdi + _6z]                                                                                                                                     |
        ;                                           |[rdi + _6color]    .Unmodified                                                                                                                  |
        ;                                           |[rdi + _7x]                                                                                                                                     |
        ;                                           |[rdi + _7y]                                                                                                                                     |
        ;                                           |[rdi + _7z]                                                                                                                                     |
        ;                                           |[rdi + _7color]    .Unmodified                                                                                                                  |
        ;                                           |[rdi + _8x]                                                                                                                                     |
        ;                                           |[rdi + _8y]                                                                                                                                     |
        ;                                           |[rdi + _8z]                                                                                                                                     |
        ;                                           |[rdi + _8color]    .Unmodified                                                                                                                  |
        ;============================================================================================================================================================================================.
       ;{
            ; Prepare data
                vbroadcastss_   {ymm0, [temp2 +       + _1x]}, {ymm1, [temp2 +       + _1y]}, {ymm2, [temp2 +       + _1z]}
                vbroadcastss_   {ymm3, [temp2 + _2xmm + _1x]}, {ymm4, [temp2 + _2xmm + _1y]}, {ymm5, [temp2 + _2xmm + _1z]}
 
                m2m     [.tmp_x +  0], [rdi + _1x], eax
                m2m     [.tmp_x +  4], [rdi + _2x], eax
                m2m     [.tmp_x +  8], [rdi + _3x], eax
                m2m     [.tmp_x + 12], [rdi + _4x], eax
                m2m     [.tmp_x + 16], [rdi + _5x], eax
                m2m     [.tmp_x + 20], [rdi + _6x], eax
                m2m     [.tmp_x + 24], [rdi + _7x], eax
                m2m     [.tmp_x + 28], [rdi + _8x], eax
 
                m2m     [.tmp_y +  0], [rdi + _1y], eax
                m2m     [.tmp_y +  4], [rdi + _2y], eax
                m2m     [.tmp_y +  8], [rdi + _3y], eax
                m2m     [.tmp_y + 12], [rdi + _4y], eax
                m2m     [.tmp_y + 16], [rdi + _5y], eax
                m2m     [.tmp_y + 20], [rdi + _6y], eax
                m2m     [.tmp_y + 24], [rdi + _7y], eax
                m2m     [.tmp_y + 28], [rdi + _8y], eax
 
                m2m     [.tmp_z +  0], [rdi + _1z], eax
                m2m     [.tmp_z +  4], [rdi + _2z], eax
                m2m     [.tmp_z +  8], [rdi + _3z], eax
                m2m     [.tmp_z + 12], [rdi + _4z], eax
                m2m     [.tmp_z + 16], [rdi + _5z], eax
                m2m     [.tmp_z + 20], [rdi + _6z], eax
                m2m     [.tmp_z + 24], [rdi + _7z], eax
                m2m     [.tmp_z + 28], [rdi + _8z], eax
 
            ;=============
            ; pitch
            ;=============
           ;{
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                        X-axe                                                                           ;;
                    ;;                                                      ymm8                   ymm9              ymm10                                                    ;;
                    ;;    new.1x =                                  (1x * cos_y * cos_z) - (1y * cos_y * sin_z) - (1z * sin_y)                                                ;; 1
                    ;;    new.2x =                                  (2x * cos_y * cos_z) - (2y * cos_y * sin_z) - (2z * sin_y)                                                ;; 2
                    ;;    new.3x =                                  (3x * cos_y * cos_z) - (3y * cos_y * sin_z) - (3z * sin_y)                                                ;; 3
                    ;;    new.4x =                                  (4x * cos_y * cos_z) - (4y * cos_y * sin_z) - (4z * sin_y)                                                ;; 4
                    ;;    new.5x =                                  (5x * cos_y * cos_z) - (5y * cos_y * sin_z) - (5z * sin_y)                                                ;; 5
                    ;;    new.6x =                                  (6x * cos_y * cos_z) - (6y * cos_y * sin_z) - (6z * sin_y)                                                ;; 6
                    ;;    new.7x =                                  (7x * cos_y * cos_z) - (7y * cos_y * sin_z) - (7z * sin_y)                                                ;; 7
                    ;;    new.8x =                                  (8x * cos_y * cos_z) - (8y * cos_y * sin_z) - (8z * sin_y)                                                ;; 8
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                   ;{
                        ; ymm0 = cos_x    ymm3 = sin_x
                        ; ymm1 = cos_y    ymm4 = sin_y
                        ; ymm2 = cos_z    ymm5 = sin_z
 
                        ; ymm6 = (1x * cos_y * cos_z)
                            vmulps      ymm6, ymm1, ymm2
                            vmulps      ymm6, ymm6, [.tmp_x]
 
                        ; ymm7 = (1y * cos_y * sin_z)
                            vmulps      ymm7, ymm1, ymm5
                            vmulps      ymm7, ymm7, [.tmp_y]
 
                        vmulps      ymm8, ymm4, [.tmp_z]        ; ymm8 = (1z * sin_y)
                        vsubps      ymm6, ymm6, ymm7
                        vsubps      ymm6, ymm6, ymm8
 
                        vmovups     [temp], ymm6
                        ; Store new X
                            m2m     [rdi + _1x], [temp +  0], eax
                            m2m     [rdi + _2x], [temp +  4], eax
                            m2m     [rdi + _3x], [temp +  8], eax
                            m2m     [rdi + _4x], [temp + 12], eax
                            m2m     [rdi + _5x], [temp + 16], eax
                            m2m     [rdi + _6x], [temp + 20], eax
                            m2m     [rdi + _7x], [temp + 24], eax
                            m2m     [rdi + _8x], [temp + 28], eax
                   ;}
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                         /X-axe                                                                         ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
           ;}
            ;=============
            ; / pitch
            ;=============
 
            ;=============
            ; yaw
            ;=============
           ;{
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                        Y-axe                                                                           ;;
                    ;;                                    ymm9                                                 ymm10                                ymm11                     ;;
                    ;;    new.1y = (1x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (1y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (1z * sin_x * cos_y)             ;; 1
                    ;;    new.2y = (2x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (2y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (2z * sin_x * cos_y)             ;; 2
                    ;;    new.3y = (3x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (3y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (3z * sin_x * cos_y)             ;; 3
                    ;;    new.4y = (4x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (4y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (4z * sin_x * cos_y)             ;; 4
                    ;;    new.5y = (5x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (5y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (5z * sin_x * cos_y)             ;; 5
                    ;;    new.6y = (6x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (6y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (6z * sin_x * cos_y)             ;; 6
                    ;;    new.7y = (7x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (7y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (7z * sin_x * cos_y)             ;; 7
                    ;;    new.8y = (8x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z))) + (8y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z))) - (8z * sin_x * cos_y)             ;; 8
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                   ;{
                        ; ymm0 = cos_x    ymm3 = sin_x
                        ; ymm1 = cos_y    ymm4 = sin_y
                        ; ymm2 = cos_z    ymm5 = sin_z
 
                        ;                     ymm9                 ymm11
                        ; ymm9 = (1x * ((cos_x * sin_z) - (sin_x * sin_y * cos_z)))
                            vmulps      ymm9, ymm0, ymm5            ; ymm9 = (cos_x * sin_z)
 
                            ; ymm11 = (sin_x * sin_y * cos_z)
                                vmulps      ymm10, ymm3, ymm4       ; ymm10 = (sin_x * sin_y)
                                vmulps      ymm11, ymm10, ymm2      ; ymm11 = (ymm10 * cos_z)
 
                            vsubps      ymm9, ymm9, ymm11
                            vmulps      ymm9, ymm9, [.tmp_x]
 
                        ;                        ymm11                  ymm12
                        ; ymm10 = (1y * ((sin_x * sin_y * sin_z) + (cos_x * cos_z)))
                            vmulps      ymm11, ymm10, ymm5      ; ymm11 = (ymm10 * sin_z)
                            vmulps      ymm12, ymm0, ymm2       ; ymm12 = (cos_x * cos_z)
                            vaddps      ymm11, ymm11, ymm12
 
                            vmulps      ymm10, ymm11, [.tmp_y]
 
                        ; ymm11 = (1z * sin_x * cos_y)
                            vmulps      ymm11, ymm3, ymm1
                            vmulps      ymm11, ymm11, [.tmp_z]
 
                        vaddps      ymm9, ymm9, ymm10
                        vsubps      ymm9, ymm9, ymm11
 
                        vmovups     [temp], ymm9
                        ; Store new Y
                            m2m     [rdi + _1y], [temp +  0], eax
                            m2m     [rdi + _2y], [temp +  4], eax
                            m2m     [rdi + _3y], [temp +  8], eax
                            m2m     [rdi + _4y], [temp + 12], eax
                            m2m     [rdi + _5y], [temp + 16], eax
                            m2m     [rdi + _6y], [temp + 20], eax
                            m2m     [rdi + _7y], [temp + 24], eax
                            m2m     [rdi + _8y], [temp + 28], eax
                   ;}
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                         /Y-axe                                                                         ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
           ;}
            ;=============
            ; / yaw
            ;=============
 
            ;=============
            ; roll
            ;=============
           ;{
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                        Z-axe                                                                           ;;
                    ;;                                    ymm9                                                 ymm10                                ymm11                     ;;
                    ;;    new.1z = (1x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (1y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (1z * cos_x * cos_y)             ;; 1
                    ;;    new.2z = (2x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (2y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (2z * cos_x * cos_y)             ;; 2
                    ;;    new.3z = (3x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (3y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (3z * cos_x * cos_y)             ;; 3
                    ;;    new.4z = (4x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (4y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (4z * cos_x * cos_y)             ;; 4
                    ;;    new.5z = (1x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (5y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (5z * cos_x * cos_y)             ;; 5
                    ;;    new.6z = (2x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (6y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (6z * cos_x * cos_y)             ;; 6
                    ;;    new.7z = (3x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (7y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (7z * cos_x * cos_y)             ;; 7
                    ;;    new.8z = (4x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z))) + (8y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z))) + (8z * cos_x * cos_y)             ;; 8
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                   ;{
                        ; ymm0 = cos_x    ymm3 = sin_x
                        ; ymm1 = cos_y    ymm4 = sin_y
                        ; ymm2 = cos_z    ymm5 = sin_z
 
                        ;                        ymm9                   ymm11
                        ; ymm9 = (1x * ((cos_x * sin_y * cos_z) + (sin_x * sin_z)))
                            ; ymm9 = (cos_x * sin_y * cos_z)
                                vmulps      ymm10, ymm0, ymm4       ; ymm10 = (cos_x * sin_y)
                                vmulps      ymm9, ymm10, ymm2       ; ymm9  = (ymm10 * cos_z)
 
                            vmulps      ymm11, ymm3, ymm5           ; ymm11 = (sin_x * sin_z)
                            vaddps      ymm9, ymm9, ymm11
                            vmulps      ymm9, ymm9, [.tmp_x]
 
                        ;                     ymm11                  ymm10
                        ; ymm10 = (1y * ((sin_x * cos_z) - (cos_x * sin_y * sin_z)))
                            vmulps      ymm11, ymm3, ymm2           ; ymm11 = (sin_x * cos_z)
                            vmulps      ymm10, ymm10, ymm5          ; ymm10 = (ymm10 * sin_z)
                            vsubps      ymm10, ymm11, ymm10
                            vmulps      ymm10, ymm10, [.tmp_y]
 
                        ; ymm11 = (1z * cos_x * cos_y)
                            vmulps      ymm11, ymm0, ymm1
                            vmulps      ymm11, ymm11, [.tmp_z]
                            vaddps      ymm9, ymm9, ymm10
                            vaddps      ymm9, ymm9, ymm11
 
                        vmovups     [temp], ymm9
                        ; Store new Z
                            m2m     [rdi + _1z], [temp +  0], eax
                            m2m     [rdi + _2z], [temp +  4], eax
                            m2m     [rdi + _3z], [temp +  8], eax
                            m2m     [rdi + _4z], [temp + 12], eax
                            m2m     [rdi + _5z], [temp + 16], eax
                            m2m     [rdi + _6z], [temp + 20], eax
                            m2m     [rdi + _7z], [temp + 24], eax
                            m2m     [rdi + _8z], [temp + 28], eax
                   ;}
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                         /Z-axe                                                                         ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;                                                                                                                                                        ;;
                    ;;--------------------------------------------------------------------------------------------------------------------------------------------------------;;
                    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
           ;}
            ;=============
            ; / roll
            ;=============
       ;}
        ;============================================================================================================================================================================================.
        ; / apply_rotation                                                                                                                                                                           |
        ;============================================================================================================================================================================================.
 
        ;=============================================================================================.
        ; move_coordinate_system                                                                      |
        ;=============================================================================================.
       ;{
            vbroadcastf128      ymm1, [rbx + OBJ3D_COORDSYS]
 
            vaddps          ymm0, ymm1, [rdi]
            vmovups         [rdi], ymm0
 
            vaddps          ymm0, ymm1, [rdi + _3x]
            vmovups         [rdi + _3x], ymm0
 
            vaddps          ymm0, ymm1, [rdi + _5x]
            vmovups         [rdi + _5x], ymm0
 
            vaddps          ymm0, ymm1, [rdi + _7x]
            vmovups         [rdi + _7x], ymm0
       ;}
        ;=============================================================================================.
        ; / move_coordinate_system                                                                    |
        ;=============================================================================================.
;}
;==========================================================================================================================================================================================================
; END_FUNCTION      END_FUNCTION      END_FUNCTION      END_FUNCTION      END_FUNCTION      END_FUNCTION      END_FUNCTION      END_FUNCTION      END_FUNCTION      END_FUNCTION      END_FUNCTION
;==========================================================================================================================================================================================================

Le langage doit donc comme tu le dis : complexifier toujours, mais rarement limiter. S'il limite, c'est par un principe annexe de "besoin".

C'est certain, mais le problème c'est ce switch que l'on doit faire si on a un autre "besoin", résultat ta tête est bourrée des trentaines de termes informatiques/programmation pour quel résultat ? le même (asm ) avec un mal de crâne en prime.

Enfin je parle pas des techniques d'algorithmes de memory management et du design du code pondu après la compilation, avec les arbres, structure et tout le tralala, car à mon sens je préfère un bon vieux tableau 1D et des labels et je t'en fais ce que je veux ^^

Certes ces algo sont à la fois complexe et intéressent (enfin je ne les ai pas tous utilisés lorsque je programmais en C) et que je te fasse des pointeurs à la chaine, ect que ça en devient imbuvable lors de l'analyse de l'asm pondu par le compilo.
Bon ce n'est pas que je remette en cause ces techniques de programmation, mais moi et mon bon vieux tableau 1D, je me sens plus libre que si j'utilisais toutes les techniques connues (enfin de ce que j'en connais), mais bon de ce que j'en ai lu, cela ne me donne pas trop envie de les tester.

Pour les autres liens, notamment glaux-os, ça reste très "basique".

glauxOS est en cours de développent sur irc freenode #osdev x)
HackOS aussi, mais pas tant que je n'aurais pas réglé le problème de ma caméra sur HackEngine et savoir init un mode flat en x64, même si à priori, il est dit dans la doc intel que c'est impossible -_-
MenuetOS l'est aussi, ils ont mis à jour leur OS récemment.

[djmic]

Je suis un peu comme Crodilus. 29 ans, dressé à coup de C, C#, Java, etc... et celà fait maintenant 5 années que je développe en PLI.

Je n'ai pas à m'en plaindre. je le trouve d'une très grande simplicité, assez complet pour faire tout ce dont on a besoin.

et il évolue encore à l'heure actuelle.

[crodilus]

Je suis un peu comme Crodilus. 29 ans, dressé à coup de C, C#, Java, etc... et celà fait maintenant 5 années que je développe en PLI.

Je n'ai pas à m'en plaindre. je le trouve d'une très grande simplicité, assez complet pour faire tout ce dont on a besoin.

et il évolue encore à l'heure actuelle.

Les langages récents ne te manque pas ? !

Ce que je reproche au RPG c'est son colonage, la doc imbuvable de chez IBM et aucun IDE digne de ce nom. Pour le CL, qui equivaut au bash sous linux, la ils n'ont pas imposé le colonage... Aller donc chercher pourquoi ? !

Le PL/1 m'a quand même l'air bien moins imbuvable au niveau syntaxe que le RPG

[Tr0n33]

Pour te répondre Shaynox, on pourrait aller encore plus loin dans ton raisonnement et jouer avec les bits pour gérer le signal

En réalité, l'infrastructure technique est "censée" évoluer en même temps que les formes de langage. D'ailleurs je ne connais pas du tout l'évolution matériel, mais un processeur est censé fournir de nouvelles fonctions et ne pas forcément se cantonner à celles de base. L'asm évolue-t-il en traitant de nouvelles instructions qui sont ni plus ni moins que des macro des autres ? On pourrait techniquement faire des opérations totalement non atomiques au processeur de manière matériel ? Simple question. Je ne connais pas trop les dernières révolutions en terme technique mais les processeurs ou les composants électroniques sont aussi censés évoluer

[Invité]

Euh j'ai du mal à te suivre là

Pour te répondre Shaynox, on pourrait aller encore plus loin dans ton raisonnement et jouer avec les bits pour gérer le signal

Pourquoi ? comme dirait cryprien, l'asm me suffit, comme toi et ton langage de haut niveau.

En réalité, l'infrastructure technique est "censée" évoluer en même temps que les formes de langage. D'ailleurs je ne connais pas du tout l'évolution matériel, mais un processeur est censé fournir de nouvelles fonctions et ne pas forcément se cantonner à celles de base

https://software.intel.com/en-us/isa...ions/intel-avx (https://en.wikipedia.org/wiki/Intel_Tick-Tock)
http://www.intel.com/content/www/us/...r-manuals.html (dernière maj en avril 2015)

L'asm évolue-t-il en traitant de nouvelles instructions qui sont ni plus ni moins que des macro des autres

Ah tu parles des features de tes compilateurs, qui ne sont au final tout traduits en asm, donc si ta logique suit, ce sont aussi des macros: http://forum.nasm.us/index.php?topic=2076.msg9426#new (certes je n'ai pas des macros aussi évoluées que les compilateurs, mais je peux te prouver clairement que ce n'est que de la poudre aux yeux ce que vos compile ont a offrir, suffit juste d'avoir http://forum.nasm.us/index.php?topic=2122.0 et c'est dans la poche)

On pourrait techniquement faire des opérations totalement non atomiques au processeur de manière matériel ? Simple question. Je ne connais pas trop les dernières révolutions en terme technique mais les processeurs ou les composants électroniques sont aussi censés évoluer

Ok, alors promet moi de ne jamais être tenté d'upgrade tes programmes avec les nouvelles instructions que ton compilateur peut gérer et tant que t'y es go migrer au DOS-16 bit, qui pour le coup utilise réellement de simples instructions 16-bit, enfin tu peux pousser encore plus loin avec Linux sur archi risc

Et tu recommences à être méprisant sur ce langage (tous les deux messages ), en tout cas, cela me fait plaisir que ça en énerve certains qu'un programmeur utilise l'asm et essaye à tout prix de lui faire changer d'avis (cela me rend nostalgique de la période où plein de trolls essayaient à tout prix de me mettre des bâtons dans les roues, pendant que j'apprenais)

Au plus vous me détestez et au plus je serais immortel

(Si tu as l'impression que je me répète, c'est tout à fait normal, car apparemment tu n'as pas encore saisi ces vérités "dérangeantes" pour quelqu'un qui fait du high level.)

[maske]

Pourquoi ? comme dirait cryprien, l'asm me suffit, comme toi et ton langage de haut niveau.

C'est ton raisonnement qui est mis en défaut par un peu d'ironie, puisque tu dis «le haut niveau ce sont des couches en trop, on peut tout faire en assembleur», on peut pousser encore plus loin en disant «bah on a qu'à tout faire en binaire directement !». Par contre - mais ça on a compris - tu pourrais juste dire «moi je kiffe l'assembleur c'est de la balle, alors je fais tout avec» ce qui est moins irréaliste.

Et tu recommences a être méprisant sur ce langage, en tout cas, cela me fait plaisir que ça en énerve certains qu'un programmeur utilise l'asm et essaye à tout prix de me faire changer d'avis (divertissant)
Au plus vous me détestez et au plus je serais immortel

Je crois qu'en fait il te posait vraiment une question...

[Invité]

C'est bien ce que je disais

C'est ton raisonnement qui est mis en défaut par un peu d'ironie, puisque tu dis «le haut niveau ce sont des couches en trop, on peut tout faire en assembleur», on peut pousser encore plus loin en disant «bah on a qu'à tout faire en binaire directement !». Par contre - mais ça on a compris - tu pourrais juste dire «moi je kiffe l'assembleur c'est de la balle, alors je fais tout avec» ce qui est moins irréaliste.

Hmm, oui et ? désolé je ne vois vraiment pas pourquoi je te ferais le plaisir de laisser tomber l'assembleur pour faire de l'opcode directement, étant donné que les opcodes ne sont que des traductions directes des instructions assembleur (c'est un peu comme si j'essayais de parler avec une personne qui a deux langages, je vais choisir celle que je préfère, mais ces deux langages sont similaires en terme de mot et de def) ....


Enfin si vous avez d'autres arguments que ceux qui sont inlassablement répétés depuis des années, allez-y, ne vous gênez pas, parce que cela devient un peu lassant à devoir toujours lire les mêmes arguments alors que j'en ai accumulé des tonnes depuis ma formation, sur tous les points de vue, mais que vous refusez de les voir, enfin de les comprendre surtout.


Et comme je l'ai dit, comment peut-on encore répéter ces mêmes arguments, alors qu'on a jamais pondu une seul ligne de code asm et ni fait de vrais projets avec.

Quelle est la différence entre moi et vous ?
J'étais en haut et je suis descendu en bas, vous, vous êtes toujours resté en haut (un peu comme les politiciens )


Si vos arguments ne sont que mépris, alors les miens aussi, let's deal with it


Vous voulez savoir pourquoi il existe une guerre entre programmeurs avec les langages comme idéologie ? Voilà un bon exemple du pourquoi dans cette discussion.

[Tr0n33]

Effectivement, je posais vraiment une question d'ordre technique sur l'évolution de l'asm, le lien entre les composants techniques et les nouvelles fonctionnalités requises en ASM. Je voulais en venir au fait que le matériel évolue en fonction du besoin (quand on se sert de Pythagore chez Euclide jeune, on ne s'en sert que rarement après car on a besoin d'outils différents, pour des problématiques de plus haut niveau). Je ne vois pas d'ailleurs où j'ai été méprisant. D'autres parts ce n'est pas "mon" langage de haut niveau (tu as souvent tendance à dire ça ^^), je me fiche pas mal du langage et j'ai toujours défendu l'apprentissage sous forme historique pour comprendre l'ensemble de l'évolution des concepts. Rien ne me dérange dans l'ASM puisque j'en fais de temps en temps, par simple passion pour l'informatique (ou pour des besoins de cartes à puces et domotique chez moi - ça reste très rare mais parfois...).

Par exemple j'utilisais de l'ASM quand je voulais programmer un micro-controlleur PIC. Là, par exemple, la petite station météo que j'ai faite utilise un Arduino et un Raspberry Pi et envoie les informations sur un site raffraichit automatiquement. J'ai donc du Python pour causer au Raspberry, du C pour causer à l'Arduino, de l'AJAX et du JS pour le site en PHP (si j'avais eu du temps je l'aurais sans doute fait en RoR pour m'entraîner). Bref, j'ai utilisé plusieurs langages fonction des abstractions nécessaires. Tout dépend du besoin. Je ne défends pas l'idée que l'ASM c'est nul ou pourri, je défends l'idée d'utiliser en fonction des concepts, un langage adapté; et qu'il est intéressant d'user des anciens langages pour comprendre l'ensemble des abstractions utilisées.

C'est tout. Ma question était donc sur le matériel. Celui ci évolue, les spec changent comme tu le montres et de nouvelles fonctions sont ajoutées. De ce que je constate ce sont des optimisations techniques, des propositions pour éviter à un système d'exploitation de devoir traiter certains éléments.

Euh j'ai du mal à te suivre là

Pour te répondre Shaynox, on pourrait aller encore plus loin dans ton raisonnement et jouer avec les bits pour gérer le signal
Pourquoi ? comme dirait cryprien, l'asm me suffit, comme toi et ton langage de haut niveau.

J'ai pris un raccourci. Mon langage de haut niveau ne me suffit justement pas ! J'ai besoin d'une palette de langage pour répondre à des problématiques diverses. Si j'ai une routine (drivers) à écrire je le ferais sans doute en ASM. Si j'ai une application pour gérer des données de trading, je n'utiliserais certainement pas l'ASM. Dans les jeux d'instruction d'un code assembleur pour un processeur donné, tu as forcément (je ne sais pas hein) des macro, des "sur"instructions pour faciliter ta vie. Tu dois même avoir avec l'évolution des architectures des éléments de traitement de langages de haut niveau qui sont inclus dans les instructions non ? Par exemple, j'avais lu il y a quelques temps que les architectures ARM (processeur RISC) ne possédaient pas l'instruction JMP. On peut donc considérer que cette instruction est une forme de macro et donc un élément de plus haut niveau. Ainsi de suite. Il me semblait aussi avoir vu des éléments de contrôles de flux et des macro de type if/then/else.

Il n'y a donc aucune critique sous jacente à la pratique de l'ASM. On peut tout faire en ASM, oui. Mais on peut aussi tout faire en C. Peu importe. Je ne suis pas justement des idéologues qui sont défenseurs d'un langage, que ce soit de bas niveau ou de haut niveau. Je suis défenseur de ceux qui répondent à cette question : "A quoi sert l'informatique ?" par "A assister l'Homme". J'utilise donc tous les concepts que j'apprends ou j'ai appris, en fonction des besoins. L'informatique est un outil, les langages sont des clefs de 4, 6, 8 ou 12. J'utilise donc celle qui est utile. Il n'y a pas vraiment de débat, je demandais surtout si l'ASM avec l'évolution des processeurs n'intégrait justement pas de nouveaux concepts. That's all.

[maske]

Hmm, oui et ? désolé je ne vois vraiment pas pourquoi je te ferais le plaisir de laisser tomber l'assembleur pour faire de l'opcode directement, étant donné que les opcodes ne sont que des traductions directes des instructions assembleur (c'est un peu comme si j'essayais de parler avec une personne qui a deux langages, je vais choisir celle que je préfère, mais ces deux langages sont similaires en terme de mot et de def) ....

Ah mais tu sais pas lire en fait ? Personne ne veut que tu abandonnes l'assembleur ! À vrai dire tout le monde s'en fout du langage que toi ou moi on utilise. Tu essaies de justifier le fait que tu te cantonnes à l'assembleur en jetant l'opprobre sur les langages de plus haut niveau et avec des attaques ad nominem sur les gens qui les utilisent (sur la connaissance de l'asm, sur leur aveuglement sur le sujet à cause du haut niveau...) alors qu'en fait tu tiens une position philosophique en considérant que le temps et la complexité technique directe ne sont pas facteurs déterminants dans tes projets et que tu aimes l'asm et en soi c'est parfaitement légitime.

Si vos arguments ne sont que mépris, alors les miens aussi, let's deal with it
Vous voulez savoir pourquoi il existe une guerre entre programmeurs avec les langages comme idéologie ? Voilà un bon exemple du pourquoi dans cette discussion.

Beh non, personne de sérieux ne méprise l'asm en soi, et on est plutôt dans le consensus à par toi et comme tu vas pas comprendre, ça veut dire que je veux dire que c'est toi qui tente de nourrir des tensions sur les langages alors que dans l'absolu - en tous cas moi - je ne suis pas forcément en désaccord avec ton choix sur l'asm.