Frameworks

Deno 1.32 améliore la compatibilié avec node.js

Soumis par fredericmazue le

Deno vient de sortir en version 1.32. Une version qui notamment améliore la compatibilité avec node.js. Cette amélioration de la compatibilité a été entreprise avec Deno 1.30, afin d'offrir une expérience de développement globale plus fluide.

Les principales améliorations de cette version incluent :

  • Installation de package limitée : L'installation de package est désormais limitée aux instances où le code utilise un spécificateur simple qui correspond à une entrée dans le fichier package.json.
  • Affichage d'erreur paresseux : les erreurs d'analyse des dépendances dans package.json sont désormais affichées de manière paresseuse, ce qui minimise les perturbations.
  • Découverte automatique contrôlée : la découverte automatique de Package.json est désactivée lorsque les indicateurs --no-config et --no-npm sont définis, offrant un meilleur contrôle sur le processus.
  • Nouvelle variable d'environnement : Une nouvelle variable d'environnement DENO_NO_PACKAGE_JSON vous permet d'empêcher complètement Deno de résoudre un fichier package.json dans l'environnement.
  • Prise en charge étendue de la cryptographie : la prise en charge des API createCipheriv et createDecipheriv dans "node:crypto" a été ajoutée, élargissant la gamme de fonctions cryptographiques disponibles.

Ces améliorations ciblées de la convivialité contribuent collectivement à une expérience de développement plus transparente et efficace lorsque vous travaillez avec Deno et Node.js, soulignent les responsables du projet Deno.

Cette version apporte aussi deux mises à jour très demandées à deno compile. Il est maintenant possible d'utiliser les importations dynamiques et l'API Web Worker avec les binaires créés à l'aide de la sous-commande deno compile. Ensemble, cela rend les programmes multithreads plus faciles à construire avec deno compie précisent les responsables du projet Deno.

Deno v1.32 est livré avec la dernière version stable de TypeScript, à savoir TypeScript 5.0, ainsi qu'avec le moteur V8 11.2.

Deno 1.32 présente des perfomances améliorées. Parallèlement aux autres avantages en termes de performances apportés par TypeScript 5.0, la vérification de type initiale de Deno est devenue beaucoup plus rapide lorsqu'elle ne vérifie pas les modules distants, sans utiliser l'indicateur --all. Cette amélioration est particulièrement efficace pour réduire les temps de vérification de type sur CI dans la plupart des cas. Le gain de temps exact dépend du nombre de modules distants dans les dépendances d'une application, mais les développeurs de Deno déclarent avoir observé plus de 2 fois plus d'accélération dans la vérification de type (par exemple, réduction des temps de 2200 ms à 600 ms).

Slint : une boite à outils GUI écrite en Rust

Soumis par fredericmazue le

Slint est une boîte à outils complète multi plates-formes pour créer des interfaces utilisateur natives pour les appareils de bureau et embarqués, implémentée en Rust. Slint permet de cibler Linux (de bureau et embarqué), macOS, Windows, WebAssembly et Blackberry QNX. 

Le développement de Slint  (initialement connu sous le nom de "SixtyFPS") a commencé en mai 2020.  Fruit de trois ans de travail de 50 contributeurs, Slint vient de sortir en version 1.0.

Slint a une approche déclarative. Ainsi Slint est livré avec un langage de balisage spécialement conçu pour les interfaces utilisateur. Ce langage fournit un moyen puissant de décrire les éléments graphiques, leur placement et le flux de données à travers les différents états.

Voici un exemple 'Hello World' :

export component HelloWorld inherits Window {
    width: 400px;
    height: 400px;

    Text {
       y: parent.width / 2;
       x: parent.x + 200px;
       text: "Hello, world";
       color: blue;
    }
}

En ce qui concerne la logique métier, Slint est conçu de telle sorte que la logique de l'application puisse être écrite dans plusieurs langages de programmation. Actuellement, Slint fournit des API pour C++, JavaScript et Rust. La prise en charge d'autres langages de programmation est en cours.

Un plugin existe pour Visual Studio Code :

Les concepteurs de Slint travaillent sur un éditeur graphique permettant aux concepteurs de faire glisser et déposer des widgets et des éléments pour créer l'interface utilisateur.

