Mmmh, si le compilateur est capable d'inférer tout seul les types ou les champs qui devraient être initialisés sans que l'utilisateur ait quoi que ce soit à faire, je ne vois pas où est le problème (je ne parle pas d'un langage en particulier).
Le truc, c'est que ce qui te semble simple, voire évident, dans le code que tu as montré se transforme en code spaghetti à force de rajouter une condition par-ci ou une autre par-là. C'est ce que je voulais dire par « laisser le compilateur briller là où il le peut ». Un exemple tout bête: une multiplication de matrice.
Le code original (naïf et tout):
void matmul(const size_t m, const size_t n, const size_t k,
const double alpha, const double *a, const double *b,
const double beta, double *c)
{
for (size_t i = 0; i < m; ++i)
for (size_t j = 0; j < n; ++j)
for (size_t l = 0; l < k; ++l)
c[i*n+j] = beta * c[i*n+j] + alpha * a[i*k+l] * b[l*n+j];
}
Bon, tu peux t'embêter à faire tout un tas d'optimisations super intelligentes (et connues depuis 30 ans), du genre promotion scalaire, inversion de boucles, et tuilage, etc., ce qui pourrait donner un truc du genre :
void matmul(const size_t m, const size_t n, const size_t k,
const double alpha, const double *a, const double *b,
const double beta, double *c)
{
for (size_t i = 0; i < m; ii += TILE_I)
for (size_t l = 0; l < k; l += TILE_L)
for (size_t j = 0; j < n; j += TILE_J)
for (size_t ii = i; ii < MAX(i+TILE_I,m); ++ii)
for (size_t jj = j; jj < MAX(j+TILE_J,n); ++jj) {
acc = c[ii*n+jj] * beta;
for (size_t ll = l; l < MAX(l+TILE_L,k); ++ll) {
acc = c[ii*n+jj] + alpha * a[ii*k+ll] * b[ll*n+jj];
}
c[ii*n+jj] = acc;
}
}
Bon, je ne dis même pas que ce code est optimal (il est loin de l'être). Un bon exemple concernant ce genre de transformations se trouve ici : http://www.spinellis.g/blog/20090420/
Cependant, si je te dis que y'a toute une théorie qui existe déjà concernant les nids de boucle, et que ce genre d'optimisation peut-être faite par le compilateur sans que tu aies à lever le petit doigt, tu seras content non ? Ben le typage fort permet justement ce genre d'optimisations (enfin pas le tuilage, mais d'autres transformations/simplifications de code). Du coup quand je te vois faire ce que tu fais en JS (ou je ne sais quel autre langage), en rajoutant condition après condition et en disant « facile ! » en fonction de ce qu'on te dit que le compilateur sait déjà faire, je tique un peu. :)
[^] # Re: typage mou
Posté par lasher . En réponse à la dépêche Quelques nouvelles de Go, le langage de programmation. Évalué à 5.
Le truc, c'est que ce qui te semble simple, voire évident, dans le code que tu as montré se transforme en code spaghetti à force de rajouter une condition par-ci ou une autre par-là. C'est ce que je voulais dire par « laisser le compilateur briller là où il le peut ». Un exemple tout bête: une multiplication de matrice.
Le code original (naïf et tout):
void matmul(const size_t m, const size_t n, const size_t k,
const double alpha, const double *a, const double *b,
const double beta, double *c)
{
for (size_t i = 0; i < m; ++i)
for (size_t j = 0; j < n; ++j)
for (size_t l = 0; l < k; ++l)
c[i*n+j] = beta * c[i*n+j] + alpha * a[i*k+l] * b[l*n+j];
}
Bon, tu peux t'embêter à faire tout un tas d'optimisations super intelligentes (et connues depuis 30 ans), du genre promotion scalaire, inversion de boucles, et tuilage, etc., ce qui pourrait donner un truc du genre :
void matmul(const size_t m, const size_t n, const size_t k,
const double alpha, const double *a, const double *b,
const double beta, double *c)
{
for (size_t i = 0; i < m; ii += TILE_I)
for (size_t l = 0; l < k; l += TILE_L)
for (size_t j = 0; j < n; j += TILE_J)
for (size_t ii = i; ii < MAX(i+TILE_I,m); ++ii)
for (size_t jj = j; jj < MAX(j+TILE_J,n); ++jj) {
acc = c[ii*n+jj] * beta;
for (size_t ll = l; l < MAX(l+TILE_L,k); ++ll) {
acc = c[ii*n+jj] + alpha * a[ii*k+ll] * b[ll*n+jj];
}
c[ii*n+jj] = acc;
}
}
Bon, je ne dis même pas que ce code est optimal (il est loin de l'être). Un bon exemple concernant ce genre de transformations se trouve ici : http://www.spinellis.g/blog/20090420/
Cependant, si je te dis que y'a toute une théorie qui existe déjà concernant les nids de boucle, et que ce genre d'optimisation peut-être faite par le compilateur sans que tu aies à lever le petit doigt, tu seras content non ? Ben le typage fort permet justement ce genre d'optimisations (enfin pas le tuilage, mais d'autres transformations/simplifications de code). Du coup quand je te vois faire ce que tu fais en JS (ou je ne sais quel autre langage), en rajoutant condition après condition et en disant « facile ! » en fonction de ce qu'on te dit que le compilateur sait déjà faire, je tique un peu. :)