Chapitre 1.
Langage extensible
1.1 Le langage qui se développe dans votre esprit
1.2 Pourquoi Scala est extensible
1.3 Pourquoi Scala ?
1.4 Racines de Scala
1.5 Conclusion


Chapitre 2.
Premiers pas en Scala
2.1 Étape 1 : Apprendre à utiliser l’interpréteur Scala
2.2 Étape 2 : Définissons les variables
2.3 Étape 3 : Définissons une fonction
2.4 Étape 4 : Écrivons un script Scala
2.5 Étape 5 : Bouclez avec while et prenez une décision avec if.
2.6 Étape 6 : Itérons en utilisant foreach et for.
2.7 Conclusion


Chapitre 3.
La deuxième étape de Scala
3.1 Étape 7 : Spécifions un paramètre de type pour le tableau.
3.2 Étape 8 : Utilisons une liste
3.3 Étape 9 : Utilisons des tuples
3.4 Étape 10 : Utilisons des ensembles et des cartes.
3.5 Étape 11 : Apprendre à reconnaître les styles fonctionnels
3.6 Étape 12 : Lire le contenu du fichier ligne par ligne
3.7 Conclusion


Chapitre 4.
Classes et objets
4.1 Classes, champs et méthodes
4.2 Inférence par point-virgule
4.3 Objets singleton
4.4 Applications Scala
4.5 Caractéristiques de l'application
4.6 Conclusion


Chapitre 5.
Types et opérations de base
5.1 Types de base
5.2 Littéral
5.3 Interpolation de chaînes
5.4 Les opérateurs sont des méthodes
5.5 Opérations arithmétiques
5.6 Opérations relationnelles et logiques
5.7 Opérations sur les bits
5.8 Identité de l'objet
5.9 Priorité et associativité des opérateurs
5.10 Rappeur riche
5.11 Conclusion


Chapitre 6.
objets fonctionnels
6.1 Spécifications de classe de fraction
6.2 Création rationnelle
6.3 Réimplémentation de la méthode toString
6.4 Vérifier les prérequis
6.5 Champs ajoutés
6.6 Auto-référence
6.7 Constructeurs auxiliaires
6.8 Champs et méthodes privés
6.9 Définitions des opérateurs
6.10 Identificateurs en Scala
6.11 Surcharge de méthode
6.12 Conversion de type implicite
6.13 Précautions
6.14 Conclusion


Chapitre 7.
Instructions de contrôle intégrées
7.1 Expressions if
7.2 boucle while
7.3 pour les expressions
7.4 Gestion des exceptions avec les expressions try
7.5 expression de correspondance
7.6 Vivre sans interruption ni déclaration de continuité
7.7 Portée variable
7.8 Code de style impératif de refactorisation
7.9 Conclusion


Chapitre 8.
Fonctions et fermetures
8.1 Méthode
8.2 Fonctions locales
8.3 Fonctions hiérarchiques de première classe
8.4 Formes simples de littéraux de fonction
8.5 Grammaire des indicateurs positionnels
8.6 Fonction partiellement appliquée
8.7 Fermeture
8.8 Formes particulières d'appels de fonction
8.9 Récursivité terminale
8.10 Conclusion


Chapitre 9.
abstraction du contrôle de flux
9.1 Réduction de la duplication du code
9.2 Simplification du code client
9.3 Curling
9.4 Écriture d'une nouvelle structure de contrôle
9.5 Appel des paramètres par leur nom
9.6 Conclusion


Chapitre 10.
Héritage et composition
10.1 Bibliothèque de mises en page 2D
10.2 Classes abstraites
10.3 Définition d'une méthode sans paramètres
10.4 Extensions de classe
10.5 Remplacement des méthodes et des champs
10.6 Définition des champs de paramètres
10.7 Appel du constructeur de la superclasse
10.8 Utilisation du modificateur de remplacement
10.9 Polymorphisme et liaison dynamique
10.10 Déclaration finale des membres
10.11 Utilisation de l'héritage et de la composition
10.12 Ci-dessus, à côté, l'implémentation de toString
10.13 Définition d'un objet Factory
10.14 Réglage de la hauteur et de la largeur
10.15 Collecte et test
10.16 Conclusion


