Apple a officiellement lancé Swift 6.2, la prochaine étape majeure dans l'évolution de son puissant langage de programmation. Cette version introduit de nouvelles fonctionnalités, améliore la gestion de la concurrence, renforce l'interopérabilité entre les langages et optimise les performances à grande échelle. Cette mise à jour apporte également des changements significatifs qui auront une incidence sur la manière dont les développeurs structureront et écriront leur code à l'avenir, qu'ils créent des applications dans l'écosystème Apple ou qu'ils intègrent Swift dans des environnements côté serveur et multiplateformes.Swift est un langage de programmation compilé, polyvalent, multi-paradigme et de haut niveau, créé par Chris Lattner en 2010 pour Apple Inc. et maintenu par la communauté open source. Swift compile en code machine et utilise un compilateur basé sur LLVM. Le langage a été lancé pour la première fois en juin 2014 et la chaîne d'outils Swift est intégrée à Xcode depuis la version 6 de Xcode, sortie en septembre 2014.
Swift 6.2 introduit des mises à jour axées sur la programmation concurrente, les performances et l'amélioration des outils de développement. Cette version rend la programmation concurrente plus accessible en utilisant par défaut un fonctionnement à thread unique et en proposant des fonctions asynchrones intuitives, ce qui permet aux développeurs d'écrire du code concurrent sécurisé avec moins de code standard.
Parallèlement, Swift 6.2 optimise les performances sans sacrifier la sécurité, permettant ainsi un code de bas niveau avec une exécution prévisible et une surcharge minimale.
Suite à ces améliorations du langage, l'extension officielle Swift pour Visual Studio Code a été vérifiée et est désormais distribuée par Swift.org. Afin d'aider les équipes à effectuer les mises à niveau, de nouveaux outils de migration permettent aux projets d'adopter les fonctionnalités du langage à venir.
L'expérience des développeurs est encore améliorée grâce à des temps de compilation nettement plus rapides, en particulier pour les projets utilisant des API basées sur des macros. Les développeurs bénéficient d'un débogage amélioré du code concurrent dans LLDB et de nouvelles options pour gérer les avertissements du compilateur au niveau du groupe de diagnostic.
S'appuyant sur les améliorations apportées à l'écosystème, les mises à jour de la bibliothèque Swift 6.2 comprennent un nouveau package Subprocess, des améliorations de la bibliothèque Foundation et de nouvelles API destinées à prendre en charge des modèles de codage plus sûrs.
Enfin, Swift 6.2 ajoute également la prise en charge de WebAssembly, permettant aux applications Swift clientes et serveurs de cibler Wasm et de se déployer sur des navigateurs ou d'autres environnements compatibles.
Concurrence accessible
Swift 6.2 facilite la programmation concurrente grâce à une série de modifications visant à réduire les codes standard et à permettre d'écrire plus naturellement du code concurrent sécurisé :
- Monothread par défaut : les développeurs peuvent exécuter leur code sur le thread principal sans annotations @MainActor explicites à l'aide de la nouvelle option permettant d'isoler le code vers l'acteur principal par défaut. Cette option est idéale pour les scripts, le code d'interface utilisateur et d'autres cibles exécutables.
- Fonctions asynchrones intuitives : écrire du code asynchrone sans accès simultané à un état modifiable. Auparavant, les méthodes asynchrones non isolées basculaient toujours vers l'exécuteur global qui gère le pool de threads simultanés, ce qui rendait difficile l'écriture de méthodes asynchrones pour les types de classes sans erreurs de sécurité liées aux conflits de données. Dans Swift 6.2, il est possible de migrer vers une fonctionnalité à venir où les fonctions asynchrones s'exécutent dans le contexte d'exécution de l'appelant, même lorsqu'elles sont appelées sur l'acteur principal.
- Activer la concurrence avec @concurrent : introduire du code qui s'exécute simultanément à l'aide du nouvel attribut @concurrent. Cela permet de préciser clairement quand on souhaite que le code reste sérialisé sur l'acteur et quand il peut s'exécuter en parallèle.
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | // In '-default-isolation MainActor' mode struct Image { // The image cache is safe because it's protected // by the main actor. static var cachedImage: [URL: Image] = [:] static func create(from url: URL) async throws -> Image { if let image = cachedImage[url] { return image } let image = try await fetchImage(at: url) cachedImage[url] = image return image } // Fetch the data from the given URL and decode it. // This is performed on the concurrent thread pool to // keep the main actor free while decoding large images. @concurrent static func fetchImage(at url: URL) async throws -> Image { let (data, _) = try await URLSession.shared.data(from: url) return await decode(data: data) } } |
Ensemble, ces améliorations permettent d'écrire du code sans conflit d'accès aux données avec moins de surcharge d'annotation, offrent un comportement plus prévisible pour le code asynchrone, tout en permettant d'introduire la concurrence lorsque cela est nécessaire.
Programmation de systèmes sécurisés
Swift 6.2 comprend des fonctionnalités conçues pour optimiser les performances sans compromettre la sécurité. Ces fonctionnalités aident à écrire du code sécurisé de bas niveau avec des performances prévisibles et une surcharge minimale.
InlineArray est un nouveau tableau de taille fixe avec stockage en ligne pour les éléments, qui peuvent être stockés dans la pile ou directement dans d'autres types sans allocation supplémentaire dans le tas. Le développeur peut introduire un tableau en ligne en écrivant la taille entre crochets avant l'élément, ou en utilisant la syntaxe abrégée :
| Code Swift : | Sélectionner tout |
1 2 3 4 5 6 7 8 | struct Game { // Shorthand for InlineArray<40, Sprite> var bricks: [40 of Sprite] init(_ brickSprite: Sprite) { bricks = .init(repeating: brickSprite) } } |
Le nouveau type Span offre un accès direct et sécurisé à la mémoire contiguë. Span garantit la sécurité de la mémoire en s'assurant que celle-ci reste valide pendant son utilisation. Ces garanties sont vérifiées lors de la compilation, sans surcoût d'exécution, et éliminent les problèmes de sécurité de la mémoire inhérents aux pointeurs, tels que les bogues de type « use-after-free ».
Swift 6.2 améliore ses capacités pour les projets de bas niveau et critiques en matière de sécurité au-delà des nouvelles API :
[LIST][*] Swift embarqué : Swift embarqué inclut désormais l'ensemble des API String de Swift, tous les types pour les protocoles contraints par classe, ainsi que les nouveaux types InlineArray et Span.[*] Interopérabilité C++ sécurisée...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.