Slint, développé par la société SixtyFPS GmbH, s'appuie sur un modèle économique durable basé sur la double licence. Dans ce modèle, Slint est disponible sous la licence open source GPLv3 et une licence propriétaire.

Le code source de Slint est disponible sur GitHub.

Site : slint-ui.com

Uno Platform 4.8

Soumis par fredericmazue le

Uno Platform est un outil multi plates-formes open source qui permet à du code basé sur WinUI et Universal Windows Platform (UWP) de s'exécuter sur iOS, macOS, Linux, Android et WebAssembly. Uno Platform vient de sortir en version 4.8.

Cette nouvelle version répond notamment à une demande des utilisateurs qui était de fournir une expérience de démarrage avec Uno Platform aussi transparente que possible. Cette nouvelle expérience tend la configuration de nouveaux projets avec Uno Platform plus facile et plus flexible. Un assistant de modèle d'application guide tout au long de la configuration d'un projet, permettant de choisir autant ou aussi peu d'éléments de la plate-forme Uno que souhaité.

Un nouvel assistant de modèle d'applications pour Visual Studio est également proposé.

A remarquer encore : Uno Platfporm 4.8 supporte .NET 8 Preview 2.

Uno Platform est un logiciel libre sous licence Apache 2.0, disponible sur GitHub.

Xcode 14.3

Soumis par fredericmazue le

Après les sorties de iOS 16.4et de macOS 13.3, APple a annoncé la disponibilité de Xcode 14.3. C'est l'occasion de rappeler qu'Apple va exiger, à partir de 25 avril 2023, qu eles application soient construites avec Xcode 14.1 au minium, pour pouvoir être déployées sur l'App Store. De même les mises à jour d'applications existantes devront être construites avec Xcode 14.1 au minimum.

Xcode 14.3 inclut Swift 5.8 et des SDK pour iOS 16.4, iPadOS 16.4, tvOS 16.4, watchOS 9.4 et macOS Ventura 13.3. La version Xcode 14.3 prend en charge le débogage sur l'appareil dans iOS 11 et versions ultérieures, tvOS 11 et versions ultérieures et watchOS 4 et versions ultérieures. Xcode 14.3 nécessite un Mac exécutant macOS Ventura 13.0 ou une version ultérieure.

Une nouvelle fonctionnalié est à remarquer dans Xcode 14.3 : un nouveau vérificateur de module qui génère des diagnostics.

