Les recettes de la programmation

Table des matières

Introduction
Les structures
Les patrons de conception

Introduction

Depuis l'invention des ordinateurs et des logiciels, le monde du développement a connu une évolution fulgurante.

Mais aujourd'hui, et malgré le fait qu'il y ait toujours plus de nouveaux langages, toujours plus de nouveaux frameworks et toujours plus de nouveaux outils, le métier de développeur n'évolue plus autant qu'à ses débuts.

Ecrire du code de nos jours revient à manipuler 3 choses:

Des séquences (des instructions à la suite)
Des conditions
Des boucles

Apprenez ces 3 choses, et vous saurez rudimentairement écrire n'importe quel programme.

Un petit exemple en javascript pour illustrer mes propos.

./main.js

// Les séquences

// Ce sont simplement les lignes de codes, les unes à la suite des autres.
// Elles peuvent être des déclarations de variables, des affectations, ou encore des appels de fonction.

// Déclaration de variable
let myVar;

// Affectation de variable
myVar = 3;

// Appel de fonction
doSomething();

// Les conditions

// Ce sont des séquences soumises à des conditions.
// Elles représentent une bifurcation du code avec N chemins possibles

// La condition "if"
if (myVar === 3) {
    doSomethingAgain();
} else {
    doSomethingElse();
}

// Les boucles

// Ce sont des séquences soumises à une répétition.
// L'itération du code se fait aussi via une condition.

// La boucle "for"
for (let i = 0; i < 100; i++) {
    write("I'll test my code");
}

// L'itération avec la fonction "each"
myArray.each(item => write("item: " + item.toString()))

Les structures

Une fois les basiques maîtrisés, il faut commencer à structurer son code. Quand un projet grossit, il devient vite illisible.

Pour cela, on peut utiliser les structures

Les fonctions
Les objets

Quand une séquence ou une partie d'une séquence peut être résumée en une phrase simple, ou un groupe de mots, c'est qu'elle est une bonne candidate pour devenir une fonction

./without-function.js

let scream = true;
let result = '';
let name = 'Vincent';

result = 'Hello ' + name;
if (scream) {
    result = result + ' !';
}

Ce morceau de code pourrait être transformé comme ceci

./with-function.js

function sayHello(name, scream = false) {
    result = 'Hello ' + name;
    if (scream) {
        result = result + ' !';
    }
    return 
}

console.log(
    sayHello('Vincent', true)
);

Quand des fonctions et des variables travaillent de manière répétée entre elles, c'est qu'elles sont de bonnes candidates pour devenir une class.

./without-class.js

let myVar = 0;

function print(index) {
    console.log('index: ' + index)
}

function increment(number) {
    return number + 1;
}

for (let i = 0; i < 10; i++) {
    increment(myVar);
    print(myVar)
}

Ce morceau de code pourrait être transformé comme ceci

./with-class.js

class Counter {
    private myVar = 0;

    function print() {
        console.log('index: ' + this.myVar)
    }

    function increment() {
        this.myVar++;
    }

    function execute() {
        for (let i = 0; i < 10; i++) {
            this.increment();
            this.print()
        }
    }
}

let myCounter = new Counter();
myCounter.execute();

Les patrons de conception

Une autre étape à passer lors de son apprentisage est l'étape des patrons de conception (design pattern).

Les problèmes que rencontrent un développeur au cour de sa carrière sont souvent redondants. Souvent, d'autres personnes ont déjà trouvé la solution à ces problèmes.

C'est là que le patron de conception entre en jeu.

Le Singleton
L'Observer
La Factory
...

Je ne les liste pas ici mais je laisse un lien vers un excellent site qui en repertori quelques uns:

https://refactoring.guru/fr/design-patterns