IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Affichage des résultats du sondage: Selon vous, quel est le meilleur langage pour apprendre la programmation ?

Votants
278. Vous ne pouvez pas participer à ce sondage.
  • C

    85 30,58%
  • C++

    36 12,95%
  • Python

    56 20,14%
  • Ruby

    16 5,76%
  • Java

    29 10,43%
  • C#

    12 4,32%
  • PHP

    9 3,24%
  • Matlab

    9 3,24%
  • HTML/CSS

    8 2,88%
  • OCaml

    14 5,04%
  • 1 0,36%
  • 1 0,36%
  • 1 0,36%
  • 1 0,36%
Débats sur le développement - Le Best Of Discussion :

Quel est le meilleur langage pour débuter la programmation ?


Sujet :

Débats sur le développement - Le Best Of

  1. #261
    Rédacteur/Modérateur
    Avatar de Logan Mauzaize
    Homme Profil pro
    Architecte technique
    Inscrit en
    Août 2005
    Messages
    2 894
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Architecte technique
    Secteur : Transports

    Informations forums :
    Inscription : Août 2005
    Messages : 2 894
    Points : 7 083
    Points
    7 083
    Par défaut
    Citation Envoyé par sazearte Voir le message
    Je me suis mal exprimé, je voulais dire que c'était le premier langage qui à possédé ce système, aujourd'hui (sous python3) PIP est fournie de base avec le langage. C'est un programme a part mais je vois pas ou est le problème ?
    Ah bon ? Pourtant que je télécharges cela : https://www.python.org/ftp/python/3....mbed-amd64.zip (je n'ai pas PIP ...).

    Le seul problème c'est la précision : "python intègre", non. Quelqu'un a développé un outil mais Python n'intègre rien du tout.
    En Java, il existe également un package JDK + Netbeans mais les deux sont bien distincts.

    Ensuite PIP, si j'ai bien compris, ne fait que déposer des librairies dans une arborescence. A ce jeu là les "package manager" de *Nix existent depuis plus longtemps.
    Java : Cours et tutoriels - FAQ - Java SE 8 API - Programmation concurrente
    Ceylon : Installation - Concepts de base - Typage - Appels et arguments

    ECM = Exemple(reproduit le problème) Complet (code compilable) Minimal (ne postez pas votre application !)
    Une solution vous convient ? N'oubliez pas le tag
    Signature par pitipoisson

  2. #262
    Futur Membre du Club
    Homme Profil pro
    Ingénieur développement matériel électronique
    Inscrit en
    Août 2011
    Messages
    7
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement matériel électronique
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Août 2011
    Messages : 7
    Points : 5
    Points
    5
    Par défaut Il n'y a pas de meilleur langage, il y a des langages couvrant des domaines différents
    Il y a plusieurs types de langage. Un seul langage ne sert pas en grand chose. On risque de ne pas posséder les concepts non traités par le langage en question.
    C'est pourquoi je verrais bien une obligation pour tout programmeur en herbe de s'initier à plusieurs langages, et ensuite de développer ses connaissances sur un langage particulier.
    par exemple:

    - un assembleur : sinon comment comprendre comment une machine fonctionne ? Comment produire des programmes performant si on ne connait rien à l'architecture d'un CPU?
    - C : car c'est obligatoire.... beaucoup de langages s'interface avec c.
    - Java (ou à la rigueur c++ ?): pour le côté objet, très formateur de part les concepts supportés.
    - Forth ou Postscript ou un autre langage de type "à pile" : c'est un premier pas vers les langages fonctionnels.

  3. #263
    Membre éprouvé

    Homme Profil pro
    non
    Inscrit en
    Mai 2008
    Messages
    394
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : non

    Informations forums :
    Inscription : Mai 2008
    Messages : 394
    Points : 1 116
    Points
    1 116
    Par défaut
    Citation Envoyé par Voconce Voir le message
    - un assembleur : sinon comment comprendre comment une machine fonctionne ? Comment produire des programmes performant si on ne connait rien à l'architecture d'un CPU?
    - C : car c'est obligatoire.... beaucoup de langages s'interface avec c.
    Juste pour rebondir là dessus, il y a eu je crois plusieurs avis similaires à cela sur ce sujet : personnellement je n'ai jamais fait d'assembleur de ma vie, ni lors de ma formation ni professionnellement. Idem pour le C. J'en ai fait un peu y'a 12 ans lors d'un semestre en licence. J'ai toujours pris soin d'éviter ces deux langages, ça m'intéresse pas. Ça m'oblige à gérer une certaine complexité sur des points techniques qui m'ennuient profondément.

    J'ai beaucoup de connaissances qui sont dans le même cas que moi (comme d'autre à l'inverse), et j'imagine très bien que, pour les mêmes raisons, de nombreuses personnes soient rebutées par l'apprentissage de la programmation quand on insiste pour les faire débuter par là. Il n'y a probablement pas de meilleur langage pour débuter d'une manière générale. C'est très relatif à la manière et à la raison pour lesquelles on souhaite apprendre à programmer.

    Je n'ai pas d'expérience en enseignement, mais finalement c'est plus un problème de moyens qu'autre chose : il faudrait pouvoir former les gens aux cas par cas. Et pour ceux qui apprennent en autodidacte, je ne saurais que conseiller de ne pas suivre le résultat d'un tel sondage, mais d'essayer plusieurs choses jusqu'à ce qu'un paradigme et/ou un langage particulier semblent convenir pour aborder la programmation.

    Peut-être que j'en rajoute, j'ai pas tout relu sur le sujet...
    [|]

  4. #264
    Inactif  

    Homme Profil pro
    NR
    Inscrit en
    Juin 2013
    Messages
    3 715
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : NR
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Juin 2013
    Messages : 3 715
    Points : 1 184
    Points
    1 184
    Billets dans le blog
    9
    Par défaut
    - un assembleur : sinon comment comprendre comment une machine fonctionne ? Comment produire des programmes performant si on ne connait rien à l'architecture d'un CPU?
    Je suis pas d'accord pour l'assembleur, de nos jour quasi plus personne ne l'utilise et il est rare qu'il soit encore enseigné à l'école (au mieux il est enseigné rapidement, mais aucune école ne s'attardera sur ce langage).

    Pour faire des programme performant, on n'a pas besoin de l'assembleur, des langage plus naturel (C, D...) offre des résultats similaire mais avec un niveau de complexité bien moindre.
    écrire un hello world en assembleur ou en C, y'a énorme fossé.

  5. #265
    Expert éminent
    Avatar de Pyramidev
    Homme Profil pro
    Développeur
    Inscrit en
    Avril 2016
    Messages
    1 459
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur

    Informations forums :
    Inscription : Avril 2016
    Messages : 1 459
    Points : 6 060
    Points
    6 060
    Par défaut
    Citation Envoyé par sazearte Voir le message
    Citation Envoyé par Voconce Voir le message
    - un assembleur : sinon comment comprendre comment une machine fonctionne ? Comment produire des programmes performant si on ne connait rien à l'architecture d'un CPU?
    Je suis pas d'accord pour l'assembleur, de nos jour quasi plus personne ne l'utilise et il est rare qu'il soit encore enseigné à l'école (au mieux il est enseigné rapidement, mais aucune école ne s'attardera sur ce langage).

    Pour faire des programme performant, on n'a pas besoin de l'assembleur, des langage plus naturel (C, D...) offre des résultats similaire mais avec un niveau de complexité bien moindre.
    Même quand on ne programme pas en assembleur, connaître un assembleur peut être utile quand on veut voir sous le capot, quand on se penche sur la performance.

    Par exemple, une fois, sur Stack Overflow, quelqu'un demandait si, en règle générale, il était plus performant de déclarer une variable avant une boucle plutôt qu'à l'intérieur : http://stackoverflow.com/questions/4...-loop/33055027

    Il donnait cet exemple en Java :
    a) declaration before loop:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    double intermediateResult;
    for(int i=0; i < 1000; i++){
        intermediateResult = i;
        System.out.println(intermediateResult);
    }
    b) declaration (repeatedly) inside loop:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    for(int i=0; i < 1000; i++){
        double intermediateResult = i;
        System.out.println(intermediateResult);
    }
    Dans le cas b, on pouvait soupçonner la variable intermediateResult d'être empilée et dépilée 1000 fois, ce qui serait alors moins performant que dans le cas a.

    La question n'était pas limitée au Java, donc il y avait des réponses pour différents langages.
    L'une des réponses concernait le langage C, avec le compilateur gcc 5.2.0, mais sans préciser les options de compilation :
    I made a simple test:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    int b;
    for (int i = 0; i < 10; i++) {
        b = i;
    }
    vs
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    for (int i = 0; i < 10; i++) {
        int b = i;
    }
    I compiled these codes with gcc - 5.2.0. And then I disassembled the main () of these two codes and that's the result:

    1º:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
       0x00000000004004b6 <+0>:     push   rbp
       0x00000000004004b7 <+1>:     mov    rbp,rsp
       0x00000000004004ba <+4>:     mov    DWORD PTR [rbp-0x4],0x0
       0x00000000004004c1 <+11>:    jmp    0x4004cd <main+23>
       0x00000000004004c3 <+13>:    mov    eax,DWORD PTR [rbp-0x4]
       0x00000000004004c6 <+16>:    mov    DWORD PTR [rbp-0x8],eax
       0x00000000004004c9 <+19>:    add    DWORD PTR [rbp-0x4],0x1
       0x00000000004004cd <+23>:    cmp    DWORD PTR [rbp-0x4],0x9
       0x00000000004004d1 <+27>:    jle    0x4004c3 <main+13>
       0x00000000004004d3 <+29>:    mov    eax,0x0
       0x00000000004004d8 <+34>:    pop    rbp
       0x00000000004004d9 <+35>:    ret
    vs


    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
       0x00000000004004b6 <+0>: push   rbp
       0x00000000004004b7 <+1>: mov    rbp,rsp
       0x00000000004004ba <+4>: mov    DWORD PTR [rbp-0x4],0x0
       0x00000000004004c1 <+11>:    jmp    0x4004cd <main+23>
       0x00000000004004c3 <+13>:    mov    eax,DWORD PTR [rbp-0x4]
       0x00000000004004c6 <+16>:    mov    DWORD PTR [rbp-0x8],eax
       0x00000000004004c9 <+19>:    add    DWORD PTR [rbp-0x4],0x1
       0x00000000004004cd <+23>:    cmp    DWORD PTR [rbp-0x4],0x9
       0x00000000004004d1 <+27>:    jle    0x4004c3 <main+13>
       0x00000000004004d3 <+29>:    mov    eax,0x0
       0x00000000004004d8 <+34>:    pop    rbp
       0x00000000004004d9 <+35>:    ret
    Which are exaclty the same asm result.
    On constate alors que, dans ce cas, il est inutile de déclarer la variable en dehors de la boucle à des fins d'optimisation : le compilateur optimise déjà.

    En analysant le code assembleur, on reconnaît le code correspondant à la boucle :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
       0x00000000004004ba <+4>:     mov    DWORD PTR [rbp-0x4],0x0 ; i = 0
       0x00000000004004c1 <+11>:    jmp    0x4004cd <main+23>      ; aller à <main+23> pour faire le test i < 10
       0x00000000004004c3 <+13>:    mov    eax,DWORD PTR [rbp-0x4] ; copier i dans eax
       0x00000000004004c6 <+16>:    mov    DWORD PTR [rbp-0x8],eax ; copier eax dans b (donc on a copié i dans b)
       0x00000000004004c9 <+19>:    add    DWORD PTR [rbp-0x4],0x1 ; i++
       0x00000000004004cd <+23>:    cmp    DWORD PTR [rbp-0x4],0x9 ; comparer i et 9
       0x00000000004004d1 <+27>:    jle    0x4004c3 <main+13>      ; si i <= 9 (soit i < 10), aller à <main+13> (début de la boucle)
    Je connais quelques autres exemples du même style où il était intéressant de voir le code en assembleur pour voir comment le compilateur optimisait.

  6. #266
    Inactif  

    Homme Profil pro
    NR
    Inscrit en
    Juin 2013
    Messages
    3 715
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : NR
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Juin 2013
    Messages : 3 715
    Points : 1 184
    Points
    1 184
    Billets dans le blog
    9
    Par défaut
    Par exemple, une fois, sur Stack Overflow, quelqu'un demandait si, en règle générale, il était plus performant de déclarer une variable avant une boucle plutôt qu'à l'intérieur :
    Pour moi c'est au rôle du compilateur/interpréteur d'optimiser ce genre de chose.

  7. #267
    Expert éminent
    Avatar de Pyramidev
    Homme Profil pro
    Développeur
    Inscrit en
    Avril 2016
    Messages
    1 459
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Développeur

    Informations forums :
    Inscription : Avril 2016
    Messages : 1 459
    Points : 6 060
    Points
    6 060
    Par défaut
    A part ça, en langage C, l'assembleur aide aussi à comprendre les différences entre les conventions d'appel des fonctions (stdcall, fastcall, thiscall, etc).

  8. #268
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 012
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 012
    Points : 23 209
    Points
    23 209
    Par défaut
    Citation Envoyé par sazearte Voir le message
    Pour moi c'est au rôle du compilateur/interpréteur d'optimiser ce genre de chose.
    Et parfois c'est notre rôle de l'aider un peu .

    Quand on écrit notre code, il y a des choses qu'on ne dit pas et le compilateur/interpréteur ne peut pas les deviner, bien qu'il fasse déjà de nombreuses optimisations.

  9. #269
    Inactif  

    Homme Profil pro
    NR
    Inscrit en
    Juin 2013
    Messages
    3 715
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : NR
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Juin 2013
    Messages : 3 715
    Points : 1 184
    Points
    1 184
    Billets dans le blog
    9
    Par défaut
    Et parfois c'est notre rôle de l'aider un peu .
    Non, si il ne sait pas allouer/libérer de la mémoire correctement alors c'est un mauvais compilateur/interpréteur.
    Il y'avais ce genre de problème dans les 1ere versions de CPython et la JVM, aujourd'hui Python 3.5 et la JVM c'est heureusement tous faire cela automatiquement.

    Aucun développeur ne s'amuse à optimiser son code avec ce genre de broutille (dans le même registre faut t'il mettre des simple ou double quote ?) c'est une perte de temps pour des gains très faible.
    L’une des optimisations effectuées par la JVM consiste à remplacer l’appel d’une méthode par le corps de cette méthode (inlining) par exemple, des optimisations de ce type il en existe à la pelle, ce qui libère le développeur de ces tache peu intéressante et de se concentrer sur l'essentiel.

  10. #270
    Inactif  


    Homme Profil pro
    Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Inscrit en
    Décembre 2011
    Messages
    9 012
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 30
    Localisation : France, Loire (Rhône Alpes)

    Informations professionnelles :
    Activité : Doctorant sécurité informatique — Diplômé master Droit/Économie/Gestion
    Secteur : Enseignement

    Informations forums :
    Inscription : Décembre 2011
    Messages : 9 012
    Points : 23 209
    Points
    23 209
    Par défaut
    Écoute, un compilateur ce n'est pas magique.

    Il est capable de faire certaines optimisations, et je ne le nie pas, mais parfois il faut aussi l'aider, qu'il soit un bon ou un mauvais compilateur.

    Pour peu que ta boucle soit un peu complexe, je doutes que ton compilateur puisse y faire grand chose :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    while(int i = 0; i < nb ; ++i) // plage de valeur de nb ? Peux-t-on dérouler la boucle ?
    {
        foo();
    }
    
    void foo() {
        BigObject o;
        // do something
    }
    Ou ne serait-ce qu'à cause des opérations effectués dans les constructeurs/destructeurs.
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    while(...) { // constructeur et destructeur appelé à chaque tour de boucle, le compilateur ne peut en aucun cas optimiser en sortant "o" de la boucle.
        Object o;
    }
    Aucun développeur ne s'amuse à optimiser son code avec ce genre de broutille
    Cela dépend de tes contraintes, et donc du domaine dans lequel tu travailles.

    Sinon, ce n'est pas tant des "optimisations" que des "bons principes" ou des idiomes.

  11. #271
    Membre éclairé

    Inscrit en
    Novembre 2008
    Messages
    417
    Détails du profil
    Informations forums :
    Inscription : Novembre 2008
    Messages : 417
    Points : 826
    Points
    826
    Par défaut
    Citation Envoyé par Voconce Voir le message
    - un assembleur : sinon comment comprendre comment une machine fonctionne ? Comment produire des programmes performant si on ne connait rien à l'architecture d'un CPU?
    Et comment peut-on être architecte (dans le bâtiment) si on ne sait monter un mur en parpaings et organiser une armoire électrique ?

    Autant ce genre de détail peut être utile dans certains cas extrêmement pointus, autant cela n'a strictement aucun intérêt pour l'immense majorité des développeurs.
    Comme pour le bâtiment, le développement, aujourd'hui, c'est beaucoup de spécialités très différentes des unes des autres dans les contraintes qu'elles imposent. Entre l'embarqué temps réel et l'application de gestion organisée autour d'une base de données de 250 tables et destinée à brasser 4 ou 5 Go (sans même parler de gros monstres), il y a un monde.
    Il est clair que le premier aura besoin d'être assez pointu sur l'architecture du processeur qu'il utilise mais le second... C'est moins évident.
    Ce dernier est-il moins un développeur que le premier ?
    L'organisation d'une telle quantité de code pour rester maintenable et évolutif nécessite également beaucoup de métier qui ne s'apprend pas en faisant de l'assembleur.

  12. #272
    Membre éclairé

    Inscrit en
    Novembre 2008
    Messages
    417
    Détails du profil
    Informations forums :
    Inscription : Novembre 2008
    Messages : 417
    Points : 826
    Points
    826
    Par défaut
    Citation Envoyé par Pyramidev Voir le message
    Même quand on ne programme pas en assembleur, connaître un assembleur peut être utile quand on veut voir sous le capot, quand on se penche sur la performance.
    Que ce soit intéressant, aucun doute. Utile, probablement. Indispensable dans tous les cas est une autre affaire.
    Nul besoin de connaitre l'assembleur pour se douter qu'un peu de réflexion sur l'organisation du code, les déclarations de variables et autres peut avoir une incidence non négligeable sur les performances.

Discussions similaires

  1. Quel est le meilleur langage pour débuter la programmation ?
    Par Amine Horseman dans le forum Actualités
    Réponses: 144
    Dernier message: 28/11/2014, 18h06
  2. Quel est le meilleur langage pour la reconnaissance d'empreintes ?
    Par hanou88 dans le forum Traitement d'images
    Réponses: 4
    Dernier message: 09/02/2011, 08h58
  3. Débat : Quel est le meilleur langage pour coder en open-source ?
    Par Katleen Erna dans le forum Actualités
    Réponses: 15
    Dernier message: 17/08/2009, 11h54
  4. Quel est le meilleur langage pour la portabilité : Windows & Linux (voire Mac) ?
    Par iubito dans le forum Débats sur le développement - Le Best Of
    Réponses: 57
    Dernier message: 27/11/2007, 00h45
  5. Réponses: 4
    Dernier message: 12/05/2007, 01h55

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo