Pourquoi vous DEVEZ suivre l’évolution des langages que vous n’aimez pas ?

Je ne vous apprends rien si je vous dis que l’industrie du développement informatique évolue très TRÈS vite.

Chaque jour, on voit apparaître de nouveaux concepts de programmation, des patrons de conception innovants et des méthodes de travail autant techniques que métiers qui viennent ajouter leur petit grain de sable à la plage que constitue notre domaine.

Les développeurs changent aussi ! Au fur et à mesure que les problèmes se présentent, nous adoptons de nouvelles pratiques et outils qui ont la dent dure, et qui finissent par devenir la norme.

Il n’y a qu’à voir la renaissance de la programmation fonctionnelle qui a donné lieu à l’apparition de nouvelles pratiques et outils qui ont illuminés la vie d’un bon nombre de développeurs, et ce en à peine 6 ans.

Mais qu’en est-il des langages de programmation ? Il faut bien qu’ils s’adaptent eux aussi s’ils ne veulent pas être laissés sur le banc de touche.

On le voit bien avec certains langages très populaires qui sont très récents (Swift : 2014), tandis que d’autres datent de Mathusalem (C : 1972).

Au final, il y a deux issues possibles :

• Soit ils ne tiennent pas la cadence et sont condamnés à mourir lentement (en général pour des questions de design) ou à être remplacés, comme ce bon vieux Lisp.
• Soit ils évoluent et s’adaptent dans le sens de l’innovation.

Et j’ai tendance à suivre les nouvelles versions et notes de publication des langages de programmation de très près, même ceux que je n’utilise ou n’aime pas.

Pourquoi ? Justement parce qu’ils en disent long sur l’évolution de notre industrie de manière générale.

Ce sont des mines d’or enterrés sous un plateau d’argile, même quand il s’agit d’un langage dont on se contrefout. Il y a énormément d’informations que l’on peut interpréter de ces notes de publication :

• Évolution et tendances de notre industrie : une nouvelle fonctionnalité dans un langage peut-être la conséquence ou la cause d’une évolution plus globale qui impacte (ou risque d’impacter) tous les autres langages de programmation.
• Nouvelles méthodes et bonnes pratiques de programmation : cela vaut pour les langages que l’on utilise au quotidien, mais ça aide aussi à découvrir des concepts dont on peut s’inspirer.
• Veille technologique : en découvrant de nouvelles méthodes, outils, frameworks et bibliothèques.
• Syntaxes et fonctionnalités innovantes : cela m’a permis plus d’une fois de me faire ouvrir les yeux sur des syntaxes très communes, mais que je ne connaissais pas.
• Culture générale : car avoir un peu de connaissances et de vocabulaire technique hors de notre zone de confort, c’est toujours utile, surtout si vous voulez vous la péter dans des meetings ReactJS 😋

Bref, analyser (brièvement) l’évolution des langages de programmation est une discipline qui vaut le détour.

Du coup, pour la suite de cet article, je vous propose de revenir sur quelques avancées très intéressantes que j’ai découvert en faisant mes petites recherches, et qui risquent de raisonner parmi plein d’autres technologies.

Mais bien sûr, cette analyse est à la portée de tout le monde, à condition d’être un minimum curieux et attentif à l’évolution de notre industrie.

Pour mener cette réflexion par vous-même, je vous ai mis dans le bonus la liste des blogs et flux RSS que je suis et qui m’aident à suivre l’actualité informatique au quotidien.

Pour la suite de cet article, je me baserais uniquement sur des informations venant des dernières notes de publication des langages Java, C# et C++ pour ne pas m’éparpiller dans tous les sens.

En situation réelle, je vous conseille d’en avoir plusieurs autres afin d’élargir vos recherches.

Mais gardez à l’esprit qu’il s’agit d’interprétations et que je n’ai pas la science infuse ! Donc si vous voulez ajouter des arguments ou me contredire, n’hésitez pas à le faire dans les commentaires en bas de l’article.

Programmation fonctionnelle

En plus des classes, des structures et des enums, on voit de plus en plus apparaître un nouveau type de données en programmation orientée objets (POO) : les enregistrements (records), apparus dans Java 14 (Mars 2020) et C# 9 (Novembre 2020).

