Axioplase ıɥs∀ a écrit 3037 commentaires

Mais je n'ai pas evalue' justement !
Le thread parle de langage amateur, je demande si c'est le cas ou non : "etes vous des amateurs ou pas ?"

Ca se voit pas forcement, loin de la. Quand un gars comme Joe Marshall se fait traiter de noob [http://funcall.blogspot.com/2010/04/education-of-jrm.html] je me dis que c est pas toujours evident, non...
T as des langages simples fatis par des pros, et l inverse aussi. Et encore une fois, en fonction de l historique de chacun, on peut se faire une idee de la maniere utilisee pour developper le langage. S il n est pas un pro, il y a peu de chances qu il aie des fermetures avec partage de code (comme dans (\x. if x then 2 else (\y. x+y))) ou` une seule fermeture (avec double pointeur de code) peut suffire. Pour les gens qui regardent juste la syntaxe, ca change rien. Pour moi, ca change tout, car c'est cette partie qui m interesse. Le langage en soit, je m'en tape. Je ne suis ni pour, ni contre, et je n emet aucune critique, aucun jugement a son egard : je n'ai qu a peine survole' la page d'accueil !

Il a passe pres de 24 heures san rien de branche', mais ce soir, ca n a rien change'.

Comme l ecran ne s allume pas du tout du tout, je me demande s il n y a pas un faux contact qui lui fait croire que la l ecran est ferme', et qui le pousserait le bios croire que l'ordi est en veille, ou un truc du genre...

Et la machine que j utilise presentement n a pas l air d avoir un disque dur facile d acces pour interchanger, le temps de faire une derniere backup (et oui, j ai depuis peu le disque externe pour la sauvegarde, mais j ai pas eu le temps de faire la sauvegarde en question...)

j ai retire' la seule barette de RAM, et il a bippe' comme un dingue au redemmarage.
Mais ca n a pas debloque' la situation... .

il a l air de tourner au demarrage, d apres le bruit.

>> PS : moi non plus je ne comprends pas la question sur les "doctorants en sémantique"; il n'y a pas besoin d'être un spécialiste de la théorie pour monter son petit langage.

Il n y a pas besoin, non. Mais si tel est le cas, autant le dire. En effet, les raisons qui poussent a creer un nouveau langage (ou a reimplanter un langage existant) ne sont surement pas les memes.

>> J'ai effectivement tendance à prendre trop à coeur ce genre de critiques

Tu t'adresses pas à moi en parlant de critique là, j'espère ?
Un fichier de code n'est pas ce que j'appelle une grammaire formelle, surtout s'il faut chercher la grammaire au milieu du bruit du fichier. Le code, c'est pas formel pour deux sous. C'est pas une critique du langage ou quoi que ce soit, c'est un fait : le formalisme repose aussi dans la présentation ; dans un fichier à part, par exemple comme sur [http://people.csail.mit.edu/jaffer/r5rs_9.html]

Ensuite, je demandais honnêtement quel était votre compétence/connaissance. En fonction de votre expérience je sais que je ne trouverais pas les mêmes procédés d'implantation du langage (typiquement au niveau de la représentation interne des objets ou le choix du système de type). Je n'ai *rien* dit sur le langage lui même, vu que je n'ai pas assez lu la doc ni les exemples.

>> Voici une grammaire formelle: http://github.com/nddrylliog/nagaqueen/blob/master/grammar/n(...)

Non, voici un fichier utilisé par le parser.
C'est pas ce que j'appelle une grammaire formelle (et ça participe donc aussi au manque de documentation.)


Et sinon, vous faites quoi dans la vie ? Je veux dire (sérieusement) : « ce langage est-il développé par des gens qui (f)ont un doctorat en sémantique ? » ou juste par une bande d'amateurs qui se fait plaisir ?

Ouaip !
C'est même à l'encontre des sacro-saintes recommandations du W3C [http://www.w3.org/QA/Tips/noClickHere].
À chaque fois qu'on viole ces recommandations, le support de Flash pour l'iPhone et l'iPad s'améliore.

oui, il y a gUw pour mettre le mot sous le curseur en majuscules.

Le lecteur CD de mon laptop m'a lâché il y a un mois.
Et c'est pas de la mauvaise foi : je ne cherche pas à remettre en cause quoi que ce soit. Tu crées un journal sur du matériel, je donne mon avis basé sur mon expérience. Après, si t'es du genre à changer de laptop tous les 6 mois, tant mieux pour toi. Pour d'autres, c'est un investissement qui se rentabilise pendant des années, et ils n'ont pas envie de devoir tout changer pour un problème qui devrait être minime (ma connaissance des slots-ins sur laptop se limitant à du matos gravé/soudé/taillé dans l'ordi, et pas des lecteurs qu'on peut changer sans passer par le SAV. C.f. Apple.)

Comme quoi, savoir utiliser un moteur de recherche, ça s'apprend…
opérateurs booléens, guillemets, recherche de plus de mots…

Bref, quand google ne trouve pas (ou un autre), c'est souvent la faute de celui qui cherche, comme maintenant. Un moteur de recherche n'a aucune garantie de résultats et si tu lui reproches ce qu'il ne fait pas, je trouve que c'est l'hôpital qui se fiche le la charité.

Alors, certes, google *pourrait* se comporter autrement, Mais comme il ne le fait pas, c'est à toi de t'adapter, ou de payer pour avoir un service personnalisé.

>> Les libristes qui pinaillent sur des choses ridicules.

Ma remarque n'est pas liée au libre, hein. Simplement, j'ai des mini-cds, j'ai déjà vu des accidents de mini-cd dans des slot-ins, et je me contente de prévenir l'acheteur potentiel.
C'est peut-être ridicule pour toi car tu dis n'avoir pas vu beaucoup de tels CDs, mais c'est une remarque qui pourra servir à d'autres.

Puis un lecteur slot-in cassé, je doute que ça se change aussi facilement qu'un lecteur à chariot.

Et il le fait dans quel ordre l'affichage des résultats ?

Je doute que ça lise les CDs format carte de visite, mais sait-on jamais.
Si j'avais un slot-in, en tout cas, j'essayerais pas…

J'y connais rien en laptop, les seuls que j'ai eus, je les ai achetés d'occasion, j'ai jamais eu besoin de neuf… Passons…

>> * 15" 1440x900 brillant

Et quand tu souris, tu t'éblouies… J'ai jamais saisi l'intérêt des écrans à dalle brillante pour laptop. Un gros écran de bureau, pour graphistes qui vivent dans une salle éclairée de manière professionnelle, je comprends, mais pour un laptop, un ordi à utiliser en déplacement, ça sent les emmerdes d'avances, avec tous ces reflets.

>> Et les fioritures agréables (alu, retro éclairage, chiclet keyboard, multitouche connecteur magnetique, fermeture magnétique, DVDrw slot-in, OSX etc etc..)

Et les mini-CDs, avec un slot-in, t'as déjà essayé ?

Il te manque le mot "naturelle" ou "natural".

La réduction est un mot propre a lambda calcul, alors que la déduction est un mot de logique (et même si thèse de Church, blah blah, c'est pas un mot directement lié avec une fréquence suffisante pour empêcher la correction automatique)

T'as pas compris. Haskell, c'est pas Lisp. L'interprète ghci a une sémantique pourrie, donc tant que tu ne fais pas un fichier à compiler avec un MAIN, tu ne comprendras jamais comment ça marche.
Haskell, c'est un mensonge. On te dit "c'est pur, mais on peut faire des effets de bord dans la monade IO". La vérité, c'est que tu dois TOUT faire dans la monade IO. Tu dois TOUT faire à partir de la fonction main. Donc tu peux TOUJOURS extraire tes données avec l'opérateur "<-"

Désormais, tu coderas dans un fichier, avec un main, et tu feras ":!ghci %" ou l'équivalent pour emacs. Et tu lanceras "main" dans ton interprète, si ça type.

En pratique, une dernière fois (après, je moinsse !)


import Random (randomRIO)
import System (getArgs)

data Mobile = Poids Rational | Branche Rational Mobile Mobile deriving Show

poids :: Mobile -> Rational
poids (Poids n) = n
poids (Branche _ g d) = poids g + poids d

shuffle' [] acc = return acc
shuffle' l acc = do
  k <- randomRIO (0, length l - 1)
  let (lead, x:xs) = splitAt k l
  shuffle' (lead ++ xs) (x:acc)

shuffle :: [a] -> IO [a]
shuffle l = shuffle' l []

splity :: [a] -> ([a],[a])
splity x = splitAt n x where
           n = div (length x) 2

ranCreation :: [Rational] -> Mobile
ranCreation [] = (Poids 0)
ranCreation [p] = (Poids p)
ranCreation li = Branche k (ranCreation x) (ranCreation y) where
                 m = splity li
                 x = fst m
                 y = snd m
                 k = (poids (ranCreation y))/(poids (ranCreation x) + (poids (ranCreation y)))


main = do
       liste <- getArgs
       let liste_nombres = (map (fromIntegral . read) liste)
       let arbre1 = ranCreation liste_nombres
       liste_nombres_randomisee <- shuffle liste_nombres -- ICI !!!!
       let arbre2 = ranCreation $ liste_nombres_randomisee -- LA !!!!
       print arbre1
       print arbre2


Ensuite,
ghc --make toto.hs
./toto 1 3 90

Et voilà !

Dans ce fil : https://www.linuxfr.org/forums/31/28606.html

Pour faire simple, c'est impossible.

Il faut donc que tu repenses ton problème autrement, c'est à dire que tu remarques que tu voudras éventuellement utiliser ton résultat, par exemple pour l'afficher. Et donc tu veux rester dans IO. Comme je vois juste une fonction et pas de main (dont le type est IO ()), j'en déduis que tu ne sais même pas ce que tu veux faire. Donc écrit main, et ensuite, code en te disant "je suis dans la monade IO"

Exemple simple :

import Random (randomRIO)
import System (getArgs)

shuffle' [] acc = return acc
shuffle' l acc = do
  k <- randomRIO (0, length l - 1)
  let (lead, x:xs) = splitAt k l
  shuffle' (lead ++ xs) (x:acc)

shuffle :: [a] -> IO [a]
shuffle l = shuffle' l []

ma_fonction_normale :: [String] -> [(String, Int)]
ma_fonction_normale = map (\x -> (x, ((read x)+2)))

main = do
  liste_d_entiers <- getArgs -- récupère une liste de nombres passés au programme
  itlse_d_enteisr <- shuffle liste_d_entiers -- permute
  let resultat = ma_fonction_normale itlse_d_enteisr -- applique une fonction "pas IO"
  print resultat -- affiche le résultat et quitte


>> On ne peut même pas avoir la preuve que le compilateur en question utilise d'une manière ou d'une autre le source founi en entrée!

Et alors ?
Il n'est pas imposé qu'un langage soit turing complet, éditable, ou quoi que ce soit !


Je pense que le programme "1" dont le compilateur est
"if (input = 1) then dump_un_binaire(); else error();" est un programme libre et bien acceptable, et qui fait ce qu'on lui demande.

En revanche, il n'est justement pas dit que le binaire sera, lui, libre !
C'est pas un bug dans la licence, c'est plutôt une feature marrante ^^

En fait, tu confonds deux choses : le logiciel et son code source.
Ici, c'est le code qui est libre mais pas le logiciel, alors que la GPL couvre le logiciel (ce qui implique la couverture du code).
La GPL dit d'ailleurs :

The “Corresponding Source” for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.


Ce qui me fait dire que si j'ai écris la partie binaire dumpée par mon compilateur entièrement à la main, alors ça peut même être GPL. C'est un programme "one shot" (un "faux" compilateur) contre lequel tu ne peux rien. Le dev a joué, a ri, et il t'a bien eu.

>> Bien sûr, mais déja ne pas avoir de buffer overflow dans son code ça devrait déja être une priorité.

Ben, suffit d'arrêter de coder en C/C++/ASM.
Je suis d'accord, ça devrait être une priorité…

Les diagonales, c'est "l'indice i de la ligne i"…
Donc tu parcoures tes listes, avec un compteur d'indice incrémenté à chaque nouvelle liste. Et tu additionnes "les éléments à l'indice i de chaque liste l_i".

Pour diag2, c'est la même chose, sauf que tu inverses l'ordre de tes listes pour les parcourir à l'envers…


l1=[[1,2,3],[4,5,6],[7,8,9]]

diag1 = fst . foldl (\(x,c) y -> (x+(y!!c),c+1)) (0,0)
diag2 = diag1 . reverse

main = do
print $ diag1 l1
print $ diag2 l1


Illisible.

J'ai pas compris quel était le but de ton journal, son plan, son argumentaire, et j'ai donc laissé tombé la lecture arrivé au premier tiers.


>> Voila j'écris sous le coup de l'émotion , pardonnez mon orthographe /grammaire / typographie ... Mais fallait que je fasse passez le message ..

Euh, non,
1/ je ne pardonne pas. Et puis quoi encore ? Pourquoi je devrais faire un effort ? ;
2/ ton message n'est pas passé.

>> Dans les deux on peut mentir, dans les deux il s'agit juste d'avoir un degré de vraissemblance pour interpeller.

Ben, dans le cas numérique, là, proche de zéro, le degré de vraisemblance…
Y'a qu'à voir le nombre de spams qu'on reçoit, écrits à la main versus électroniques.

Dans les faits, les signatures manuelles correspondent à une vraie personne, les autres à un pc sous windows infecté.

Si tu me rajoutes du PGP sur ta pétition, je suis près à en rediscuter.


Sinon, c'est quoi ACTA ?

Bon, je relance ici, car le fil est gelé là bas…

>> Le récupérateur de mémoire se déclenche généralement quand il n'y a plus de mémoire disponible, où quand l'application n'a rien de mieux à faire.

Pas d'accord. En gros le GC se déclenche tout le temps : à chaque fois quon quitte la portée d'un objet, il est *immédiatement* récupéré (sauf cas pathologiques pour certains types de GC où la récupération se fait à un autre moment). Quand tu manques de mémoire, c'est l'allocation de plus de mémoire qui se déclenche, pas la récupération.


>> Finalement, un récupérateur de mémoire n'est pas si compliqué que ça. Mais face à quelques «delete» bien placés et pas oubliés, ça fait légèrement lourd.

Un simple GC, c'est simple, oui.
Mais des centaines de « delete » pas forcément bien placés, et parfois oubliés, c'est légèrement relou, face à de simples GC_malloc();


>> PS: Je préfère une application en C qui perd un peu de mémoire sur certaines opérations, à une application java qui consomme 200Mio quoi qu'il arrive.

C'est pas un problème de GC, ni même de langage. C'est un problème de paradigme, et ça n'a rien à voir… Si tu codais orienté objet en C, tu passerais ton temps à créer des objets qui bouffent de la mémoire… En "impératif C", tu crées ce dont tu as besoin, à la main. En POO, tu crées un objet, et immédiatement, toute une hiérarchie d'autres objets dont tu n'as peut-être rien à faire, mais que tu es obligé d'avoir car ils sont liés dans une méthode de la classe virtuelle de l'interface publique du cousin 2.0 de la méthode Cauet(); forcément, ça bouffe plus de mémoire…


Oui, un GC, ça a un coût. Et c'est fouchtrement rentable quand on sait s'en servir. Simplement, ce que tu ne sais (probablement) pas, c'est qu'un GC, c'est pas une solution générique miracle : ça se choisit en fonction du problème à résoudre et des données, puis ça se paramètre en fonction du programme écrit. Le problème, c'est qu'on a souvent un seul GC par langage ou implantation… Le GC devrait être une lib à part.

En fait, un GC est une chose trop importante pour être laissée aux implanteurs d'un langage… C'est aussi un art, tout comme gérer ses free() à la main. À compétences égales de développeur, la version GC est garantie meilleure : un débutant fera mieux avec n'importe quel GC qu'un débutant avec free(), et un pro utilisera son GC dans les meilleures situations, et des free() à d'autres !