Chapitre 11.
La hiérarchie de Scala
11.1 Hiérarchie des classes de Scala
11.2 Comment avez-vous implémenté plusieurs classes de base ?
11.3 Tapez sur le sol
11.4 Définir sa propre classe de valeurs
11.5 Conclusion


Chapitre 12.
trait
12.1 Fonctionnement des traits
12.2 Interface simple et riche
12.3 Exemple : Objet Rectangle
12.4 Caractéristiques ordonnées
12.5 Cumul des modifications à l'aide de traits
12.6 Pourquoi l'héritage multiple n'est-il pas autorisé ?
12.7 Être ou ne pas être un trait, telle est la question
12.8 Conclusion


Chapitre 13.
Colis et importations
13.1 Écrire du code à l'intérieur d'un package
13.2 Accès concis au code associé
13.3 Import
13.4 Importations implicites
13.5 Modificateurs d'accès
13.6 Objets du paquet
13.7 Conclusion


Chapitre 14.
Assertions et tests
14.1 Déclarations affirmatives
14.2 Tests en Scala
14.3 Signalement des défaillances fournissant des informations suffisantes
14.4 Tests avec spécifications
14.5 Tests basés sur les propriétés
14.6 Organisation et exécution des tests
14.7 Conclusion


Chapitre 15.
Classes de cas et correspondance de modèles
15.1 Un exemple simple
15.2 Types de motifs
15.3 Protection de motif
15.4 Chevauchement de motifs
Classe scellée 15.5
15.6 Type d'option
15.7 Les motifs sont partout
15.8 Exemples complexes
15.9 Conclusion


Liste du chapitre 16
16.1 Liste des littéraux
16.2 Type de liste
16.3 Création d'une liste
16.4 Opérations de base sur les listes
16.5 Modèles de listes
16.6 Méthode principale de la classe List
16.7 Méthodes d'ordre supérieur de la classe List
16.8 Méthodes de l'objet Liste
16.9 Traitement simultané de plusieurs listes
16.10 Comprendre l'algorithme d'inférence de type de Scala
16.11 Conclusion


Chapitre 17.
Collection
17.1 Séquence
17.2 Ensembles et cartes
17.3 Collections mutables et immuables
17.4 Initialisation de la collection
17,5 Tuples
17.6 Conclusion


Chapitre 18.
objets mutables
18.1 Qu'est-ce qui rend un objet mutable ?
18.2 Variables et propriétés réassignables
18.3 Étude de cas : Simulation d'événements discrets
18.4 Langage pour circuits numériques
18.5 API de simulation
18.6 Simulation de circuit
18.7 Conclusion


Chapitre 19.
Paramétrage de type
19.1 Files d'attente fonctionnelles
19.2 Dissimulation d'informations
19.3 Notation modifiée
19.4 Vérification de la notation mutée
19,5 Limite inférieure
19.6 Anticommutation
19.7 Données privées des objets
19,8 Limite supérieure
19.9 Conclusion


Chapitre 20.
membre abstrait
20.1 Un bref aperçu des membres du résumé
20.2 Type Membre
20.3 Valeur abstraite
20.4 Variable abstraite
20.5 Initialisation de la valeur abstraite
20.6 Types abstraits
20.7 Types dépendants du chemin
20.8 Type subdivisé
20.9 Énumérations
20.10 Étude de cas : Conversion de devises
20.11 Conclusion


Chapitre 21.
Conversions implicites et paramètres implicites
21.1 Conversion implicite
21.2 Règles d'implication
21.3 Conversion implicite vers le type attendu
21.4 Conversion de l'objet cible de l'appel
21.5 Paramètres implicites
21.6 Limites du contexte
21.7 Lors de l'utilisation de plusieurs transformations
21.8 Débogage implicite
21.9 Conclusion


Chapitre 22.
Implémentation de liste
22.1 Aperçu de la classe Liste
22.2 Classe ListBuffer
22.3 Liste réelle des classes
22.4 Fonctionnel vu de l'extérieur
22.5 Conclusion