[video:https://www.youtube.com/watch?v=6I3x9hN4V2k autoplay:0]

Spin : un framework pour construire des microservices basés sur WebAssembly

Soumis par fredericmazue le

Spin est un framework open source développé par la société Fermyon, permettant de créer et d'exécuter des microservices cloud rapides, sécurisés et composables avec WebAssembly. Il vise à être le moyen le plus simple de démarrer avec les microservices WebAssembly et tire parti des derniers développements du modèle de composant WebAssembly et de l'environnement d'exécution Wasmtime. Spin offre une CLI pour créer, distribuer et exécuter des applications

Les concepteurs de Spin ont choisi d'utiliser Wasm car il fonctionne en bac à sable, est portable et rapide. Les temps de démarrage à froid d'une milliseconde signifient qu'il n'est pas nécessaire de garder les applications "au chaud". Autre avantage souligné par les concepteurs de Spin : de nombreux langages ont des implémentations Wasm, de sorte que les développeurs n'ont pas à apprendre de nouveaux langages ou bibliothèques.

Spin est open source et construit sur des standards, ce qui signifie que les applications Spin peuvent potentiellement être déployées n'importe où. Il existe des implémentations Spin pour le développement local, pour les serveurs auto-hébergés, pour Kubernetes et pour les services hébergés dans le cloud.

Un guide de démarrage est disponible sur le site de Fermyon.

Spin est un logiicel libre sous licence Apache 2.0, disponible sur GitHub.

[video:https://www.youtube.com/watch?v=GqpZ9Kw0K3E autoplay:0]

Jetpack Compose 1.4

Soumis par fredericmazue le
Image
Image

Cette version de Jetpack Compose contient de nouvelles fonctionnalités telles que, notamment, Pager et Flow Layouts. Elle améliore également les performances des modificateurs et corrige un certain nombre de bugs.

Compose inclut donc désormais une prise en charge prête à l'emploi pour la pagination verticale et horizontale entre différents contenus. L'utilisation de VerticalPager ou HorizontalPager permet une fonctionnalité similaire à  ViewPager  dans le système d'affichage. Vous n'avez plus besoin de créer un adaptateur ou des fragments ! Vous pouvez simplement intégrer un composable à l'intérieur du  Pager :

// Display 10 items
HorizontalPager(pageCount = 10) { page ->
    // Your specific page content, as a composable:
    Text(
        text = "Page: $page",
        modifier = Modifier.fillMaxWidth()
    )
}

FlowRow et FlowColumn offrent quant à eux un moyen de disposer des éléments dans un conteneur lorsque la taille des éléments ou du conteneur est inconnue ou dynamique. Ces conteneurs permettent aux éléments de passer à la ligne suivante dans  FlowRow  ou à la colonne suivante dans  FlowColumn  lorsqu'ils manquent d'espace. Ces dispositions de flux permettent également un dimensionnement dynamique à l'aide de poids pour répartir les éléments dans le conteneur.

Voici un exemple qui implémente une liste de filtres pour une application immobilière :

@Composable
fun Filters() {
  val filters = listOf(
    "Washer/Dryer", "Ramp access", "Garden", "Cats OK", "Dogs OK", "Smoke-free"
  )
  FlowRow(
    horizontalArrangement = Arrangement.spacedBy(8.dp)
  ) {
    filters.forEach { title ->
      var selected by remember { mutableStateOf(false) }
      val leadingIcon: @Composable () -> Unit = { Icon(Icons.Default.Check, null) }
      FilterChip(
        selected,
        onClick = { selected = !selected },
        label = { Text(title) },
        leadingIcon = if (selected) leadingIcon else null
      )
    }
  }
}

.NET 8 Preview 2

Soumis par fredericmazue le

Après .NET 8 Preview 1 qui se faisait remarquer par une amélioration de la prise en charge de Linux, Microsoft a publié .NET 8 preview 2 qui apporte diverses améliorations, parmi lesquelles nous remarquons la prise en charge de l'introspection pour les pointeurs de fonction. Les pointeurs de fonction ont été ajoutés dans le contexte de .NET 5 et C# 9, cependant, Microsoft n'avait alors pas ajouté d'expérience correspondante pour la fonctionnalité dans Reflection. Cette nouvelle fonctionnalité ajoute la possibilité d'obtenir des métadonnées de pointeur de fonction via Reflection, y compris les types de paramètres, le type de retour et les conventions d'appel.  Voici un exemple de code qui utilise cette nouvelle fonctionnalité : 

FieldInfo fieldInfo = typeof(MyClass).GetField(nameof(MyClass._fp));

// Obtain the function pointer type from a field. This used to be the 'IntPtr' type, now it's 'Type':
Type fpType = fieldInfo.FieldType;

// New methods to determine if a type is a function pointer:
Console.WriteLine(fpType.IsFunctionPointer); // True
Console.WriteLine(fpType.IsUnmanagedFunctionPointer); // True

// New methods to obtain the return and parameter types:
Console.WriteLine($"Return type: {fpType.GetFunctionPointerReturnType()}"); // System.Void

foreach (Type parameterType in fpType.GetFunctionPointerParameterTypes())
{
    Console.WriteLine($"Parameter type: {parameterType}"); // System.Int32&
}

// Access to custom modifiers and calling conventions requires a "modified type":
Type modifiedType = fieldInfo.GetModifiedFieldType();

// A modified type forwards most members to its underlying type which can be obtained with Type.UnderlyingSystemType:
Type normalType = modifiedType.UnderlyingSystemType;

// New methods to obtain the calling conventions:
foreach (Type callConv in modifiedType.GetFunctionPointerCallingConventions())
{
    Console.WriteLine($"Calling convention: {callConv}");
    // System.Runtime.CompilerServices.CallConvSuppressGCTransition
    // System.Runtime.CompilerServices.CallConvCdecl
}

// New methods to obtain the custom modifiers:
foreach (Type modreq in modifiedType.GetFunctionPointerParameterTypes()[0].GetRequiredCustomModifiers())
{    Console.WriteLine($"Required modifier for first parameter: {modreq }");
    // System.Runtime.InteropServices.InAttribute
}

// Sample class that contains a function pointer field:
public unsafe class MyClass
{
    public delegate* unmanaged[Cdecl, SuppressGCTransition]<in int, void> _fp;
}

eSOL publie son nouveau eMCOS SDK

Soumis par fredericmazue le

eSOL, éditeur de solutions logicielles embarquées temps réel, a annoncé la sortie de son nouveau kit de développement logiciel eMCOS SDK. Centré sur le système d'exploitation temps réel (RTOS) multi-noyaux eMCOS d'eSOL, eMCOS SDK fournit un ensemble commercial complet d'outils prêts pour le CI/CD et d’exécutables, pour le développement et le déploiement d'applications embarquées à criticité mixte.

Masaki Gondo, Directeur Technique, Vice-Président Exécutif Senior et Responsable de la division Logiciels chez eSOL, déclare : « Nous sommes ravis de proposer notre eMCOS SDK amélioré sous la forme d'un package pratique, facile à utiliser et tout-en-un, qui simplifie le développement de logiciels sûrs ou à criticité mixte. Cet ensemble d'outils commerciaux conviviaux a été conçu pour permettre aux utilisateurs d’accélérer le développement de solutions logicielles, tout en optimisant leurs achats et en réduisant leurs coûts globaux. »

La nouvelle plateforme eMCOS SDK regroupe dans un même package intégré « tout-en-un » les composants logiciels de développement suivants, avec en plus un support et une maintenance standard à guichet unique :

  • eMCOS POSIX, un RTOS basé sur l'architecture multi-noyaux évolutive et performante, offrant une API POSIX étendue, et des fonctionnalités de calcul parallèle optimisé pour plateformes multi-cœurs/manycore
  • eDEVS une suite d'outils logiciels optimisée pour eMCOS POSIX et conçue pour s'intégrer de manière transparente dans une chaîne d'outils CI/CD : environnement de build basé sur CMake, intégration dans les environnements de développement et debug Eclipse/Visual Studio, et disponible sur hôtes Windows et Linux
  • Compilateur Arm C/C++ Standard et FuSa, et librairies optimisées pour les plateformes matérielles Arm
  • Prise en charge de la sonde de débogage Arm DSTREAM/DSTREAM-ST
  • Middleware avec un système de fichiers (filesystem) transactionnel robuste et des communications réseau TCP/IP
  • Exemples de BSP pour la prise en charge de plateformes Arm.

En outre, pour compléter le logiciel de base de eMCOS SDK, les modules complémentaires suivants sont également disponibles et pré-intégrés, et peuvent être érés dans le même environnement d'installation et d'activation de licence :

L'entreprise va présenter cette nouvelle plateforme logicielle au salon embedded world 2023 (du 14 au 16 mars 2023 à Nuremberg, en Allemagne).

Plus d'informations sur www.esol.com.

Entity Framework Core 8

Soumis par fredericmazue le

Entity Framework Core 8.0 (EF8) est la prochaine version après EF Core 7.0. Sa sortie est prévue en novembre 2023. Une préversion est toutefois accessible sur nuget.org. Les aperçus EF8 ciblent actuellement .NET 6 et peuvent donc être utilisés avec .NET 6 (LTS) ou .NET 7. Il y a de fortes chances que EF8 soit modifié pour cibler .NET 8 avant sa sortie. EF8 apportera beaucoup de nouveautés. En voici quelques unes.

Améliorations apportées à la prise en charge des colonnes JSON

EF8 inclut des améliorations de la prise en charge du mappage de colonnes JSON introduite dans EF7. Par exemple, la requête suivante, écrite en C#, vérifie si les deux premières mises à jour ont été effectuées avant une date donnée.

var cutoff = DateOnly.FromDateTime(DateTime.UtcNow - TimeSpan.FromDays(365));
var updatedPosts = await context.Posts
    .Where(
        p => p.Metadata!.Updates[0].UpdatedOn < cutoff
             && p.Metadata!.Updates[1].UpdatedOn < cutoff)
    .ToListAsync();

Cela se traduit par le SQL suivant lors de l'utilisation de SQL Server

SELECT [p].[Id], [p].[Archived], [p].[AuthorId], [p].[BlogId], [p].[Content], [p].[Discriminator], [p].[PublishedOn], [p].[Title], [p].[PromoText], [p].[Metadata]
FROM [Posts] AS [p]
WHERE CAST(JSON_VALUE([p].[Metadata],'$.Updates[0].UpdatedOn') AS date) < @__cutoff_0
  AND CAST(JSON_VALUE([p].[Metadata],'$.Updates[1].UpdatedOn') AS date) < @__cutoff_0

Requêtes SQL brutes pour les types non mappés

EF7 a introduit des requêtes SQL brutes renvoyant des types scalaires. Ceci est amélioré dans EF8 pour inclure des requêtes SQL brutes renvoyant tout type CLR mappable, sans inclure ce type dans le modèle EF. Les requêtes utilisant des types non mappés sont exécutées à l'aide de SqlQuery ou SqlQueryRaw .

Chargement différé pour les requêtes sans suivi

EF8 ajoute la prise en charge du chargement différé (ou chargement paresseux) des navigations sur les entités qui ne sont pas suivies par DbContext. Cela signifie qu'une requête sans suivi peut être suivie d'un chargement différé des navigations sur les entités renvoyées par la requête sans suivi.

Par exemple

var blogs = await context.Blogs.AsNoTracking().ToListAsync();

S Blog.Posts est configuré pour le chargement différé, par exemple, à l'aide de proxys de chargement différé, l'accès à Posts entraînera son chargement à partir de la base de données :

Console.WriteLine();
Console.Write("Choose a blog: ");
if (int.TryParse(ReadLine(), out var blogId))
{
    Console.WriteLine("Posts:");
    foreach (var post in blogs[blogId - 1].Posts)
    {
        Console.WriteLine($"  {post.Title}");
    }
} 

EF8 indique également si une navigation donnée est chargée ou non pour les entités non suivies par le contexte. Par exemple:

foreach (var blog in blogs)
{
    if (context.Entry(blog).Collection(e => e.Posts).IsLoaded)
    {
        Console.WriteLine($" Posts for blog '{blog.Name}' are loaded.");
    }
}

.NET 8 Preview 1 améliore la prise en charge de Linux

Soumis par fredericmazue le

Microsoft vient de publier la première préversion de .NET 8, dont la version finale sera une version avec support à long terme (LTS).  De nouvelles préversions se suivront mensuellement jusqu'à la release Candidate. Comme d'habitude, la version finale sera livrée courant novembre lors de .NET Conf. Les nouveautés apportés par .NET 8 seront très nombreuses.

Tout d'abord Microsoft continue de travailler sur Native AOT, une fonctionnalité qui est apparue avec .NET 7. Native AOT apporte une empreinte mémoire réduite, une temps de démarrage amélioré et une durée de vie de la batterie améliorée sur les appareils concernés. .NET 8 améliore ces concepts fondamentaux, notamment au niveau de la taille des fichiers d'applications qui est ainsi réduite de 50%.

Prise en charge de Linux

.NET est désormais compilable sur Linux directement à partir du référentiel dotnet/dotnet. Il utilise dotnet/source-build pour créer des runtimes, des outils et des SDK .NET. Il s'agit de la même version que Red Hat et Canonical utilisent pour créer .NET, par exemple. Au fil du temps, Microsoft l'étendra pour prendre en charge macOS et Windows.

Microsoft publie des images Ubuntu Chiseled avec .NET 8. Ce type d'image est destiné aux développeurs qui souhaitent bénéficier de l'informatique de type appliance. Microsoft prévoit que les images ciselées d'Ubuntu seront prises en charge en production par Canonical et Microsoft d'ici la sortie de .NET 8.

Prise en charge de Linux et objectif de référence

Microsoft met à jour ses lignes de base minimales pour Linux pour .NET 8. Il y a par conséquent trois changements notables.

  • Le produit .NET sera construit en ciblant Ubuntu 16.04, pour toutes les architectures. C'est principalement important pour définir la version minimale de la glibc pour .NET 8. Par exemple, .NET 8 ne parviendra même pas à démarrer sur Ubuntu 14.04, par exemple, en raison de ce changement.
  • Pour Red Hat Enterprise Linux (RHEL), Microsoft prendra en charge RHEL 8+, abandonnant RHEL 7.
  • Microsoft ne publiera qu'une déclaration de support pour RHEL, avec cependant l'intention que ce support s'applique aux autres distributions de l'écosystème RHEL .

Microsoft continuera à prendre en charge Linux sur les architectures Arm32, Arm64 et x64.

Toutes les nouveautés de .NET 8 sont à retrouver dans ce billet de blog.