1
V'là un bon topic pour ne rien dire grin

J'entends pas mal parler de Scala comme « remplaçant » de Java.
Est-ce que vous avez un peu regardé ? Qu'en pensez-vous ?
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
2
J'ai un pote qui en fait au travail, c'est ni de l'oop ni du procédural, mais du fonctionnel

Du peu de que je comprend, ça peut utiliser les librairies de java (Beurk), mais c'est pas compilé en bytecode java. Ni en machine, ça doit être interprété.
3
En fait l'interpréteur doit être écrit en java #modui#
4
Warpten (./2) :
Du peu de que je comprend, ça peut utiliser les librairies de java (Beurk), mais c'est pas compilé en bytecode java. Ni en machine, ça doit être interprété.

WP dit que ça peut être compilé en bytecode Java ou .NET., et que l'approche peut être fonctionnelle mais aussi OO.
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
5
Le bytecode compilé est en effet utilisable soit sur JVM, soit sur la vm .Net. Le gros avantage pour eux est de récupérer toute une lib standard gratuitement.

Je commence à découvrir, et j'apprécie moins que ce que je pensais, même si ça semble être un gros pas en avant par rapport à Java.
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
6
flanker (./5) :
Je commence à découvrir, et j'apprécie moins que ce que je pensais, même si ça semble être un gros pas en avant par rapport à Java.


De toute façon face a java tu peux pas revenir en arrière...


GT Mauvaise langue !! tongue
avatar< SCPCD > j'aurais du dire "les doigts dans le cul vu que le java c'est de la merde"
Je suis Goto !
7
C'est quand même un peu flippant : j'ai fait un projet (vide pour l'instant, je n'ai pas encore créé de classe), avec un simple fichier SBT (le système de packaging recommandé), puis je clique sur la commande de build.
Résultat : 91 dossiers, 51 fichiers.
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
8
wow, mieux qu'un squelette de projet autotools grin
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
9
Allez, deux classes Scala, 265 dossiers et 212 fichiers après la compilation (en plus, ça génère une classe et un fichier par fonction anonyme, et on est fortement encouragés à un faire tout le temps…)
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
Tiens, question, pourquoi te soucier de ça, t'es pas censé réfléchir à plus haut niveau sur la structure de ton projet ? Si le packageur doit faire ça pour faire ce que tu veux, où est le problème ?
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
En soi, je n'en ai rien à faire, simplement je découvre le langage et les outils de build, du coup je regarde un peu la structure réelle.
Après, je ne suis pas fan des usines à gaz juste pour compiler une classe vide. Mais bon, c'est lié au côté Java de Scala ^^
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
Oui c'est une contrainte liée au Java qui t'impose un fichier par classe et qui t'impose aussi que tout soit dans des classes. Parfait pour bloater considérablement tout ton projet.

En ce qui concerne Scala, j'avais regardé il y a pas mal d'années... j'avais trouvé le système de typage intéressant mais assez complexe étant donné que c'était l'un des plus évolué à l'époque. Mais bon le simple fait qu'il dépende de Java avait suffit à le discréditer pour toute utilisation en ce qui me concerne grin
Au contraire : quand tu n'as pas le choix et que tu dois utiliser l'écosystème de Java, ça permet d'utiliser un langage qui est quand même nettement plus léger à coder ^^

(après, si j'avais vraiment le choix, je pense que je serais parti sur autre chose que du Scala)
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
Là-dessus on est d'accord, c'est mieux d'utiliser Scala plutôt que Java quand on n'a pas le choix.
flanker (./13) :
un langage qui est quand même nettement plus léger à coder ^^
Intéressant, tu as quelques exemples/urls ?
http://stackoverflow.com/questions/2952732/samples-of-scala-and-java-code-where-scala-code-looks-simpler-has-fewer-lines


Java 7:
Collections.sort(people, new Comparator<Person>() {
  public int compare(Person a, Person b) {
    return a.getName().compare(b.getName());
  }
});
Collections.sort(people, new Comparator<Person>() {
  public int compare(Person a, Person b) {
    return Integer.valueOf(a.getAge()).compare(b.getAge());
  }
});

Scala:
val sortedPeople = people.sortBy(p => (p.name, p.age))
Java 8:
people.sort(Comparator.comparing(Person::getName).thenComparing(Person::getAge));
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
Je trouve que Scala a fait quelques choix vraiment curieux.

Pour ne faire aucune exception de syntaxe pour les opérateurs classiques (+, *, …), ils ont établis quelques règles :

* *, +, -, … sont des noms de méthode comme les autres
* quand une méthode ne prend qu'un argument, on peut supprimer . et () (au lieu d'écrire instance.methode(argument), on peut écrire instance methode argument ).

Comme ça, on a instance * argument == instance.*(argument). Ok, mais « instance methode argument » n'est pas très lisible.


Les [] sont réservés pour les types. Bon, pourquoi pas, mais c'était quand même bien pratique pour les tableaux. On se retrouve à devoir écrire tableau(index) = valeur, qui a la même syntaxe qu'un appel de fonction… À nouveau, je trouve ça moins lisible sad Un autre truc qui manque (et qui est purement du sucre syntaxique), c'est le slicing à la Python.
On se retrouve à devoir faire
val l = tableau.length
val soustableau = tableau.slice(l - 5, l - 1)
au lieu de soustableau = tableau[-5; -1]


