Fondamentalement, Hyperlambda n’est en réalité qu’un langage de balisage complet de Turing, avec quelques fonctionnalités supplémentaires ressemblant à des fonctionnalités de XSLT et XPath. On pourrait dire que Hyperlambda est l’équivalent de programmation de YAML. A l’indice de « abstractions au niveau de la programmation » si nous soutenons que le code assembleur CISC x86 est au niveau 1 (le niveau inférieur) et que C# et Java sont au niveau 5, tandis que Python et PHP sont au niveau 10 – Hyperlambda est au niveau 100+ quelque part.
Bien sûr, le fait est que 95% des fois où vous avez besoin d’une construction de programmation de bas niveau, Hyperlambda crée implicitement vos objets C# et les lie ensemble 100% correctement hors de la boîte. Cela réduit la complexité cognitive du code de votre application résultante par des ordres de grandeur. Pour illustrer cette différence, veuillez consulter l’extrait de code suivant tiré de la documentation officielle de Microsoft pour savoir comment créer correctement une requête HTTP à partir de C#.
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public void ConfigureServices(IServiceCollection services)
{
services.AddHttpClient();
// Remaining code deleted for brevity.En plus de l’extrait suivant…
public class BasicUsageModel : PageModel
{
private readonly IHttpClientFactory _clientFactory;
public IEnumerable<GitHubBranch> Branches { get; private set; }
public bool GetBranchesError { get; private set; }
public BasicUsageModel(IHttpClientFactory clientFactory)
{
_clientFactory = clientFactory;
}
public async Task OnGet()
{
var request = new HttpRequestMessage(HttpMethod.Get,
"https://api.github.com/repos/dotnet/AspNetCore.Docs/branches");
request.Headers.Add("Accept", "application/vnd.github.v3+json");
request.Headers.Add("User-Agent", "HttpClientFactory-Sample");
var client = _clientFactory.CreateClient();
var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
using var responseStream = await response.Content.ReadAsStreamAsync();
Branches = await JsonSerializer.DeserializeAsync
<IEnumerable<GitHubBranch>>(responseStream);
}
else
{
GetBranchesError = true;
Branches = Array.Empty<GitHubBranch>();
}
}
}… il y a environ 10 extraits de code supplémentaires dans l’exemple de Microsoft. Cependant, je ne vous ennuierai pas avec tous les détails concernant ces derniers – Le fait est que c’est extrêmement complexe pour simplement OBTENIR une requête HTTP freakin’ en utilisant C#, et des centaines de choses pourraient mal se passer dans le processus …
Au total, nous parlons de plus de 50 lignes de code, dispersées dans 3 fichiers différents, obligeant le consommateur de la classe à comprendre des constructions telles que l’injection de dépendances, les invocations de méthodes asynchrones, la sérialisation et la désérialisation JSON, les objets IDisposable, etc, etc. etc. Notez que le code ci-dessus n’inclut même pas la classe de modèle pour les objets renvoyés non plus, donc l’exemple de code réel finirait probablement par devenir près de 100 lignes de code dans au moins 3 fichiers différents. Ensuite, regardez l’exemple Hyperlambda équivalent faisant le exactement la même chose.
http.get:"http://github.com"Sous les capots, l’extrait de code Hyperlambda fait le exactement la même chose, avec une différence cruciale bien sûr, étant que l’exemple C# est 50 à 100 fois plus complexe, ce qui implique qu’il est 50 à 100 fois plus probable que quelque chose se passe mal. Ce n’est pas unique pour les requêtes HTTP, et des différences similaires peuvent être trouvées si vous essayez de récupérer des données de votre base de données, de créer plusieurs threads, de sauvegarder et de charger des fichiers, etc., etc. Dans l’ensemble, cela réduit la complexité de votre fin le code résultant par ordre de grandeur, le rendant extrêmement facile à lire et, plus important encore, il devient presque impossible pour vos développeurs juniors de faire quelque chose de mal lorsqu’ils créent du code dans Hyperlambda.
SOLIDE
Un autre paradoxe avec Hyperlambda est que même si les idées de SOLID ont été inventées à l’origine pour créer les meilleures pratiques pour le développement de logiciels OOP, et Hyperlambda ne contient pas une seule construction OOP – le code Hyperlambda est sans doute « code implicitement SOLIDE ». Par exemple, le S de SOLID implique « responsabilité unique ». Hyperlambda est un langage de programmation fonctionnel, et pour implémenter correctement SOLID en POO, vous vous retrouvez souvent avec des classes avec une seule méthode publique. Cette méthode unique, bien sûr, encapsule l’intégralité de la « responsabilité » de votre classe, souvent reflété par un seul verbe, comme « Courir », « Télécharger », « Ouvert », etc. Après avoir créé votre « SOLIDE » class, vous l’encapsulez généralement dans une interface, câblez l’interface via votre conteneur IoC et autorisez le reste de votre équipe à l’utiliser exclusivement via votre interface.
Le paradoxe auquel j’arrive est qu’un langage de programmation fonctionnel est fondamentalement meilleur à « responsabilités uniques » que les langages POO pour ces raisons, simplement parce que lorsque toutes les fonctions sont des verbes, elles sont implicitement de nature SOLIDE. Violer la responsabilité unique dans un langage où tout est une seule fonction, faire une seule chose, encapsulé par un seul verbe, devient sans doute impossible. Je pourrais continuer avec le reste des 4 lettres de SOLID, mais je suppose que vous voyez l’idée.
Supprimer la complexité
Au lieu de nous demander ce qu’a exactement Hyperlambda, définissons le langage du point de vue de ce qu’il n’a pas …
- Hyperlambda fait ne pas avoir une injection de dépendance
- Hyperlambda fait ne pas avoir un polymorphisme
- Hyperlambda fait ne pas avoir un héritage
- Hyperlambda fait ne pas avoir des constructeurs
- Hyperlambda fait ne pas avoir des interfaces
Je pourrais continuer sur des centaines de pages illustrant ce que fait Hyperlambda ne pas avoir, et aussi expliquer pourquoi c’est l’avantage d’Hyperlambda, mais le fait est qu’en raison de ce qu’il fait ne pas avoir, Hyperlambda devient beaucoup plus facile à apprendre et à utiliser correctement. Apprendre à appliquer correctement la POO dans un langage tel que C# nécessite généralement 10 000 heures de développement logiciel, souvent pendant une décennie ou plus. Et jusqu’à ce que vous compreniez des idées complexes telles que les conteneurs IoC, les interfaces, SOLID, les modèles de conception, etc. – Imaginer que vous êtes capable de créer du code de haute qualité dans un langage tel que C# est au mieux illusoire.
Se lier d’amitié avec le développeur junior
Cela implique que vous pouvez prendre un développeur junior avec un week-end d’expérience en programmation, et supposer simplement qu’il est (presque) capable de mettre en œuvre code parfait prêt à l’emploi. Bien sûr, pour un développeur senior, avec des décennies d’expérience, la façon dont SOLID, les conteneurs IoC et les interfaces, etc. sont censés être liés ensemble est une évidence. Mais pour un développeur junior, comprendre ces constructions est extrêmement difficile!
En supposant que vous travailliez en équipe, vous serez obligé de collaborer avec des développeurs juniors à un moment donné de votre carrière, et en raison des fonctionnalités d’extension d’Hyperlambda, le développeur senior peut faire tout le « trucs complexes », et l’envelopper dans une interface simple et morte pour le junior, comme illustré ci-dessous.
using magic.node;
using magic.signals.contracts;
namespace acme.foo
{
[Slot(Name = "acme.foo")]
public class Foo : ISlot
{
public void Signal(ISignaler signaler, Node input)
{
var arg1 = input.Children.First().Get<int>();
var arg2 = input.Children.Skip(1).First().Get<int>();
// ... do more complex stuff here ...
input.Value = arg1 + arg2;
input.Clear();
}
}
}Ce qui précède est en fait un exemple pratique de la façon d’étendre Hyperlambda avec le mot-clé [acme.foo], d’où vous avez accès à toute la complexité de C# et du CLR, et vous pouvez appliquer autant d’injection de dépendances et de SOLID que vous le souhaitez, en exposant votre code C# magnifiquement créé via un seul mot-clé Hyperlambda, garantissant qu’il n’y a aucun moyen que le les juniors de votre équipe pourraient tout gâcher pour vous.
Dans un environnement de développement de logiciels d’entreprise typique, environ 50 % de tous les développeurs sont des développeurs juniors. Les idées ci-dessus donnent au final un code de meilleure qualité, des produits plus stables et sécurisés, où toute la complexité est implicitement cachée, tout en offrant une extensibilité pour les moments où vous en avez besoin. J’aime les analogies, et d’une certaine manière, cela lubrifie le moteur de votre département de développement logiciel, permettant à tous de contribuer à n’importe quel niveau auquel ils sont suffisamment qualifiés pour contribuer, sans exposer des choses complexes aux noobs, et/ou aux personnes qui intègrent simplement votre code C# avancé quel que soit le niveau auquel ils sont censés le consommer.
Réutilisabilité
Comme effet supplémentaire, tous les emplacements Hyperlambda que vous créez à l’aide de constructions telles qu’illustrées dans le code C# ci-dessus deviennent implicitement réutilisables, vous permettant de considérer Hyperlambda comme le chef d’orchestre de votre orchestre symphonique, où vos constructions C# deviennent les instruments individuels. L’idée étant bien sûr prête à l’emploi, Magic vous propose des centaines de ces constructions réutilisables avant même de commencer votre propre projet. Un homme célèbre a dit un jour ce qui suit à propos de la réutilisation en POO…
Tu veux la banane, tu as un gorille, tenant une banane, dans la forêt tropicale
Pour tous ceux qui ont essayé de réutiliser des choses en C#, l’analogie ci-dessus devient douloureusement vraie. Avec Hyperlambda cependant, ce qui suit est la vérité …
Vous voulez la banane, vous obtenez la banane, PERIODE !
Fini les gorilles ou les forêts tropicales…