Il s’agit d’une forme restreinte de la classe qui ne contient que des données immutables : pas de comportement (méthodes) et uniquement des valeurs en lecture seule. Hormis ça, le fonctionnement est le même que celui d’une classe.

record Rice
{
    string OriginCountry;
    string Variety;
}

record Sauce 
{
    float Quantity;
    string Name;
}

Cette fonctionnalité vise à reproduire les types de la programmation fonctionnelle qui séparent totalement les données du comportement, ce qui n’est pas le cas des classes (ni même des structures).

Cela permet à Java et C# d’intégrer petit à petit des aspects de PF et de montrer que celle-ci n’est absolument pas incompatible avec la POO.

Toujours dans le même registre, C# 9 introduit la notion de mutateur d'initialisation (init setter) qui est une forme particulière de mutateur qui ne peut être appelé qu’une seule fois.

Ainsi, ça donne lieu à des propriétés immutables puisqu’il est impossible de leur assigner une nouvelle valeur après leur initialisation contrairement à un mutateur classique.

public string Name { get; init; }

Ce n’est pas le premier pas vers l’immutabilité en C# qui possédait déjà les mots-clés “const” et “readonly”. Le problème (entre autres) est qu’ils ne concernent que les champs, et non pas les propriétés.

// Champ
public const string FullName = "SushiExpert";

// Champ
public readonly string FirstName;

// Propriété
public string LastName { get; init; }

Évidement, il s’agit encore une fois d’un mouvement stratégique de la part de Microsoft pour développer les principes de la PF en C#, même si bien sûr cela reste très pauvre comparé à F# : la référence des langages de PF pour .NET.

Coté Java, bien que ces principes font leur petit bout de chemin, il se fait largement dépasser par Kotlin ou Scala, deux autres langages OO de la JVM qui poussent la PF beaucoup plus loin.

Malgré tout, j’ai confiance en l’avenir, et étant donné l’évolution extrêmement rapide de Java et C# ces temps-ci (au moins une version majeure par an !), je suis certain que la vraie PF deviendra une réalité dans un futur proche.

À noter que ces améliorations ne sont pas impératives pour faire de la PF. Par exemple, il est possible d’en faire avec C++ bien qu’il ne possède aucune de ces fonctionnalités (et n’a pas l’air trop chaud pour les intégrer). Elle est juste beaucoup moins confortable.

Syntaxe condensée

Une observation que je fais depuis déjà un bout de temps, c’est que le futur tant à s’orienter vers des syntaxes plus courtes et concises, afin de limiter au maximum le nombre de lignes de code.

Ce ne sont pas les exemples qui manquent :

• La montée en popularité de la syntaxe lambda qui a encore eu droit à de multiples améliorations avec C++ 20.

auto kingSizeSushi = [](float size) { return size * 1.65; };

sushi->size = kingSizeSushi(sushi->size);

• L’opérateur => en C# qui permet de condenser encore plus la syntaxe des fonctions.

public void GoKingSize() => this.Size *= 1.65f;

• La montée en puissance de langages comme Scala ou Kotlin qui ont pour mot d’ordre de faire beaucoup en très peu de lignes.

// Fonction en Java
public List<Product> getProductsByCategory(String category) {
    List<Product> products = new ArrayList<Product>();
    for (Order order : orders) {
        for (Product product : order.getProducts()) {
            if (category.equals(product.getCategory())) {
                products.add(product);
            }
        }
    }
    return products;
}

// La même fonction en Scala
def productsByCategory(category: String) = orders.flatMap(o => o.products).filter(p => p.category == category)

• Pour chipoter, l’accolade (si tenté qu’il y en a une) qui a de plus en plus tendance à être placée sur la même ligne, plutôt que d’avoir sa propre ligne. C’est très souvent le cas dans le monde JavaScript.

if(hello != undefined) {
    console.log("Hello World!");
} else {
    console.log("Nothing for you :(");
}

Donc quel avenir pour les langages qui aiment bien causer ? Je ne pense pas qu’ils disparaîtront, car encore un bon nombre de programmeurs aiment les syntaxes explicitent qui ne jouent pas à “qui a la plus courte ?”.

