hsyl20 a écrit 228 commentaires

Ca serait le programme du FN, que je dirais strictement la meme chose. Et sur l'aspect LL en particulier ils sont pas tres tres loin vu qu'eux aussi n'ont aucune chance de le mettre en application et peuvent s'amuser a y caser toutes les propositions irrealistes qui leur passent par la tete.

Bel amalgame. Détrompe-toi, il ne s'agit pas du NPA, le Front de Gauche est prêt à gouverner. Quelles propositions du programme sont irréalistes ?

Ils sont tellement dans la posture qu'ils n'arrivent meme pas a rentrer dans les clous. Pourtant, ils ont d'assez grande marges de manoeuvre (les changements au niveau de la loi dans la proposition sont assez larges).

Puisque nous contestons les clous, c'est un peu normal. Non ?

Une fois au pouvoir, tu crois serieusement qu'ils vont faire sauter tous les verrous pour mettre en application toutes leurs promesses?

Quelle autre alternative ?

Faire sauter les regles constitutionnelles de bonne gestion financiere, c'est dans le programme ou pas encore?
La bonne gestion financière de Nicolas ? De quelles règles parles-tu ?

Il y a les deux aspects dans le projet. Voir les 4 premières fiches.

De plus, il ne faudrait pas oublier que l'État, c'est sensé être nous tous. En ce moment ça n'est plus ça du tout mais ça n'empêche pas d'aspirer à ce que ça le redevienne.

Qu'est-ce qui dans le programme du Front de Gauche ne va pas dans le sens de redonner du contrôle au peuple ? Qu'est-ce qu'il faudrait y ajouter ?

Quelle belle argumentation sur le fond. Si vous avez des arguments rationnels entre deux conneries, n'hésitez pas !

Si j'ai posté cette partie du programme ici c'est évidemment parce que ça va dans le sens du LL. Les députés et les sénateurs du Front de Gauche se sont battus contre HADOPI et consorts. On peut peut-être penser qu'ils ont poussé leur réflexion jusqu'à ce qu'ils voudraient (et à priori leurs électeurs) à la place ? C'est ce "truc". Si vous voulez en débattre, n'hésitez pas...

Les lignes téléphoniques sont à l'État qui peut te mettre sur écoute. "Ce qu'il a tendance à en faire" dépend complètement des contrôles et des garde-fous qui sont mis en place. Pour Internet c'est la même chose. Avec le contrôle redonné au peuple dans le projet du Front de Gauche (assemblée constituante, etc.) ça ne peut qu'être mieux qu'actuellement.

Pour la licence globale, il faut aussi lire les autres articles sur la création artistique qui propose de revoir la répartition entre les maisons de disque, les artistes, etc. Et j'ai bien indiqué (comme dans la fiche source) que les financements alternatifs sont à l'état de réflexion. Si tu veux y participer, n'hésite pas...

Bref, 90% de ces propositions sont illégales ou non applicables, en l'état actuel du droit.

Oui on est bien d'accord, c'est pour ça qu'il faut sortir du traité de Lisbonne (entre autres). Dans le cadre du traité de Lisbonne, seule une politique libérale est applicable. C'est bien pour ça qu'on l'avait refusé en 2005 (référendum Constitution Européenne) et c'est aussi pour ça qu'ils l'ont imposé sans référendum.

Les méthodes pour sortir du traité de Lisbonne de façon diplomatique existent et de toutes façons c'est un préalable si on veut changer de modèle politique.

Et sinon, toutes ces propositions, elles sont chiffrées où c'est un concours miss france? (moi je veux la paix dans le monde aussi d'abord!)

Je t'invite à consulter le document "Comment gouverner face aux banques ?" qui contient des mesures pour restaurer les marges de manœuvre de l'État : http://www.lepartidegauche.fr/images/stories/textes/pg-face-(...)

Pour la paix dans le monde, de nombreuses propositions vont dans ce sens. Sortie de l'OTAN, logique de coopération plutôt que de guerre économique, etc.

/me va aller voir les autres...
Tu nous raconteras.

Je m'attendais un peu à ce genre de commentaire argumenté. Surtout le terme "populiste" que j'aimerais bien que tu définisses pour qu'on rigole un peu.

Pour ce qui est de l'arrivée au pouvoir, on peut effectivement douter des chances de réussite mais ça ne doit pas empêcher de proposer une alternative à ce qui existe. Tu proposes quoi comme autre démarche ?

