Quels seraient les bons arguments factuels pour convaincre la haute direction de considérer la programmation fonctionnelle? [fermé]

Il y a des tonnes d'arguments «théoriques» pour expliquer pourquoi la programmation fonctionnelle est une bonne idée (trop pour que cela soit resté une question ouverte, et correctement).

Cependant, la plupart d'entre eux sont des arguments soit issus de la théorie ("élégance", etc ...), soit destinés aux développeurs.

Le problème est que la plupart d'entre eux sont totalement inutiles lorsque l'on a pour objectif de présenter l'idée à la direction d'une grande entreprise , dont certains ne sont même pas développeurs, et qui se soucient tous principalement d'arguments commerciaux : coût, gestion du capital humain , livraison de produits, service à la clientèle et revenus; ainsi que des faits quantitatifs sur des points théoriques qui ne peuvent tout à fait être étayés par des faits.

Y a-t-il des arguments convaincants à présenter pour répondre à ces préoccupations commerciales en ce qui concerne l'adoption de la programmation fonctionnelle en tant que concept (pas de langage spécifique), par rapport à la combinaison typique de procédures / POO, par exemple Java / C ++ / (Perl | Python) .

De préférence, je recherche des arguments quantitatifs et / ou basés sur des recherches ou des études de cas. Par exemple "selon cette référence, le taux de bogues des systèmes multithread en Lisp / F # est de 10% celui de Java" ou "80% des meilleurs diplômés exprimant les préférences de la technologie souhaitée nommée programmation fonctionnelle comme étant parmi les 3 principaux intérêts".

Je sais que Graham a présenté des cas d'utilisation de programmation fonctionnelle pour une starup et serait ouvert à certains de ses arguments en supposant qu'ils peuvent être valables pour une grande entreprise établie.