Mais il est fort probable que les prochains langages les plus populaires adoptent ce genre de syntaxe, je prends encore une fois l’exemple de Scala, et même les langages de PF de manière générale qui ont tendance à faire beaucoup sans être très bavards pour autant.

Filtrage par motif (pattern matching)

Il s’agit d’une stratégie de programmation permettant de vérifier si une donnée est au format attendu avant de continuer le programme.

C’est particulièrement pratique pour faire des filtres de valeur (pas de nombres négatifs, pas de zéros, pas de chaînes de plus de 1024 caractères…) et de type (seulement des nombres à virgule, seulement des chaînes de caractères, seulement des objets de type Legume…).

Ce patron de conception continue de prendre de plus en plus d’importance notamment avec les API REST, car on est jamais trop sûr du genre de donnée que l’on va recevoir (toi-même tu connais le ‘; DROP DATABASE db; --).

Ainsi, beaucoup de langages commencent à mettre au point des syntaxes particulières pour faire ce type de vérification plus simplement et de manière plus optimisée, pour ne plus avoir à passer par des if… else if… else…

Pour C# et Java, il s’agit simplement d’une variation de la clause “switch” avec des conditions plus poussées et pouvant retourner des valeurs.

switch (obj) {
    case Garnish g -> AddGarnish(g);
    case Sauce sa  -> AddSauce(sa);
    case Spice sp  -> AddSpice(s);
};

Bonus : bloc de texte

Java 15 introduit une nouvelle notion appelée “bloc de texte”, qui permet d’écrire le contenu d’une chaîne de caractères sur plusieurs lignes, au lieu de concaténer plusieurs chaînes ensemble comme à la vieille époque.

// Avant
string quote = "My sushis are dha best,\n"
             + "fackya all";

// Après
string quote = """
    My sushis are dha best,
    fackya all
""";

J’ai trouvé le concept tellement génial que j’ai directement cherché des alternatives sur d’autres langages, mais j’étais loin d’imaginer que ça existait déjà partout, y compris sur les langages que j’utilise au quotidien :

string quote = @"
    My sushis are dha best,
    fackya all
";

import textwrap
quota = """
    My sushis are dha best,
    fackya all
"""

let quote = `
    My sushis are dha best,
    fackya all
`;

C’est aussi un aspect intéressant de cette petite analyse : même un langage que vous n’utilisez pas peut vous apprendre des choses. Alors, pourquoi s’en priver ?

Conclusion

Pas compliqué, n’est-ce pas ? En tout cas, pas besoin d’avoir fait un doctorat en recherches et démarches scientifiques.

Bien sûr, je vous invite fortement à faire cette petite analyse par vous-même afin de profiter de toutes ces nouvelles croustillantes.

Et il n’y a pas besoin d’y passer 3 heures, c’est quelque chose que vous pouvez faire au jour le jour en vous tenant au courant de l’actualité numérique.

Le plus simple, c’est encore d’avoir un flux RSS : un outil qui va vous permettre d’avoir du contenu quotidien qui arrive directement sur votre ordinateur/téléphone. Comme ça, au lieu d’aller vers l’information, c’est l’information qui vient à vous. C’est pas beau ça ? 😃

En plus de ça, c’est gratos, pas long ni compliqué à mettre en place (il y a des applications toutes faites), et c’est un excellent moyen de s’informer, veiller et progresser.

Pour les gens qui veulent créer ou peaufiner leur flux RSS, je vous ai mis la liste de mes meilleurs blogs et sites de news en informatique dans le bonus de cet article.

Vous y trouvez bien entendu des sites pour suivre l’évolution des langages et vous faire votre propre avis sur le sujet.

Bien sûr, c’est encore plus intéressant quand il s’agit de langages que l’on utilise au quotidien, mais c’est aussi une bonne occasion pour s’ouvrir l’esprit et de sortir de sa zone de confort 😉

Quant à moi, je vous laisse, il faut que j’aille boire une bière avec mon ami joueur de vielle à roue. Je vous donne rendez-vous la semaine prochaine pour un nouvel article sur le blog des développeurs ultra-efficaces !

Accéder au bonus : Les meilleurs blogs et podcasts de développement informatique.