Chapitre 23.
Examen de l'expression for
23.1 pour les expressions
23.2 n Problème de la reine
23.3 Requête avec la formule for
23.4 pour la conversion d'expressions
23.5 Application inverse
23.6 pour la généralisation
23.7 Conclusion
Un regard plus attentif sur le chapitre 24, collection 577
24.1 Collections mutables et immuables
24.2 Cohérence de la collecte
24.3 Caractéristique itérable
24.4 Caractéristiques des séquences : Seq, IndexedSeq, LinearSeq
Ensemble de 24,5
Carte 24.6
24.7 Classes de collections concrètes immuables
24.8 Classes de collections de béton mutables
24.9 tableaux
24.10 Chaîne
24.11 Caractéristiques de performance
24.12 Identité
24,13 vues
24.14 Itérateur
24.15 Créer votre première collection
24.16 Conversion des collections Java et Scala
24.17 Conclusion
Chapitre 25 : Architecture des collections Scala 647
25.1 Regroupement des opérations communes
25.2 Ajout d'une nouvelle collection
25.3 Conclusion


Chapitre 26.
extracteur
26.1 Exemple : Extraction d'adresses électroniques
26.2 Extracteur
26.3 Modèles sans variable ou avec une seule variable
26.4 Extracteur d'arguments variables
26.5 Extracteurs et modèles de séquences
26.6 Extracteur et classes de cas
26.7 Expressions régulières
26.8 Conclusion


Chapitre 27.
Annotation
27.1 Pourquoi des annotations sont-elles nécessaires ?
27.2 Grammaire d'annotation
27.3 Annotations standard
27.4 Conclusion


Chapitre 28. Travailler avec XML
28.1 Données semi-structurées
28.2 Aperçu XML
28.3 Littéraux XML
28.4 Sérialisation
28.5 Analyse XML
28.6 Désérialisation
28.7 Sauvegarde et chargement
28.8 Correspondance de modèles pour XML
28.9 Conclusion


Chapitre 29.
Programmation modulaire utilisant des objets
Problème 29.1
29.2 Application de recette
29.3 Abstraction
29.4 Séparation des modules en traits
29.5 Liaison d'exécution
29.6 Instances du module de suivi
29.7 Conclusion


Chapitre 30.
identité des objets
30.1 Identité en Scala
30.2 Écrire une méthode de comparaison d'identité
30.3 Définition de l'identité des types paramétrés
30.4 Recettes Equals et HashCode
30.5 Conclusion


Chapitre 31.
Combiner Scala et Java
31.1 Utilisation de Scala en Java
31.2 Annotations
31.3 Types de caractères génériques
31.4 Compilation conjointe de Scala et Java
31.5 Intégration de Java 8
31.6 Conclusion


Chapitre 32.
Futur et simultanéité
32.1 Troubles au paradis
32.2 Exécution asynchrone et essai
32.3 Utilisation du futur
32.4 Test futur
32.5 Conclusion


Chapitre 33.
Analyse combinatoire
33.1 Exemple : Expressions arithmétiques
33.2 Exécution de l'analyseur syntaxique
33.3 Analyseur d'expressions régulières de base
33.4 Autre exemple : JSON
33.5 Résultats de l'analyseur
33.6 Implémentation de l'analyseur syntaxique combinatoire
33.7 Chaînes littérales et expressions régulières
33.8 Analyse lexicale et syntaxique
33.9 Rapport d'erreur
33.10 Retour arrière et LL(1)
33.11 Conclusion


Chapitre 34. Programmation d'interfaces graphiques
34.1 Première application Swing
34.2 Panneaux et agencements
34.3 Gestion des événements
34.4 Exemple : Convertisseur Celsius/Fahrenheit
34.5 Conclusion


Chapitre 35. Feuille de calcul SCells
35.1 Cadre d'écran
35.2 Séparation de la saisie des données et de l'affichage à l'écran
35,3 aliments
Analyse du type 35.4
35,5 calcul
35.6 Bibliothèque d'opérations
35.7 Propagation du changement
35.8 Conclusion


Annexe A.
Utilisation de scripts Scala sous Unix et Windows
Annexe B.
Glossaire des termes
Annexe C.
Références

