Salut ! Déjà lundi 4 août, ça va super vite ! Bientôt il sera temps de sortir les pulls d’hiver… 😅

Jour 52 de formation et 29ème jour des 100 Days of SwiftUI. Le week-end s’est bien passé, on a vu des amis et on a un peu traînassé le dimanche. Aujourd’hui, on continue l’aventure avec un nouveau projet qui va nous montrer la manipulation des fichiers et des chaînes de caractères, ainsi que comment importer des fichiers dans la codebase avec Xcode.

# Apprentissages du jour : manipulation de fichiers et chaînes

## Nouveau projet : Word Scramble

Aujourd’hui, on a vu la théorie avec Paul, et demain on mettra en pratique. Le petit software qu’on va développer sera un Word Scramble, une sorte de WordGuessr pour deviner des mots.

## Lecture de fichiers depuis le Bundle

func testBundles() {
    if let fileURL = Bundle.main.url(forResource: "somefile", withExtension: "txt") {
        if let fileContent = try? String(contentsOf: fileURL) {
            print(fileContent)
        }
    }
}

## Manipulation de chaînes de caractères

func testStrings() {
    let input = """
    a
    b
    c
    """
    let letters = input.components(separatedBy: "\n")
    let letter = letters.randomElement()
    
    let trimmed = letter?.trimmingCharacters(in: .whitespacesAndNewlines)
}

## Vérification orthographique avec UITextChecker

Un concept intéressant découvert aujourd’hui : la vérification d’orthographe en 4 étapes :

let word = "swift"
let checker = UITextChecker()

let range = NSRange(location: 0, length: word.utf16.count)
let mispelledRange = checker.rangeOfMisspelledWord(in: word, range: range, startingAt: 0, wrap: false, language: "en")

// Info : Obj-C n'a pas le concept d'Optional, il envoie NSNotFound
let allGood = mispelledRange.location == NSNotFound

Point important : Objective-C n’a pas le concept d’Optional, il utilise NSNotFound à la place.

## Optimisation des performances avec @State

J’ai suspecté qu’une fonction se chargeait à chaque refresh, ce qui pouvait causer des problèmes de performance :

Version problématique (fonction appelée dans body) :

struct ContentView: View {
    var body: some View {
        VStack {
            List(testBundles(), id: \.self) { word in
                // Contenu...
            }
        }
    }
    
    func testBundles() -> [String] {
        // Lecture de fichier à chaque refresh !
    }
}

Version optimisée avec @State et onAppear :

struct ContentView: View {
    @State private var words: [String] = []
    
    var body: some View {
        VStack {
            List(words, id: \.self) { word in
                if word.contains("c") {
                    Text("\(word)")
                        .fontWeight(.bold)
                } else {
                    Text("\(word)")
                }
            }
        }.onAppear {
            loadWords()
        }
    }
     
    func loadWords(){
        guard let fileURL = Bundle.main.url(forResource: "start", withExtension: "txt"), 
              let fileContent = try? String(contentsOf: fileURL) else {
            words = []
            return
        }
        words = fileContent.components(separatedBy: .newlines)
    }
}

# Réflexions sur l’apprentissage

Ce matin, c’était un petit peu, la théorie était assez légère, mais j’en ai profité pour essayer de remettre en pratique ce que j’avais appris. J’ai implémenté ces concepts sur le petit projet ContactHive que je suis en train de refactoriser petit à petit en Swift et SwiftUI.

Ça avance ! J’ai l’impression que ce que j’ai fait est assez cohérent. C’est juste un nouveau prototype, codé à la main sans les outils d’intelligence artificielle. Mais j’ai l’impression qu’on arrive plus vite à un résultat.

## Comparaison avec mes débuts

Si je compare avec mes 5 mois de développement sur la première application… OK, le scope était beaucoup plus grand, mais je suis arrivé très vite à quelque chose de fonctionnel cette fois.

Je me rends compte maintenant de l’erreur que j’ai faite à l’époque : j’ai voulu trop over-engineer. Je suis arrivé avec quelque chose qui n’était pas bon, et je ne savais pas trop où j’allais. J’ai dû refaire plusieurs fois marche arrière et marche avant.

Mais ici, j’ai déjà l’expérience avec l’application. J’avais fait des mockups, des designs, des prototypes HD. Ça me permet de faire un petit peu d’exercice dessus, donc ça avance pas mal.

# Avancement sur les projets portfolio

## Finalisation de Fidelity App

Cet après-midi, j’ai continué à finaliser l’application de fidélité. C’est la dernière semaine pour la finaliser et je pense que j’aurai fini demain.

Aujourd’hui, j’ai :

• Créé la page d’étude de cas
• Publié l’étude de cas
• Fait une petite vidéo
• Corrigé les deux derniers bugs qui restaient (workflow qui ne fonctionnait pas correctement et statuts mal répliqués)
• Corrigé des bugs dans le README du repository public

Demain, je ferai une rétrospective sur ce qui s’est bien passé et ce qui ne s’est pas bien passé pour le projet. Et si j’ai terminé, je commencerai directement à implémenter la deuxième application. Vu qu’il me reste 4 jours, autant avancer !

# Expérimentation : du Vibe Coding au Context Engineering

En parallèle, je suis toujours en train de tester un petit projet de Vibe Coding sur le côté. C’est plutôt une expérimentation : je mets en place un client-serveur pour un pseudo-jeu multijoueur en ligne. C’est juste pour jouer, il n’y a vraiment rien de concret.

## Le paradigme qui change

Ce qui est super intéressant, c’est qu’il y a vraiment un shift au niveau de comment les gens interagissent avec l’intelligence artificielle, dans ce cas-ci Claude Code et tous les agents de codage.

• Avant : on faisait du Vibe Coding, on ne réfléchissait pas, on brûlait les tokens
• Maintenant : on est plus dans la rationalisation. On ne parle plus de Vibe Coding, on parle de Context Engineering

## Le Context Engineering expliqué

Le Context Engineering, c’est lorsqu’on utilise plusieurs techniques pour optimiser au maximum les informations qu’on donne au LLM, afin d’éviter de brûler des tokens - parce que les modèles de langage LLM coûtent cher.

Par exemple, avec Claude et des forfaits qui sont déjà limités : plus on est vague, plus l’outil va devoir chercher par lui-même et plus il va récupérer des informations qui vont s’ajouter au contexte. Ce contexte va devenir de plus en plus grand, ce qui :

• Rend le tout moins efficace
• Coûte plus cher

## Réflexions sur l’avenir du développement

J’ai vraiment avancé dans la compréhension de cette nouvelle façon de travailler.

Il va falloir se faire à l’idée qu’à un certain moment, on ne codera plus nous-mêmes.

Et ok, aujourd’hui je suis en train d’apprendre à coder parce que j’en ai besoin. Mais dans le futur, je ne vais pas me voiler la face : je vais utiliser aussi les outils d’intelligence artificielle. Et probablement, si je veux rester compétitif, il faudra que je les adopte.

Je pense que c’est important d’étudier cette façon de travailler en faisant des expérimentations. Ça ne m’engage à rien, je suis en formation. Je fais ça le soir, le matin ou pendant la pause du midi.

Et franchement, c’est super intéressant !

Voilà pour la journée d’aujourd’hui. On se dit à demain pour la mise en pratique du Word Scramble !

Alessandro