_{Je suis parfaitement conscient que vous pouvez faire quelque chose de proche de la programmation fonctionnelle en Perl, probablement Python, et (peut-être) même Java 8 ou C ++ 14. Mais cela ne signifie pas qu'une organisation utilisant Perl, C ++ ou Java approuverait la fonction vs POO / approches procédurales même dans ces langues}

_{Pour les besoins de ce langage, "large" est défini comme suffisamment grand pour avoir un groupe dédié d'ingénierie / outils de développement, qui dicte ce que tous les développeurs sont autorisés à utiliser / faire; et au moins des centaines de développeurs bas de gamme} .

Il y a un argument très simple, qui pourrait au moins amuser la direction.

Il est bien connu que les ordinateurs modernes ne deviennent pas "plus rapides" qu'avant, car la mise à l'échelle des fréquences, pour l'instant, atteint la limite. Ils augmentent leur productivité potentielle en ajoutant des cœurs.

Cela implique que pour bénéficier au maximum de cette architecture, les programmes doivent être parallélisés. Mais la programmation parallèle est beaucoup plus difficile que la programmation séquentielle, en raison de nombreux nouveaux défis qu'elle apporte (consultez l' article Wiki pour une vue d'ensemble complète).

La programmation fonctionnelle permet de se débarrasser de certains de ces défis, par exemple les conditions de concurrence ne s'appliquent pas si vous utilisez uniquement des variables et des méthodes immuables sans effets secondaires. La courbe d'apprentissage de la programmation fonctionnelle est souvent abrupte, mais la courbe d'apprentissage de la programmation parallèle peut être encore plus abrupte et pas du tout intuitive.

Donc, si le défi est d'écrire des programmes plus efficaces de manière plus efficace, on peut comparer les coûts de formation des gens à écrire des programmes parallèles avec les coûts de formation des gens à apprendre la programmation fonctionnelle, et les risques que les deux approches peuvent entraîner.

Concernant les langages mixtes (qui prennent en charge à la fois le style de programmation fonctionnel et impératif): à partir d'un certain point, ils pourraient être utiles pour la transition (les gens pourraient commencer à les utiliser de manière "familière" et apprendre progressivement de nouvelles approches). D'un autre point, cela pourrait être une bénédiction déguisée, car les avantages potentiels de la programmation fonctionnelle peuvent être annulés avec le code maladroit de quelqu'un. On peut atténuer cela en établissant des directives de codage claires (voir par exemple " Scala efficace " par Twitter), bien que suivre les directives nécessite un certain niveau de maturité d'équipe. De ce point de vue, les langages fonctionnels purs pourraient être "plus faciles" pour le développement de logiciels en raison des règles plus strictes qu'ils imposent par conception.

Vous approchez cela du mauvais côté. Dans la plupart des entreprises, la direction n'est pas responsable du "choix du paradigme de programmation", elle est (ou du moins devrait être) responsable de l'efficacité du travail d'équipe. Si toute votre équipe est convaincue que la programmation fonctionnelle améliorera la vitesse ou la qualité de votre travail, il ne devrait pas être trop difficile de convaincre la direction également. De plus, si votre équipe commence tout juste à utiliser des constructions fonctionnelles dans vos langages de programmation établis, et tout le monde en est satisfait, vous ne devriez même pas avoir à demander une autorisation (diable, un non-programmeur pourrait même ne pas comprendre la différence entre les non constructions fonctionnelles et fonctionnelles, alors pourquoi voulez-vous discuter de ce problème avec lui?).

Mais attention, si le reste de votre équipe a une opinion différente sur la PF, et qu'ils commencent à se plaindre de votre code fonctionnel que les autres membres de l'équipe ne comprennent pas, vous pourriez avoir des problèmes avec la direction - pour une bonne raison, car dans un tel cas, l'équipe perd de son efficacité.

L'essentiel est donc de convaincre les autres membres de l'équipe ou vos chefs d'équipe, mais pas la gestion de haut niveau!

EDIT: en raison de votre commentaire - en fait, c'est une réponse à votre question ;-). Le seul argument factuel dont je parle est "toute l'équipe pense que la PF est utile pour faire le travail . À mon humble avis, c'est l'argument qui a le plus de chances d'être accepté par la direction de haut niveau, et il est très pratique à appliquer. Essayer d'utiliser des arguments techniques aux personnes non techniques travaillent directement rarement, non pas parce qu'elles sont "trop ​​stupides pour comprendre le raisonnement technique", mais parce qu'elles sont assez intelligentes pour savoir que les décisions techniques doivent être prises par des experts techniques, et elles sont également assez intelligentes pour ne pas se fier sur l'avis d'un seul expert.

Pour comprendre pourquoi la programmation fonctionnelle n'a pas envahi le monde, vous devez comprendre la pensée d'entreprise derrière les décisions de langage de programmation. Pour choisir Java pendant un moment:

1. Il existe des armées de programmeurs disponibles qui peuvent écrire des rames de code Java ordinaire. Ce n'est pas le cas des programmeurs Lisp ou Haskell (ou même Scala).
2. Tout le monde utilise Java, donc ça doit être bon. Corrolary: les gestionnaires n'ont pas à justifier leur choix de Java par rapport à un langage obscur dont personne dans la structure de commande n'a jamais entendu parler.

Si votre organisation est déjà ancrée dans le royaume des noms , il ne sera tout simplement pas possible de procéder à une modification complète de la programmation fonctionnelle. Le choix de la langue (et tous les autres choix qui l'entourent) est déjà profondément ancré dans la culture d'entreprise.

En supposant que votre objectif est de grandir en tant que développeur de logiciels, votre meilleur pari est de

1. Intégrez des concepts fonctionnels à vos programmes existants là où ils sont utiles et appropriés,
2. Utiliser les nouvelles fonctionnalités du langage fonctionnel au fur et à mesure qu'elles sont ajoutées au langage, et
3. Apprenez les modèles de conception orientés objet, dont certains existent pour surmonter les carences du langage dans les langages OO qui ne sont pas présents dans les langages fonctionnels.

Les arguments de Paul Graham ne s'appliquent vraiment qu'aux startups, et il y a eu un certain nombre d'histoires de mise en garde d'entreprises qui ont commencé à utiliser des langages purement fonctionnels, mais elles ont ensuite été rachetées par une autre société dont le premier objectif était de convertir immédiatement la base de code fonctionnelle vers un langage OO afin que leurs développeurs de logiciels existants puissent le comprendre.

Dans mon expérience (un peu cynique), ayant travaillé pour un magasin où nous avons utilisé la programmation fonctionnelle, et interviewé dans plusieurs autres:

1. Il y avait toujours un CTO et d'autres techniciens de haut niveau qui avaient de l'expérience avec la programmation fonctionnelle et ont réussi à en convaincre les cadres non techniques. (Et d'ailleurs, ces gens sont mieux qualifiés que moi pour répondre à votre question.)
2. Une fois que ces gens quitteront l'entreprise et seront remplacés par des gens qui n'ont pas cette inclination, les choses iront vers le sud. Les nouveaux gars imputeront tout ce qui ne va pas (y compris, et en particulier leurs propres échecs) au langage de programmation et au paradigme étranges utilisés pour construire ce qui a précédé. Ils marginaliseront les personnes restantes avec des compétences en programmation fonctionnelle, les expulsant de l'entreprise. Le système construit sur le langage fonctionnel se détériorera sans entretien. Ce genre de chose, à mon avis, le plus grand risque qu'une entreprise prend si elle adopte un langage fonctionnel, et ne doit pas être sous-estimé.
3. L'organisation doit avoir une culture «construire au lieu d'acheter» pour que cela fonctionne. Parce que l'adoption d'un langage fonctionnel signifiera moins d'options "d'achat".
4. Il y avait presque toujours un compromis sur les détracteurs techniques et non techniques de l'idée. Le plus commun de ces compromis est que tout langage non JVM était tout simplement hors de considération; Clojure et Scala ont été proposés, Haskell et O'Caml étaient tout de suite sortis du lot.

Éléments à prendre en compte pour la haute direction lorsque / si la haute direction est impliquée dans la sélection des langages de programmation (ce qui est étrange, ils devraient laisser cela à des personnes compétentes et compétentes (à la fois en technologie et en affaires):

• Productivité
  • Employés actuels et futurs
  • Tous les rôles (architectes, développeurs, testeurs, OP, ...)
• Plateformes prises en charge
  • Systèmes d'exploitation, (matériel?)
• Editeur de la langue / plateforme
  • Licences
• Maturité de la langue / plateforme
  • Support de / par l'éditeur et / ou la communauté
  • Bibliothèques
• Migration de la base de code actuelle
  • Ou intégration avec

Notez que ceux-ci ne sont pas spécifiques aux langages de programmation fonctionnels. Ce ne sont pas non plus des arguments sauf si vous fournissez des données avec ceux-ci. Nous ne pouvons pas vous donner les données car elles dépendent complètement de l'environnement de votre entreprise. La seule chose que nous pourrions faire est de collecter des données sur le Web pour montrer combien de connaissances et d'intérêt il y a pour une langue spécifique. Soyez prudent lorsque vous traduisez de nombreuses questions sur StackOverflow ou de nombreuses balises sur Linkedin dans une langue populaire.

Je ne pense pas que les arguments ou les faits aideront. Et certainement pas sans énoncer les problèmes que vous souhaitez résoudre.

Contre la croyance commune et l'auto-évaluation typique, de nombreuses décisions sont prises en fonction du sentiment intestinal. Et souvent, ces décisions sont de très bonnes décisions, car elles intègrent à un niveau subconscient beaucoup d'expérience de la personne qui prend la décision.

Si vous voulez contester une telle décision comme "Nous nous en tiendrons au langage C jusqu'à la fin de tous les ordinateurs", vous devez faire plus que simplement fournir quelques arguments.

La première étape consiste probablement à découvrir les personnes et les raisons de la décision selon laquelle la haute direction devrait avoir son mot à dire dans ces décisions techniques. Bien sûr, je ne peux que deviner ici, mais il est très probable qu'ils aient un historique de décisions prises par des techniciens qui ont mal tourné. Avouons-le: la plupart des développeurs ne sont pas très bons pour prendre des décisions (même techniques) au niveau de l'entreprise.

Une fois que vous avez trouvé ces personnes, parlez-leur pour gagner leur confiance. La meilleure approche est peut-être de les écouter. De quoi s'inquiètent-ils, quels sont les risques et les chances qu'ils voient? Quels sont les problèmes auxquels ils sont confrontés. À partir de là, vous pourriez vous déplacer pour impliquer les techniciens dans ce type de décision. Souvent, la direction ne veut pas vraiment prendre ces décisions, mais ne lui fait pas confiance. Donc, si votre équipe commence à s'impliquer dans la décision architecturale et à démontrer que les décisions que vous proposez sont une bonne gestion, vous serez peut-être prêt à faire confiance à vous / à votre équipe.

Il est important de prendre de bonnes décisions architecturales:

• Recueillir les contributions des parties prenantes (Management, Utilisateurs, Administrateurs, Ventes, Clients ...)
• Baser les décisions sur cette entrée
• Communiquer clairement: quelles sont les décisions (proposées); Quel risque ils visent à atténuer; Quels sont les intérêts contradictoires et avec un certain retard: leur efficacité.

Si vous travaillez pour une grande entreprise avec par exemple 10 000 employés, préparez-vous à apprendre certaines des leçons suivantes.

• la vitesse de codage n'est pas vraiment pertinente pour le résultat final.
• des choses comme la maintenabilité à l'échelle des décennies est.
• les problèmes que vous pensez pouvoir résoudre en utilisant des langages fonctionnels ne sont pas vraiment pertinents pour les résultats
• des problèmes comme la formation de 1000 développeurs, la résistance naturelle au changement et le maintien d'une base de code écrite par des développeurs ayant moins de 5 ans d'expérience dans la technologie utilisée sont.

Une fois que vous avez atteint un niveau de confiance que vos arguments sont entendus et considérés, vous aurez également établi un moyen de rassembler et de prendre en compte les exigences que vous, votre équipe et la direction avez confiance.

Si ce processus produit la recommandation d'utiliser une approche fonctionnelle dans certains domaines, vous avez terminé.

Si ce processus produit la recommandation d'ignorer les approches fonctionnelles allant au-delà de ce que propose le langage de programmation principal actuel, vous avez également terminé.

La mauvaise nouvelle est la suivante: selon la taille et le style de l'entreprise, cela peut facilement prendre quelques années ou décennies.

La bonne nouvelle est: vous apprendrez beaucoup en chemin.

Étant donné que la première étape consiste à commencer à parler et surtout à écouter la haute direction, je recommanderais de commencer par lire Just Listen .

Une bonne approche serait de montrer qu'elle a montré de bons résultats dans l'industrie et qu'elle a été adoptée.

Vous pouvez obtenir des données de:

• http://www.quora.com/What-companies-use-a-functional-language-as-an-official-language

• http://pchristensen.com/blog/lisp-companies/

Idéalement, essayez de parler aux gestionnaires de certaines sociétés cotées, surtout si vous êtes dans votre secteur, et obtenez des chiffres et des témoignages de leur part.

Google a de nombreux autres liens similaires pour Haskell, OCaml, etc.

Vous arrivez à cela dans la mauvaise direction.

Vous essayez de convaincre la direction d'un passage à un paradigme fonctionnel pour votre propre amusement et vous essayez de saisir des arguments pour soutenir cela qui n'ont rien à voir avec la vraie raison pour laquelle vous le souhaitez. Sinon, vous n'auriez pas besoin de poser la question, car vous seriez en mesure d'énumérer vos arguments du haut de votre tête.

Ce à quoi vous devriez plutôt penser, c'est ce dont le besoin commercial actuel est et comment il est le mieux servi. S'il arrive qu'il soit mieux servi en utilisant un paradigme fonctionnel, alors - ouais! - vous pouvez jouer. Mais si vous faites une analyse juste, en tenant compte des besoins opérationnels opérationnels, de la formation nécessaire des collègues, des antécédents des futurs programmeurs, de la maintenance, etc., souvent, ce ne sera pas le cas.

La haute direction sans compétences techniques ne devrait pas se soucier d'aspects techniques tels que l'utilisation de paradigmes fonctionnels. Ce n'est pas leur domaine d'expertise et ça sent la microgestion. Pourquoi ne délèguent-ils pas ces décisions à des personnes qui ont effectivement les compétences requises?

Ceci étant dit, voici quelques conseils pour convaincre les personnes ayant des connaissances techniques (premier cas) et celles qui n'en ont pas (deuxième cas).

Premier cas

Si vous parlez à des gens qui connaissent la programmation , comparer le code écrit sans paradigmes de programmation fonctionnelle et le même code écrit dans un style fonctionnel peut être suffisamment convaincant:

Exemple de code C # qui utilise un style impératif:

var categorizedProducts = new Dictionary<string, List<Product>>();

// Get only enabled products, filtering the disabled ones, and group them by categories.
foreach (var product in this.Data.Products)
{
    if (product.IsEnabled)
    {
        if (!categorizedProducts.ContainsKey(product.Category))
        {
            // The category is missing. Create one.
            categorizedProducts.Add(product.Category, new List<Product>());
        }

        categorizedProducts[product.Category].Add(product);
    }
}

// Walk through the categories.
foreach (var productsInCategory in categorizedProducts)
{
    var minimumPrice = double.MaxValue;
    var maximumPrice = double.MinValue;

    // Walk through the products in a category to search for the maximum and minimum prices.
    foreach (var product in productsInCategory.Value)
    {
        if (product.Price < minimumPrice)
        {
            minimumPrice = product.Price;
        }

        if (product.Price > maximumPrice)
        {
            maximumPrice = product.Price;
        }
    }

    yield return new PricesPerCategory(category: productsInCategory.Key, minimum: minimumPrice, maximum: maximumPrice);
}

Même code réécrit avec la programmation fonctionnelle à l'esprit:

return this.Data.Products
    .Where(product => product.IsEnabled)
    .GroupBy(product => product.Category)
    .Select(productsInCategory => new PricesPerCategory(
              category: productsInCategory.Key, 
              minimum:  productsInCategory.Value.Min(product => product.Price), 
              maximum:  productsInCategory.Value.Max(product => product.Price))
    );

Demandez-leur ensuite:

1. Combien d'erreurs un programmeur peut-il commettre dans le premier échantillon? Et le deuxième?

2. Est-il difficile de repérer les erreurs?

3. Est-il difficile de modifier le code?

Ces trois facteurs influencent la productivité, et donc le coût du produit.

Deuxième cas

Si vous avez affaire à des gens qui ne connaissent pas la programmation, il n'y a pas grand chose de technique à leur dire. L'une des façons d'être convaincant est de montrer l'impact réel des paradigmes fonctionnels sur votre travail et le travail de vos collègues.

Par exemple, comparez deux projets réalisés par la même équipe, l'un utilisant la PF, l'autre ne l'utilisant pas. Montrer que le nombre de bogues est beaucoup plus faible ou que c'était le premier projet que la société a réellement livré à temps devrait être suffisamment convaincant.