Je suis plus optimiste que toi quant aux chances de réussite du Front de Gauche, et surtout je ne me reconnais dans aucun des autres partis, donc j'ai deux options : soit je dis comme toi qu'il n'y a aucune chance et je vais à la pêche (enfin geeker en fait), soit j'essaie de m'investir avec ceux qui proposent quelque chose.

Euh, un framework qui a de l'avenir et qui se base sur un langage qui a de l'avenir, ce serait plutôt Lift.

http://liftweb.net/

Couplé avec impressive ( http://impressive.sourceforge.net/ ), c'est le top :-)

J'avais commencé à écrire un rapport avec OOo et effectivement tout ce que tu décris + la mauvaise gestion du placement des images ont fait que j'ai finalement préféré tout passer en Latex. Je ne sais pas comment se comporte la concurrence mais il y a clairement des progrès à faire pour OOo.

Euh.. le but était d'exprimer la même chose dans un autre paradigme donc c'est normal que ce soit différent. Dans les codes que j'ai proposés, je n'utilise pas de "mutable cells" (de variables qui varient) ce qui simplifie beaucoup (normalement) la compréhension du code : dans un contexte donné, une variable a toujours la même valeur.

Ensuite ma fonction est récursive terminale (tu peux t'en assurer en ajoutant l'annotation @tailrec, qui se trouve dans le package scala.annotation, au dessus de la définition) donc n'importe quel compilateur digne de ce nom va transformer l'appel récursif en boucle/goto/etc. Donc aucun problème avec la pile d'appel.

Ok je suis d'accord. Avec une autre syntaxe, ça passe effectivement mieux. Le même exemple en Scala :

def loop(x: Int): Int = {
   val n = input
   if (n == -99) x else loop(max(x,n))
}

output(loop(0))

Avec, toujours pour ceux que ça intéresse, le code à ajouter au début pour que ça compile (version script) :

#!env scala 
!#
import scala.math.max
def input = readLine toInt
def output(x:Int) = println(x)

Enfin tout ça pour dire que le paradigme impératif est un des moins déclaratif (voir http://www.info.ucl.ac.be/people/PVR/paradigmsDIAGRAMeng108.(...) ) donc ce n'est pas étonnant qu'il soit plus difficile à appréhender/analyser.

x := 0
input n
while n is not equal to -99 {
   if n > x then x := n
   input n
}
output x

C'est sûr que présenter un langage très peu déclaratif avec en plus 2 façons d'assigner des valeurs (x := 0 et input n), ça peut ne pas être forcément évident pour les débutants. Il faudrait comparer avec d'autres paradigmes. Par exemple en fonctionnel :

loop x = do
   n <- input
   test n x
   where
      test (-99) x = return x
      test n x = loop (max n x)

main = do
  a <- loop 0 
  output a

Pour quelqu'un qui n'a jamais programmé mais qui a quelques notions de math (variables non ré-assignables, fonctions pures), ça peut être plus compréhensible. Pour ceux que ça intéresse, il faut ajouter ce qui suit en haut du fichier pour le compiler avec ghc :

module Main (main) where
import Monad
input = (liftM read) getLine :: IO Int
output = putStrLn . show

J'ai lu en diagonale "Ce qu'on voit et ce qu'on ne voit pas" de Frédéric Bastiat. Ce qu'on voit c'est que c'est un pamphlet contre l'État (contre les impôts, les fonctionnaires, la subvention de la culture, les travaux publics, les services publics, etc.). Ce qu'on voit aussi, c'est que c'est une ode au néolibéralisme (c'est confirmé car d'après Wikipedia, Reagan et Tchatcher le citaient volontiers, ainsi que la droite américaine).

Ce qu'on ne voit pas, ce sont les effets bénéfiques de ce qu'il préconisait maintenant que toutes ses belles idées sont mises en application. Par exemple, il dit que virer les fonctionnaires considérés comme inutiles, c'est ballot pour eux mais ça permet aux contribuables de payer moins d'impôts et donc d'avoir plus de fric, donc finalement ils y gagnent, c'est ce que l'on ne voit pas. Effectivement c'est ce que l'on ne voit pas. Il dit que l'intervention de l'état en faveur des plus démunis c'est injuste pour les autres qui n'ont pas démérité (oui parce que c'est de leur faute en plus s'ils sont démunis) : et donc on fait quoi ? on les laisse crever ? Je pourrais en citer d'autres...

Je n'y connais peut-être pas grand chose en économie, mais suffisamment pour voir qu'il raconte de grosses conneries. Globalement son texte tente de justifier une politique, celle reprise par Sarkozy, qui ne fonctionne et n'a fonctionné nulle part. C'est ce que l'on voit.

Je te conseille de relire Jacques Généreux, notamment "La dissociété". Je ne vois même pas comment tu peux qualifier de torchon "les vraies lois de l'économie" après avoir lu Bastiat. Autant "les vraies lois de l'économie" est une vulgarisation de l'économie, autant Bastiat est un recueil de préceptes néolibéraux ne citant aucune référence et sans aucune démonstration qui ne tienne la route face à la réalité.

> Citons aussi Programming without Code: A Work in-Progress Paper qui s'approche pas mal de ce que je veux faire. Ouf je suis pas le seul :-)

Est-ce que tu as regardé du côté de Scratch [ http://scratch.mit.edu/ ] ? Je ne l'ai jamais utilisé mais j'avais trouvé ce papier [ http://web.media.mit.edu/~mres/scratch/scratch-cacm.pdf ] mentionné sur LTU [ http://lambda-the-ultimate.org/node/3686 ] intéressant.

Ça ressemble aussi un peu à un logiciel que j'utilisais quand j'avais 10 ans : Klik&Play !!! [ http://wikiclick.margasoft.fr/index.php?title=Klik%26Play ]

Avant que les certains politiques ne s'attaquent aux sciences dures, ils pourraient s'attaquer à certaines sciences molles qui les concernent encore plus. L'économie par exemple. Ça n'est pas mon domaine mais je suis en train de lire "Les vraies lois de l'économie" (Jacques Généreux) et notre gouvernement, tout comme le conseil de l'UE, est apparemment aussi nul en économie que dans les autres sciences...

J'ai posé la question sur la mailing-list. Pour l'instant aucune réponse claire :
http://scala-programming-language.1934581.n4.nabble.com/Scal(...)

PS : oui j'ai fait une faute à "license"

Si tu t'intéresses toujours aux paradigmes des différents langages, je peux te recommander (si tu ne les as pas déjà lus) :

Un article de Van Roy :
http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf

Le livre (dont l'article précédent est un résumé) :
http://www.info.ucl.ac.be/~pvr/book.html
qui a apparemment été traduit en français :
http://www.info.ucl.ac.be/~pvr/coursfrancais.html
Le sigle CTM utilisé parfois sur LTU (Lambda The Ultimate) fait référence à ce livre.

Programming Language Pragmatics (PLP sur LTU) :
http://www.cs.rochester.edu/~scott/pragmatics/

Concernant les continuations, on peut trouver divers exemples ici :
http://lampsvn.epfl.ch/trac/scala/browser/compiler-plugins/c(...)

Il y a aussi un exemple ici : http://scala-programming-language.1934581.n4.nabble.com/Deli(...)
Que j'ai plus ou moins expliqué en français ici : http://www.hsyl20.fr/home/?q=node/35

L'utilisation des symboles peut être très bénéfique. Surtout quand il n'y a pas de mot pour exprimer ce qu'ils représentent.

Par exemple : http://github.com/scalaz/scalaz/blob/master/example/src/main(...)

"<*" c'est quand même mieux que "applicativeFunctorWithAnAnonymousLeft"

Ça demande un temps d'adaptation mais c'est la même démarche que pour les autres sciences : il y a des notations spécifiques au domaine concerné.

Dans le cas de Map, c'est quand même plus clair de montrer que "b" est associé à la clé "a" avec "a -> b" qu'avec "(a,b)". Si j'avais à représenter une association unidirectionnelle entre deux entités sur une feuille, j'utiliserais plus naturellement une flèche qu'un tuple.

Ça tombe bien, Josh Suereth vient de publier un article qui explique comment implémenter l'équivalent des "type classes" d'Haskell en Scala : http://suereth.blogspot.com/2010/07/monkey-patching-duck-typ(...) Ça se fait en combinant les "structural types" :

scala> def pouet(a:{def ping: String}) = println("kekidi? " + a.ping)
pouet: (a: AnyRef{def ping: String})Unit

scala> class Yop {
     | def ping = "checku"
     | }
defined class Yop

scala> val truc = new Yop
truc: Yop = Yop@1c45484a

scala> pouet(truc)                                                                                                                                         
kekidi? checku 

Avec les traits :

scala> trait MyTypeClass {                                                                                                                                 
     | def ping: String                                                                                                                                    
     | }                                                                                                                                                   
defined trait MyTypeClass 

scala> def pouet(a:MyTypeClass) = println("kekidi? " + a.ping)                                                                                              
pouet: (a: MyTypeClass)Unit  

scala> pouet(truc)
:14: error: type mismatch;
 found   : Yop
 required: MyTypeClass
       pouet(truc)
             ^

Et avec les implicits. Si Yop supporte la type-class MyTypeClass, alors on définit un implicit comme ça :

scala> implicit def yop_mtc(a:Yop): MyTypeClass = new MyTypeClass {
     | def ping = a.ping
     | }
yop_mtc: (a: Yop)MyTypeClass

Ce qui permet ensuite d'écrire, sachant que truc est de type Yop :

scala> pouet(truc)
kekidi? checku

Sur shootout, la version 2.7.7 de Scala est utilisée. Elle commence à dater. Il faudrait voir ce que ça donne avec la 2.8.

L'utilisation mémoire de la JVM et le garbage collector utilisé se configurent. Si jamais la consommation mémoire devient un problème, il est possible de regarder de ce côté là.

En Scala si tu veux utiliser le Duck typing, tu fais :

def pouet(a: {def yeah}) {
a.yeah
}

C'est-à-dire que la méthode "pouet" prend en argument n'importe quel objet ayant une méthode "yeah" (ne prenant pas d'argument et ne renvoyant rien, dans cet exemple).

Après on utilise très rarement ce genre de code en pratique. Là où Scala ressemble à un langage de script, c'est principalement grâce à son système d'inférence de type, qui est très bien fait, et aussi grâce aux implicits qui permettent d'étendre des classes déjà existantes (à la Ruby).

Justement. Si on compare les deux versions (en indentant comme il faut), on peut voir qu'à quelques conversions syntaxiques près, on a le "même" code qu'en Python. On peut même se passer de la création d'une classe dans la version "script" en Scala.

Exemples de conversion Python => Scala :
"in" => "<-"
"xrange" => "Range"
indentation => accolades
...

Et on gagne le typage statique, la compatibilité avec les biblio Java/Scala/autres langages sur la JVM, la rapidité, etc. tout en conservant le Duck Typing.

J'ai traduit littéralement les 2 versions Python en Scala:

Version 1 :

#!/usr/bin/env scala
!#

class Toto {
for (a <- Range(2,100000)) {
var sa = 1
for (d <- Range(2,a-2))
if (a%d == 0)
sa += d
var (b,sb) = (sa, 1)
for (d <- Range(2,b-2))
if (b%d == 0)
sb += d
if (sb == a && a < b)
println(a+","+b)
}
}

new Toto


Version 2 :

#!/usr/bin/env scala
!#

class Toto {
//Pour ajouter la fonction "sort" à (x,y) comme dans le code Python
implicit def tupl(t:Tuple2[Int,Int]) = new {
def sort = if (t._1 > t._2) t.swap else t
}

val NB_ENTRIES = 1000000
val d = Array.fill(NB_ENTRIES)(1)

for (i <- Range(2, NB_ENTRIES / 2))
for (j <- Range(2 * i, NB_ENTRIES, i))
d(j) += i

println ( for (i <- Range(0, d.length) if d(i) < NB_ENTRIES && d(d(i)) == i && i <= d(i)) yield (i, d(i)).sort )
}

new Toto


Là ce sont les versions "script". Pour avoir une version pré-compilée en bytecode, enlever l'entête et remplacer "new Toto" par:

object Pouet {
def main(args:Array[String]) {
new Toto
}
}

Compiler avec scalac Toto.scala
Exécuter avec scala Pouet


Résultats avec 1M éléments :
Python V1 : j'ai arrêté après 14 minutes
Python V2 : entre 3.7s et 4s
Scala V1 : environ 50 minutes
Scala V2 : entre 1.3s et 1.6s
Scala V2 compilé : entre 0.60s et 0.66s

J'espère que ça va donner envie aux programmeurs Python qui voudraient passer à un langage qui a au moins la même expressivité que Python et qui est plus rapide et plus fiable (typage statique...) ;-)