★ Article recommandé ★

Lorsque j'ai commencé à programmer en 2004 et que j'ai choisi Scala, un langage alors peu connu, je n'avais aucune idée du voyage d'exploration et de découverte dans lequel je m'embarquais.


Lorsque j'ai commencé à expérimenter avec Scala, j'ai eu l'impression que cela ressemblait beaucoup à n'importe quel autre langage que j'avais utilisé auparavant, mais c'était un processus d'essais et d'erreurs, de découverte par l'expérimentation et d'illumination après des malentendus.
À l'époque, il existait très peu de documentation pour apprendre Scala, pas de tutoriels, pas de blogs et aucun utilisateur de Scala suffisamment expérimenté pour me l'enseigner.
Bien sûr, il n'existait pas de livre comme 『Programming in Scala』.
Il existait des langages qui offraient de nouvelles fonctionnalités extraordinaires, mais personne ne savait vraiment comment les utiliser correctement.
Cette situation était à la fois inspirante et déconcertante !

En tant que développeur Java, j'avais une idée du style de programmation, mais l'expérience de coder en Scala au quotidien était différente.
Je me souviens de mes premières aventures, de mon apprentissage de Scala et de ma collaboration sur des projets de taille moyenne avec d'autres personnes.
Il y a eu des moments où j'ai décidé de remanier le code (et j'ai dû le faire assez souvent au fur et à mesure que je découvrais et apprenais de nouvelles fonctionnalités et de nouveaux modèles), et des moments où j'ai dû compiler plusieurs fois.