mais bon, ça reste mieux que Java grin
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
./17 : la priorité des opérateurs reste gérée comme un cas particulier, ou bien ils ont aussi trouvé une astuce ?
avatarAll right. Keep doing whatever it is you think you're doing.
------------------------------------------
Besoin d'aide sur le site ? Essayez par ici :)
Je me suis aussi posé la question, et ça se base sur le premier caractère de l'opérateur, dans l'ordre suivant :

(toutes les lettres)
|
^
&
< >
= !
:
+ -
* / %
(tous les autres caractères spéciaux)

#hack#
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
Mouais, nettement moins élégant tout à coup grin

Je m'étais posé la question également, et j'en viens à me demander si c'est vraiment une si bonne idée de vouloir à tout prix rapprocher les opérateurs et les appels classiques de méthode. Ou plus simplement, les opérateurs c'est tout pourri et il faudrait enfin accepter un langage qui ne les proposerait pas embarrassed
avatarAll right. Keep doing whatever it is you think you're doing.
------------------------------------------
Besoin d'aide sur le site ? Essayez par ici :)
Autre truc que je n'aime pas : le return est facultatif pour renvoyer la dernière valeur calculée dans une fonction. Ça manque de cohérence, je trouve embarrassed

Zeph (./21) :
Mouais, nettement moins élégant tout à coup grin

Je m'étais posé la question également, et j'en viens à me demander si c'est vraiment une si bonne idée de vouloir à tout prix rapprocher les opérateurs et les appels classiques de méthode. Ou plus simplement, les opérateurs c'est tout pourri et il faudrait enfin accepter un langage qui ne les proposerait pas embarrassed

J'aime bien la surcharge classique d'opérateurs. Au moins, on conserve la lisibilité.
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
Ouais, parce que quand tu dois utiliser des fonctions pour remplacer les opérateurs (genre pour faire du calcul sur des complexes ou des matrices en C), dès que les calculs sont un peu complexes tu pleures question lisibilité tongue
avatarZeroblog

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo
(disclaimer : je suis toujours débutant en Scala)

On sent quand même que c'est bâti sur du Java. Le système de packaging est loooooooooooourd (et il faut télécharger internet pour la compilation), d'ailleurs l'auteur de SBT a le sens de l'humour (Simple Build Tool, ahaha), on a des trucs un peu curieux : tout est objet et tout le monde hérite de Any, notamment les sous-classes AnyRef et AnyVal. Et que retrouve-t-on dans AnyVal ? uniquement Int, Long, Char… bref les types primitifs de Java.


Encore quelques trucs pénibles : quand une méthode n'a pas d'argument (genre toString()), les parenthèses sont facultatives. Du coup, dur de faire la différence entre la méthode x.toString et l'appel à la méthode x.toString…
Seules les classes statiques peuvent avoir des méthodes statiques. Hors de question d'avoir des méthodes statiques dans une classe non statique…

L'importation est bizarre :

import org.apache.spark.SparkContext
import org.apache.spark.SparkContext._
import org.apache.spark.rdd.RDD

la seconde ligne permet d'importer tous les symboles définis dans SparkContext.
Si je l'utilise pas, la classe RDD ne dispose pas de la méthode reduceByKey. Et oui, c'est logique, importer un module permet d'ajouter des méthodes à une classe qui est définie dans un autre module… hum
Naturellement, l'IDE est incapable de le trouver (faut dire que ce n'est pas très intuitif). À propos d'IDE, ça m'est arrivé d'avoir un code qui ne compile pas alors que l'IDE ne me signale aucun problème sad
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
puthon, ça doit être pénible de programmer en Scala !
avatar<<< Kernel Extremist©®™ >>>
Feel the power of (int16) !
flanker (./24) :
quand une méthode n'a pas d'argument (genre toString()), les parenthèses sont facultatives. Du coup, dur de faire la différence entre la méthode x.toString et l'appel à la méthode x.toString…

Ca marche comment alors du coup ? Dans les langages dérivés de ML (comme OCaml ou F#), il n'y a pas de parenthèses dans la syntaxe des appels de fonctions, mais comme il n'est pas possible (à ma connaissance) de créer une fonction qui n'a pas d'argument, ça ne pose pas de problème d'ambiguité. Je suppose que ce n'est pas le cas de Scala (compatibilité Java oblige), du coup t'as une idée de ce que c'est censé faire ?
En fait, il y a deux cas : les méthodes sans argument, et les méthodes avec zéro argument (tritop)

def toto() { } <- méthode avec zéro argument
def toto { } <- méthode sans argument

dans le premier cas, tu peux l'appeler indifféremment obj.toto() ou obj.toto
dans le second cas, tu es obligé de l'appeler obj.toto

Mais du coup, je ne sais pas trop comment il fait la différence entre la méthode et l'appel à la méthode, j'imagine qu'il se base sur les types. Mais bon, je trouve ça assez bizarre :/
avatar<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant
C'est vraiment pas pour troller hein mais quel est l'intérêt de concevoir et utiliser un truc qui n'est qu'une surcouche de Java (et tout ce que cela implique...)? ça doit être bien lourd non?
avatar"If you see strict DRM and copy protection that threatens the preservation of history, fight it: copy the work, keep it safe, and eventually share it so it never disappears. [...] no one living 500 years from now will judge your infringing deeds harshly when they can load up an ancient program and see it for themselves."

Benj Edwards - Why History Needs Software Piracy

- - -
Achat ou échange: topic de mes recherches
Oui surtout avec la legerete de base du Java, je pense qu'en 2015 il y aura un concours du langage le plus lourd.



GT Leger !!
avatar< SCPCD > j'aurais du dire "les doigts dans le cul vu que le java c'est de la merde"
Je suis Goto !