CrEv a écrit 4577 commentaires

> Moi je personnalise, mais pas ma sœur par exemple. Pourtant, sous gnome c'est très simple.

Vu le nombre d'options et de possibilités de gnome, c'est un peu logique qu'il soit simple à personnaliser ...

justement, si on pouvais éviter, dans une vidéo du genre, les amalgames qui ne font rien avancer...
Après libre à chacun de faire une vidéo pour vanter les mérites d'ubuntu...

idem quand je lis le deuxième point :
> Inspirer les spectateurs à essayer Linux

On va voir tout plein de fenêtres volantes toutes molles, d'aquarium 3d en fond d'écran, etc ... que des trucs qu'on vire au bout de 30s (pour ceux qui l'ont installé...)

Je vois ce que tu veux dire.

Mais je vois en fait le langage (et sa complexité surtout) comme un investissement.
Si apprendre un langage un peu plus complexe, et donc "perdre" du temps dessus, me permet, à chaque fois que j'en aurai besoin, de me simplifier la vie, de simplifier mon code, sa compréhension, etc, alors j'estime que ça en vaut la peine.

Comme je dis de temps en temps, il faut savoir (apprendre ...) à perdre du temps maintenant pour en gagner plus tard.

Et c'est pour ça que j'aime les langages assez expressifs (je sais pas si c'est le bon terme) qui ne sont pas pauvres en mot clés (mais qui restent compréhensibles)

> Et c'est ce qui me donne envie de regarder vers ruby ... mais son coté Perl me fait peur ...

En fait moi c'est presque l'inverse.
j'adore ruby parce qu'il est puissant, expressif mais n'a pas les travers de perl tout en reprenant ses bons côté (les unless, les regexp, etc) et des trucs hyper sympa comme pouvoir mettre des "?" et "!" à la fin des noms de méthodes.

Je trouve les programmes ruby assez propre (même si on peut faire du crade hein...) plus lisible que perl.


Je viens de lire qq news sur python et dans le genre pas facile à comprendre par exemple :
5 // 10

si qqn qui n'a jamais utilisé ça se trouve devant, je suis pas sur que ce soit compréhensible directement (histoire de division entière, etc)

attend, là je comprend pu rien du tout

Si la classe mère est celle contenant le minmax, c'est quoi ma classe fille ?
Evidemment si je colle minmax dans ma classe mère alors la classe fille est simple, mais ça ne correspond plus du tout à l'exemple dont je parle _depuis le début_


question subsidiaire : pourquoi ne pas faire, juste un peu, abstraction de minmax etc pour juste tenter de comprendre l'exemple ?
Je demande pas comment me passer d'un minmax, comment optimiser ce cas hyper précis puisque c'est un _exemple_

ra mais c'est pas vrai ça

Non c'est vrai !

> la classe mère qui gère le flag
non, c'est la classe fille !

> quand c'est bien fait, le truc que tu racontes est simplement et purement faux
ben non, si c'était bien fait on aurait pas à faire toutes ces conneries de java


Allez on reprend pour ceux du fond qui ne suivent pas.

disclaimer : ceci est un exemple, pour comprendre, qu'on me sorte pas des conneries de collection ou autre c'est pour expliquer un principe, une logique, non pour écrire un exemple réel (j'suis pas sur que tout le monde ait compris ça déjà...)

Imaginons une classe de tableau : (ha oui, j'écris ni en ruby, ni en java, ni en js, etc c'est juste pour comprendre sans s'en soucier, et oui j'ai pas mis de test, de validation, etc on s'en branle)

class Array

  def get index
    return data_au_bon_index
  end

  def set index, value
    data_au_bon_index = value
  end
end


Maintenant j'ai deux classes utilisant ceci, en rajoutant des besoins spécifiques et non nécessaires à tous (oui les noms sont pourris je m'en fou aussi c'est un exemple) :

class ArrayWithExtraFunctionnality1 < Array
  def plop
    [...]
  end
end

class ArrayWithMinMax <Array
  def getMinMax
  end
end


Version sympa :

class ArrayWithMinMax < Array
  def getMinMax
    [...]
    return min, max
  end
end


Version "java"

class ArrayWithMinMax < Array
  boolean internalStateModified = false

  def getMin
    if internalStateModified
      computeMinMax
    end

    return min
  end

  def getMax
    if internalStateModified
      computeMinMax
    end

    return max
  end

  def set index, value
    internalStateModified = true

    super.set(index, value)
  end
end


Maintenant je veux rajouter la méthode concat dans ma classe mère car je sais qu'elle sera utilisée par _toutes_ les classes filles :


class Array
  [...]

  def concat otherArray
    [...]
  end
end


Avec la solution simple ... ben je change rien, je peux l'utiliser
Avec la solution "java" :

class ArrayWithMinMax < Array
  [...]

  def concat otherArray
    internalStateModified = true

    super.concat otherArray
  end
end


Il faut donc que je maintienne ma classe fille quand je rajoute des choses dans la classe mère.

Ha oui, je veux pas que mon "internalStateModified" soit dans la classe mère, je veux juste rajouter un getMinMax qui est utile que pour ce cas précis.

En gros, comment proposer une architecture complexe juste pour rajouter le calcul et le retour de deux valeurs simultanément...

dites les gars, vous comprenez le sens "d'exemple" ? ;-)

je sort un exemple de regexp et tout de suite on sort un cas particulier de java (ou d'un autre langage ça change rien)

Mais si j'avais écrit ça :

var parsed = /^ACTION=(\w+)!IDGEO=(\w+)&USER=(\w+)!([0-9]+)$/.exec(query);
if(parsed) {
  var [, action, id, user, userid] = parsed;
  [...]
}

comme exemple, ça aurait été moins intéressant...

Et en java tu ferais quoi ?
Une regexp ? (tout de suite c'est lourd)
Des splits comme on voit souvent ? (beurk !!)

> crade sur le long terme et de pas evolutif pour un sou

faut voir, j'ai plutôt tendancer à penser qu'un code simple _immédiatement_ est justement plus facile à faire évoluer car il est beaucoup moins complexe à comprendre et moins source de problème.

Mais combien de programmes sont inutilement compliqués derrière des "mais si dans x années qqn code un truc non voulu, non prévu et si il le fait pas exactement comme il faut, ne respecte pas les conventions, etc" ?
C'est bien de vouloir prévoir les cas, mais combien ne se produiront _jamais_ alors que ça aura complexifié le code ?

sinon, pour le getMinMax ecart type toussa, j'ai pas vu la solution (pourtant si chère aux programmeurs java) je prend eclipse refactor toussa et hop rulez ! le fait que j'ai utilisé ailleurs ou non mon minmax est automatiquemnt trouvé / modifié / etc

> Quand a l'appel surcharge a add() sur la collection, je me gausse, on parle de setter un booleen la, une ligne de code, une petite affectation toute simple, si t'es rendu a ce niveau d'optimisation, elle est belle ta vie

Là je pense que t'as pas du saisir ce que je disais. Je n'ai rien contre le fait de rajouter un booléen mais contre le fait de devoir surcharger _toutes_ les méthodes de modification de ma classe.
Si je rajoute une méthode de modification dans ma classe mère alors il _faut_ que je la surcharge dans ma classe fille.
Et toi qui parle de maintenance / évolutivité à qq années, c'est bien pire que de savoir comment je pourrai un jour rajouté un écart type
C'est typiquement le genre de chose qui sera oublié et là l'intégralité des résultats de mon getMinMax sera faux et pour comprendre d'où ça vient rapidement...

ok

> Ca on le sait mais 2 int ca ne fait pas un type abstrait de données

Mais je ne veux pas un type abstrait, je veux que ma fonction retourne plusieurs valeurs.

Mais bon, faut croire que c'est si sympa de créer tout un bordel pour ça...

typedef int min;
c'est bon là ?

non mais c'est bien rigolo votre truc, mais si tu écris une fonction getMax qui s'appuie sur un tableau tu va créer un type pour ça ou retourner un entier (si je n'ai qu'un tableau d'entier) ?

M'enfin, tout ça pour ce qui est à la base un exemple, juste des contraintes prises comme ça pour expliquer que ça peut servir, mais ça fout tellement les boules aux codeurs java que ça en devient ridicule.

- Bonjour je voudrais calculer simultanément et retourner le min et le max d'un tableau d'entier.
- Ok, tu fais une classe interne, un observer, deux ou trois ko de code et ça roule. autre chose ?
A oui, on pourrait faire plus simple mais tu vois c'est pas drole, on se ferai chier, c'est pas bien, c'est une erreur, c'est toi qui sait pas, c'est pas propre, c'est trop compliqué pour un neuneu (rayer les mentions inutiles)

> 2 variables en sortie non typée

ra mais c'est pas vrai, vous le faites exprès ?

Un retour de fonction en java est bien typé, non ?
Donc si on permet d'avoir plusieurs valeurs de retour, pourquoi ça deviendrait non typé par magie ?
Pourquoi ne pas imaginer :
public int min, int max getMinMax()
?

Et après, franchement pour sortir un min et un max en même temps s'il faut sortir une sous classe, une interface spécifique, coller un observer, etc ... ben en fait je comprend de plus en plus le journal de Ploum... http://linuxfr.org/~ploum/27723.html

> Ben si, puisque c'est ce qui ressemble le plus à un langage ....naturel:
> L'anglais.

Ha bon ?

Je te conseil de lire ce qu'écrit Larry Wall (le créateur de perl) à propos de perl 5, des langages (ça se trouve dans un bouquin sur perl, chez oreilly) ça te surprendra surement sur la création de perl.
A noter aussi que Larry Wall est à la base un linguiste.

Mais je sais pas si c'est possible en python, mais écrire quelque chose de proche du langage naturel en perl et ruby c'est extrêmement simple :


print line if line.include? "plop"

Affiche la ligne si la ligne contient "plop"

Comment écrire ça plus simplement ?

Mais l'avantage est qu'on peut aussi écrire l'inverse très facilement et toujours de manière très compréhensible :

print line unless line.include? "plop"


C'est beaucoup plus logique que "if !line.include? "plop"" ou "if not line.[...]"

Et si certains ne comprennent pas au premier abord, ben à part leur faire apprendre le mot unless on peut pas faire grand chose je trouve.

Et bon, le coup de python c'est proche du langage naturel... mouaif, faut voir hein ...

Allez, une abération que j'ai jamais supporté dans python :
pourquoi se trimbaler "self" dans la définition d'une méthode d'un objet ?
Ok, explicit better gnia gnia gnia
Le programme / les développeurs sont trop con pour savoir qu'une méthode qui se trouve dans la définition d'un objet est lié à un objet ?
Ca pue surtout le modèle objet un peu foiré ça...

(tout n'est probablement pas parfait en ruby, mais de là à mettre python comme le sauveur...)

ha, je me suis dit le contraire vu qu'un peu plus haut thedude donnait la même solution (mais sans la détailler) :
utilisation de private computeMinMax http://linuxfr.org/comments1000491.html#1000491

oups

s/ / /g

> Non tu fais simplement

Non mais sérieux, c'est pas quelque chose de simple ton truc.
C'est inutilement compliqué ça

Surtout que cette solution oblige aussi à redéfinir _toutes_ les méthodes d'accès (en écriture, push, etc) du tableau.

Imaginons que je veuille rajouter mon getMinMax à une classe de tableau. Je vais faire une nouvelle classe héritant de mon tableau.

Avec ma solution je défini _une_ méthode qui fait ce que je veux -> le code est clair, très compréhensible, concis mais pas inutilement, très facile à maintenir.

Si j'utilise cette solution je commence par définir _trois_ méthodes (recalculMinMax, getMin, getMax) et je surcharge _toutes_ les autres méthodes modifiant l'objet pour changer mon booléen de modification.
Le code est lourd, complexe, chiant, inutilement long, plus compliqué à maintenir.

Et si j'ajoute une fonctionnalité dans ma classe mère :
- avec ma solution celle ci est dispo tout de suite dans ma classe fille, sans modifier une ligne de code
- avec la solution "java" ... ça dépend. Si cette méthode est une méthode d'accès, alors ça roule. Si par contre c'est une méthode de modification ... ben soit je l'utilise telle quelle et mon getMin / getMax est foutu, soit il faut que je la resurcharge dans ma classe fille.
Ca devient très vite le bordel et on est justement dans un cas où le système se casse la gueule en maintenance, car une autre personne que celle qui a écrit le premier code va rajouter la fonctionnalité dans la classe mère et ne comprendra jamais pourquoi son getMin / getMax est devenu tout pourri et ne renvoi pas les bonnes valeurs.



ps : pour tous ceux qui veulent include du code dans un commentaire :
s/ / /g et ça roule !

> c fun/hype de faire du ruby, du erlang, du <ton language préféré> ...
mais imagine la cata si chaque personne utilisait un language différent

Donc il ne faut pas utiliser python non plus !


> la syntaxe est une chose, et si elles se ressemblent inter-languages, c'est quand même aussi dans le but de simplifier l'appréhension du language nouveau.

Mais c'est bien ça le problème, on peut aussi appeler ça un nivellement par le bas. Et non, un langage ça _doit_ s'apprendre.
Il faut savoir perdre du temps (à apprendre) pour devenir plus performant, pour faire des choses plus puissantes et donc gagner du temps sur du moyen terme...

> je ressort mon argument qui va très bien là également

Ben en fait non, je trouve pas vraiment que ce soit un bon argument...

(et pour les tests, outils, etc ça va par exemple être des lancement automatiques sur build / commit donc je les lance pas à la main, manquerait plus que ça...)

> faut toujours penser à celui qui reprendra ton code, ou à toi, avec qques bieres dans le nez.
faut être le plus clair possible, ça paye vraiment avec le temps

Déjà dans mon taff j'évite vraiment de coder avec de la bière, et si c'est le cas et que je comprend pas mon code, je crois qu'il faut plus en vouloir à la bière qu'au code...

Et faire de l'implicite n'empêche absolument pas de faire clair.
Allez, juste pour le fun :
faire de l'explicite inutile (sous pretexte que c'est "better") complexifie inutilement le code et tend à le rendre moins clair.
Moins il y a de parasitage dans le code, plus le code est clair et compréhensible.

mouais, j'aurais tendance à dire que c'est justement la réponse d'un codeur java ;-)

Si j'ai des données qui sont un tableau d'entier (juste un tableau, pas autre chose, pas de liste, pas de hash, etc) ça fout un bordél énorme juste pour un min max...
Et ça ne corrige toujours pas le fait que getMin va parcourir mon tableau et getMax aussi alors que c'est totalement idiot

Et le coup du max,min qui devient min,max...
Quel est la différence entre la déclaration de valeur(s) de retour et la déclaration des paramètres ?
Et en l'occurence j'aurais tendance à penser que getMinMax retourne min, max et getMaxMin retourne max, min

> une immondice pareille dans le langage
> tres crade

Etrange, c'est justement ce que pense beaucoup de programmeurs java...

Pour l'histoire de langage objet, etc c'était surtout pour présenter un exemple simple. D'ailleurs mon getMinMax est par exemple une méthode de classe.

Mais dans un programme ou, sur mon tableau, jamais je n'utiliserai min sans max (voyons ça comme des limites) pourquoi je devrais utiliser deux méthodes différentes ?
C'est là qu'on a un comportement illogique et consommateur de resources.
Ou alors je sais pas, je fais un myArray.calculateMinMax() suivit de myArray.getMin() et myArray.getMax() ? Là ça pue !


Pour ce qui est de faire de l'objet pur, etc, voir le modèle objet de ruby, il est assez bien foutu, va beaucoup plus loin que celui de java entre autre.

Décidément c'est dur à faire comprendre (ou alors je m'exprime pas bien.. ?)

> L'implicite necessite que la personne, ou toi, re-devine ce que tu voulais dire/faire "en codant ainsi"

Implicite ne veut pas dire de supprimer tout ce qui est possible hein.
On peut avoir aussi bien de l'"explicite" et de l'"implicite" dans un même programme.

Après faut juste coder intelligemment...

Permettre d'utiliser l'implicite ne veut pas dire tout supprimer. Si vous ne voulez pas coder proprement, c'est pas le langage qui empêchera de faire de la merde.

Mais si quelque chose est _évident_ (que ce soit au moment où on l'écrit, au moment où on le lit, même plus tard) pourquoi l'écrire ?

Utiliser de l'implicite ne veut pas dire ne pas documenter, supprimer tout ce qui traine et faire du code idiot hein !


> Mais, dans la vraie vie, sous la pression, sous le stress, sous les contraintes, et pour aller vite ... tu zappes les règles et tu peux faire d'énormes raccourcis (pk le language le permet), qui te couteront plus tard.

C'est bien pour ça qu'il existe des outils pour contraindre, des outils de vérification de syntaxe par exemple (éviter par exemple qu'il existe des blocs sans accolades)


> il fallait "trop apprendre", par rapport à des choses plus classiques ("formatté au c/c++/java").

Ben voilà le vrai problème, refuser des avancées parce qu'il faut apprendre...

pour la première partie, c'est exactement ce que je pense (sauf que je me suis trompé de version...) qu'ils ont pas la volonté suffisante d'améliorer le langage.

Pour la deuxième partie je suis moins d'accord.
Le "problème" est qu'on nous a toujours appris qu'une fonction doit retourner 0 ou 1 objet. Mais pourquoi donc ? Est-ce vraiment si obligatoire ? Ne peut on pas réfléchir un peu et faire autrement, aller plus loin ?

Imaginons que dans un programme on ait un tableau de valeurs numériques. On veut à un moment donné obtenir les bornes (ie min et max du tableau)
On peut évidemment parcourir 2 fois le tableau et renvoyer une fois le min, une fois le max.... mais si ces valeurs sont faites pour être utilisées en même temps, c'est un peu idiot.
Pourquoi ne pas avoir une fonction "getMinMax" qui nous retournerais le min _et_ le max du tableau ?
C'est pas hyper tordu, c'est logique mais c'est interdit pour quelle raison ? parce qu'on peu _aussi_ écrire de la daube avec ? Pour moi c'est pas une raison on peut écrire de la merde avec n'importe quel langage...
Et dans le cas min/max créer un objet pour ses valeurs serait complètement idiot, inutile à mon avis.

(et sinon les langages de script c'est pas que pour les petits programmes à la con de quelques lignes, pour le moment je bosse surtout avec un langage interprété, à prototype et il fait un peu moins de 60 000 lignes sans les libs...)

> Évident, c'est pas gagné, surtout avec Perl

Oui mais quand je dis ça je veux dire que le code évident (parce qu'il l'est réellement, que c'est redondant, qu'il y a suffisament d'informations pour le comprendre) peut être supprimé.

Mais à chaque fois qu'on parle de perl, l'argument avancé pour les "contre" est qu'il est illisible alors qu'en réalité c'est que les gens ne le connaissent pas.

> n'importe qui (ayant une connaissance minimale du langage)

Où s'arrête le minimal ?
Les $* font partie de perl et du minimum de perl pour moi.
Le truc c'est que vous ne voulez pas apprendre perl car il semble obscure et il semble obscure car vous ne l'apprenez pas.

Demandez à un programmeur lisp de coder en java et il va dire qu'il ne comprend rien.

En fait tout le monde est trop formatté au c/c++/java je trouve...


> un code explicite est un gage de pérénité : si le développeur disparait, on peut le remplacer.

Je ne pense pas.
SI je file dans quelques année un code perl 4 ou 5 à un développeur avec un bouquin du perl correspondant alors mon code serait maintenable également.

Si je file à un programmeur ne connaissant pas python un programme en python, c'est pas sur qu'il s'en sorte plus facilement.

Evidemment si je file un code pourris en perl il y aura de la casse, mais du code crade on peut en écrire dans quasiment tout langage.
Il n'y a qu'à voir ce qu'on peut faire en C:C++... et pourtant y'a pas trop de magie comme dans perl.

Tiens d'ailleurs c'est pas mal ça, si dans quelques années on file un programme C++ (avec tout plein de pointeurs) à un programmeur java je voudrais bien voir ce que ça donnera...

Explicit is better than implicit est une erreur à mon avis...

Oui, c'est exactement ça. La liste (ou le tableau) est en général là pour pallier au manque dans le langage, et comme tu dis c'est surement dur à implémenter. Mais quand je code dans un langage de haut niveau, le compilo je m'en fou un peu, son boulot est justement de me faciliter la vie pas le contraire.

Pour ce qui est du ruby, pour ma part avec des langages de ce genre et des fonctions idem ... ben c'est documenté en codant est la doc est mise à jour (javadoc and co) Ca reste un moyen correct même si pas parfait...

ou alors on dit qu'une méthode renvoi plusieurs valeurs et qu'on peut affecter plusieurs valeurs en même temps par similitude
hop, le problème est réglé, la liste n'est juste qu'une écriture comme une autre pour du retour / affectation de plusieurs valeurs mais pas forcément un type en soit (dans ce cas précis)

Le problème est bien que java est trop fermé pour ces choses et non un problème de langage objet

En ruby par exemple :

def foo
  return 1, 2, 3
end

a, b, c = foo()


Il n'y a pas de notation de liste, tableau ou autre, mais le principe est le même (il ne faut pas du tout se focaliser sur la notation en javascript)

> Explicit is better than implicit.

Je crois que c'est le truc qui m'a toujours fait détesté python.
Pourquoi écrire du code alors que c'est évident ?
Ca complique la vie du codeur, ça complique aussi la vie de tous ceux qui lisent le code et ça n'apporte rien...


open(FILE, ">file.txt");
while(<FILE>) {
  print if =~ /plop/
}
close(FILE);


C'est implicite et lisible si tu connais =~ et < >

> La forme est en effet assez lisible et concise... Mais pour un langage objet, je crains qu'elle ne le soit trop !

Et pourquoi un langage objet ne devrait pas être concis ??

Il n'y a qu'à prendre ruby : objet et concis.
Pour moi pour le moment un des meilleurs modèle objet que je connaisse (après il y en a ptetre d'autres...)


Pour le reste, ben voilà quoi, je trouve que java est vraiment trop limité côté type "primitifs", et je comprend vraiment pas pourquoi ils ont fait ça vu les limitations que ça provoque...

> ce qui donne lieu à un autre débat :)

C'est bien le problème de java : un langage objet non objet, avec que des trucs chiant, juste assez bien (surtout niveau plateforme) pour l'utiliser et juste assez chiant pour le détester...
A croire que les concepteurs ont jamais eu les couilles de faire plus qu'un langage "basique" avec rien de nouveau à part virer les pointeurs...

allez, histoire d'accumuler les retours et les regexp :


// Simple regular expression to match http / https / ftp-style URLs.
var parsedURL = /^(\w+)\:\/\/([^\/]+)\/(.*)$/.exec(url);
if (parsedURL) {
  var [, protocol, fullhost, fullpath] = parsedURL;
  [...]
}


Si ça c'est pas sympa comme code !