Le compilateur génère à chaque fois diverses erreurs, ainsi que les numéros de ligne du code source.
À chaque fois, je regardais le code, je cherchais ce qui n'allait pas, puis je modifiais le code pour corriger l'erreur (bien sûr, souvent l'erreur se déplaçait à un autre endroit au fur et à mesure que je modifiais le code).
Mais à chacune de ces étapes, le compilateur m'a conduit directement à la racine du problème.
Il m'est arrivé de passer des jours à essayer de modifier le code sans jamais réussir à le compiler.
Mais j'ai réussi à faire fonctionner mon logiciel, fortement remanié, pour la première fois, en réduisant le nombre d'erreurs de compilation de quelques centaines à une douzaine, puis en réduisant ces erreurs à une seule, et enfin en les éliminant complètement (ce qui signifie qu'il a été compilé avec succès).

Et contrairement à mes attentes, le code compilé a fonctionné parfaitement dès le départ.
En tant que jeune programmeur n'ayant expérimenté que Java, Perl, Pascal, Basic, PHP et JavaScript, je ne peux exprimer avec des mots à quel point cette expérience a été impressionnante.
Dans son discours d'ouverture à la conférence Scala World que j'ai organisée en 2015, Runar Bjarnason a soutenu que « les contraintes donnent la liberté, et la liberté impose des contraintes ».
Cette vérité est particulièrement évidente lors de la compilation en Scala.
L'objectif principal de scalac, en imposant diverses contraintes, est d'empêcher les programmeurs de commettre des erreurs susceptibles de se produire lors de l'exécution (et ce sont les pires de toutes les erreurs), ce qui libère tous les programmeurs.
Cela permet aux programmeurs d'expérimenter, d'explorer et de modifier le logiciel en toute confiance, même sans suite de tests complète.

Des années ont passé depuis, et aujourd'hui encore, je continue d'apprendre Scala, découvrant de nouvelles possibilités, des différences sémantiques subtiles et des interactions intéressantes entre différentes fonctionnalités.
Je ne connais aucun autre langage de programmation qui offre une telle profondeur et qui permette de maintenir l'intérêt des utilisateurs pendant tant d'années.

Scala est sur le point de connaître une période de changements considérables.
La prochaine version majeure, Scala 3, contiendra autant de changements que lorsque je suis passé de Java à Scala 2 il y a 15 ans.
Bien que l'expérience de programmation quotidienne avec Scala reste globalement la même, Scala 3 apporte un ensemble de nouvelles fonctionnalités qui couvrent la quasi-totalité du langage Scala.
À l'heure où nous écrivons ces lignes, Scala 3 n'est pas près d'être largement adopté, et Scala 2 restera probablement la norme de facto dans un avenir prévisible.

Ce livre couvre en détail la dernière version de Scala 2, Scala 2.13.
Nous présentons également la bibliothèque de collections, qui a été repensée et intégrée à la bibliothèque standard afin de simplifier davantage sa structure tout en intégrant les enseignements tirés de la refonte majeure introduite dans Scala 2.8.
La nouvelle bibliothèque de collections peut être compilée en Scala 2 et 3.
Cette bibliothèque de collections constituera donc la base du code qui sera utilisé pendant les 10 prochaines années.
Alors, avant de vous enthousiasmer pour le nouveau Scala, c'est le moment idéal pour vous procurer ce livre et commencer à apprendre !

Jon Pretty
Cracovie, Pologne, 12 septembre 2019


★ Public cible de ce livre ★

Le public cible principal est constitué de programmeurs qui souhaitent apprendre à écrire des programmes en Scala.
Si vous souhaitez aborder votre prochain projet en Scala, ce livre est fait pour vous.
Les programmeurs désireux d'élargir leurs horizons en apprenant de nouveaux concepts trouveront également ce livre agréable.
Par exemple, un programmeur Java peut apprendre divers concepts de programmation fonctionnelle et des idées orientées objet plus avancées en lisant ce livre.
Je suis convaincu qu'après avoir appris Scala et ses concepts, vous deviendrez assurément un meilleur programmeur.

Nous supposons que le lecteur possède des connaissances générales en programmation.
Bien que Scala soit un bon langage pour débuter l'apprentissage de la programmation, ce livre ne vous apprend pas à programmer.
Toutefois, aucune connaissance préalable d'un langage de programmation n'est requise.
Bien que la plupart des programmeurs utilisent Scala sur la plateforme Java, nous ne supposons pas que les lecteurs aient des connaissances en Java.
Cependant, comme nous supposons que de nombreux lecteurs connaissent Java, nous comparerons occasionnellement Java et Scala afin d'aider les lecteurs familiers avec le développement Java à comprendre.


★ Structure de ce livre ★

Le chapitre 1, « Langage extensible », explique la conception de Scala et sa justification, et fournit un historique général.
Le chapitre 2, « Premiers pas en Scala », montre comment gérer les tâches de programmation de base en Scala.
Je n'entrerai pas dans les détails sur le fonctionnement de chacune.
L'objectif du chapitre 2 est d'amener le lecteur à saisir et à exécuter du code Scala.
Le chapitre 3, « Scala : Deuxièmes étapes », présente des tâches de programmation plus basiques pour vous aider à vous familiariser plus rapidement avec Scala.
Après avoir terminé le chapitre 3, vous serez capable d'utiliser Scala pour des tâches de script simples.
Le chapitre 4, « Classes et objets », détaille les éléments constitutifs de base orientés objet de Scala et montre comment compiler et exécuter des applications Scala.
Le chapitre 5, « Types de base et opérations », explique les types de base de Scala et leurs littéraux.
Et il explique les opérations, les règles de priorité et d'associativité qui peuvent être utilisées pour chaque type.
Enfin, parlons de l'enveloppe luxueuse.
Le chapitre 6, « Objets fonctionnels », approfondit les aspects orientés objet de Scala.
Prenons comme exemple un nombre rationnel fonctionnel immuable.
Le chapitre 7, « Instructions de contrôle intégrées », montre comment utiliser les structures de contrôle fournies par Scala : if, while, for, try et match.
Le chapitre 8, « Fonctions et fermetures », détaille les fonctions, les éléments constitutifs de base des langages fonctionnels.
Le chapitre 9, « Abstractions du flux de contrôle », explique comment les lecteurs peuvent créer leurs propres abstractions de contrôle pour compléter les structures de contrôle de base de Scala.
Le chapitre 10, « Héritage et composition », explique comment Scala prend en charge la programmation orientée objet.
Les sujets abordés ne sont pas aussi fondamentaux que ceux du chapitre 4, mais ils sont plus fréquemment rencontrés dans la pratique.
Le chapitre 11, « La hiérarchie de Scala », explique la hiérarchie d'héritage de Scala et les méthodes communes et les types de base disponibles dans toutes les hiérarchies.
Le chapitre 12, « Traits », traite du mécanisme de combinaison des mixins en Scala.
Le chapitre 12 explique le fonctionnement des traits, décrit les cas d'utilisation courants et montre comment les traits améliorent l'héritage multiple traditionnel.
Le chapitre 13, « Packages et importations », aborde les problèmes qui surviennent dans la programmation à grande échelle.
Décrit les paquets de niveau supérieur, les commandes d'importation et les modificateurs de contrôle d'accès tels que protected et private.
Le chapitre 14, « Assertions et tests », couvre le mécanisme d'assertion de Scala et explore brièvement plusieurs outils de test disponibles en Scala.
Nous nous concentrerons notamment sur ScalaTest.
Le chapitre 15, « Classes de cas et correspondance de modèles », introduit une paire de constructions qui permettent d'écrire des structures de données communes non encapsulées.
En particulier, les classes de cas et les correspondances de modèles sont utiles lors de la création de données récursives telles que des structures arborescentes.
Le chapitre 16, « Listes », détaille les listes, la structure de données la plus couramment utilisée dans les programmes Scala.
Le chapitre 17, « Collections », montre comment utiliser les collections Scala de base telles que les listes, les tableaux, les tuples, les ensembles et les maps.
Le chapitre 18, « Objets mutables », explique les objets mutables et apprend comment les exprimer en Scala.
La dernière partie du chapitre 18 traite de la simulation d'événements discrets, qui utilise concrètement des objets mutables.
Le chapitre 19, « Paramétrage de type », explique certaines des techniques de dissimulation d'informations introduites au chapitre 13 avec des exemples spécifiques.
Par exemple, créer une classe de file d'attente entièrement fonctionnelle.
Le chapitre 19 explique la variance des paramètres de type et discute de la relation entre la variance et la dissimulation d'informations.
Le chapitre 20, « Membres abstraits », décrit tous les membres abstraits pris en charge par Scala.
Non seulement les méthodes, mais aussi les champs et les types peuvent être définis comme des membres abstraits.
Le chapitre 21, « Conversions implicites et paramètres implicites », introduit deux éléments qui aident le compilateur à fournir aux programmeurs les informations nécessaires en leur permettant d'omettre des parties potentiellement fastidieuses de leur code source.
Le chapitre 22, « Implémentation de la classe List », explique l'implémentation de la classe List.
Il est important de comprendre comment fonctionnent les listes Scala.
De plus, cette implémentation démontre également comment tirer parti de certaines fonctionnalités de Scala.
Le chapitre 23, « Revisiter l’expression for », montre comment l’expression for peut être convertie en commandes qui appellent map, flatMap, filter, foreach, etc.
Le chapitre 24, « Un regard plus attentif sur les collections », fournit une explication détaillée de la bibliothèque de collections Scala.
Le chapitre 25, « L'architecture des collections Scala », montre comment nous avons construit la bibliothèque de collections et explique comment vous pouvez implémenter vos propres collections.
Le chapitre 26, « Extracteur », montre comment effectuer une correspondance de modèles sur des classes arbitraires, et pas seulement sur des classes de cas.
Le chapitre 27, « Annotations », montre comment utiliser les extensions de langage grâce aux annotations.
Nous aborderons les annotations standard et la manière de créer les vôtres.
Le chapitre 28, « Manipulation de XML », explique comment manipuler du XML en Scala. Il présente plusieurs méthodes pour générer, analyser et traiter du XML.
Le chapitre 29, « Programmation modulaire avec les objets », montre comment utiliser les objets de Scala comme système de modules.
Le chapitre 30, « Identité de l'objet », explique ce qu'il faut prendre en compte lors de l'écriture d'une méthode equals.
Il y a quelques pièges à éviter.
Le chapitre 31, « Combiner Scala et Java », aborde les problèmes qui surviennent lors de l’utilisation conjointe de Scala et de Java dans un même projet et propose des solutions.
Le chapitre 32, « Futures et concurrence », montre comment utiliser les Futures en Scala.
Bien que vous puissiez tirer parti des primitives et bibliothèques de concurrence de Java dans vos programmes Scala, l'utilisation des futures vous aide à éviter les interblocages et les conditions de concurrence qui affectent souvent les approches traditionnelles « threads et verrous ».
Le chapitre 33, « Analyse syntaxique par combinateurs », montre comment construire un analyseur syntaxique à l'aide de la bibliothèque d'analyseurs combinateurs de Scala.
Le chapitre 34, « Programmation d'interfaces graphiques », présente le processus de programmation d'interfaces graphiques Swing simples à l'aide de la bibliothèque Scala.
Le chapitre 35, « SCells Spreadsheet », rassemble ce que vous avez appris jusqu'à présent pour créer une application de tableur complète en Scala.


★ Note de l'auteur ★

Ce livre étant un tutoriel, il est recommandé de le lire de manière séquentielle, du début à la fin.
Nous avons tout mis en œuvre pour n'introduire qu'un seul sujet à la fois et pour expliquer les nouveaux sujets en nous basant sur ce qui a été décrit précédemment.
Ainsi, si vous deviez feuilleter un livre jusqu'à la fin pour avoir un aperçu rapide d'un sujet, vous pourriez avoir du mal à le comprendre car il est probablement expliqué à l'aide de concepts qui vous sont inconnus.
En lisant chaque chapitre dans l'ordre, vous pourrez facilement développer vos compétences en Scala, étape par étape.
Si vous rencontrez un terme que vous ne connaissez pas, consultez les sections « Recherche » et « Glossaire ».
Certains lecteurs se contenteront peut-être de parcourir le livre en diagonale.
Ce n'est pas grave.
Les fonctions « Recherche » et « Glossaire » vous aideront à réexaminer les passages que vous auriez pu négliger.
Ce livre peut servir de référence linguistique même après une seule lecture.
Bien qu'il existe une spécification formelle pour le langage Scala, cette spécification sacrifie la lisibilité à la correction.
Bien que ce livre ne couvre pas tous les détails de Scala, il aborde un large éventail de sujets et constituera une référence pratique pour votre langage à mesure que vous progresserez en programmation Scala.


★ Note du traducteur ★

Même en 2014, lorsque j'ai traduit la deuxième édition de 『Programming in Scala』, l'intérêt pour Scala n'était pas si grand en Corée.
Cependant, à peu près au même moment où la deuxième édition est sortie, Apache Spark a gagné en popularité et le nombre de startups technologiques a augmenté, entraînant une augmentation rapide de l'intérêt pour des langages comme Python et Scala, plus faciles à utiliser que des langages comme Java.
Par conséquent, le nombre de développeurs rejoignant la communauté Scala a augmenté, et Scala a bénéficié d'une attention accrue dans divers groupes d'étude et séminaires.
À mesure que les versions de Scala augmentent, certaines fonctionnalités utilisées dans les versions plus anciennes sont supprimées, certains termes ou usages ont changé et de nouvelles fonctionnalités sont introduites.
Tout comme les langues courantes telles que le coréen et l'anglais évoluent, le fait que les langages de programmation adoptent naturellement de tels changements en fonction de leur environnement d'utilisation ou des besoins des utilisateurs témoigne de la santé et du dynamisme d'une langue et de sa communauté.
Je suis particulièrement heureux de pouvoir traduire et publier la 4e édition, qui a été repensée pour être plus simple et qui a complété le contenu de la bibliothèque de la collection avant la sortie de Scala 3 (Dotty).
Comme je l'ai mentionné dans la note du traducteur de la troisième édition, l'utilisation de langages de paradigmes différents peut faire de vous un meilleur programmeur, que vous fassiez de la programmation procédurale ou orientée objet.
À travers ce livre, j'espère que les lecteurs apprendront bien Scala, appliqueront leurs connaissances en Scala et en programmation fonctionnelle, et deviendront des programmeurs capables de créer du code lisible et maintenable en utilisant les bons concepts au bon moment, quel que soit le langage de programmation utilisé.

Oh Hyeon-seok
Décembre 2020 à Brisbane, Australie