Norbert  Ernser

Norbert Ernser

1648718280

Compétences requises pour devenir un développeur Solidity

Dans cet article, vous apprendrez comment devenir un développeur Solidity et les compétences requises pour les emplois de développeur Solidity.

Les contrats intelligents ont transformé le visage de l'automatisation sur les plateformes numériques d'une manière complètement nouvelle. L'utilisation de contrats intelligents a facilité les environnements sans confiance dans lesquels les parties impliquées dans une transaction peuvent faire confiance à un code automatisé plutôt qu'à une institution centralisée. Les contrats intelligents font partie intégrante du paysage numérique décentralisé émergent, ce qui implique le besoin de développeurs de contrats intelligents experts. 

Considérant l'utilisation de Solidity comme outil privilégié pour le développement de contrats intelligents, la demande de postes de développeur Solidity a augmenté ces derniers temps. Qu'est-ce que la Solidité ? Avez-vous besoin de compétences particulières pour apprendre le langage de programmation des contrats intelligents ? Le rôle d'un programmeur Solidity facilitera-t-il un développement professionnel prometteur à long terme ? La discussion suivante vous aide à découvrir les réponses à toutes ces questions avec un guide détaillé sur la façon de devenir des développeurs Solidity.

Lire la suite : Contrats intelligents dans Blockchain et comment ça marche

Qu'est-ce que la Solidité ?

La première chose évidente que vous découvrirez dans un didacticiel de développeur Solidity est une introduction au langage de programmation lui-même. Solidity est essentiellement un langage de programmation orienté objet, tout comme JavaScript, axé particulièrement sur le développement de contrats intelligents. Il prend en charge les capacités multiplateformes, bien que la plupart des applications de Solidity soient sur Ethereum. 

L'idée du langage de programmation Solidity, proposée par Gavin Wood, a pris forme en 2014. Les similitudes de Solidity dans la syntaxe avec JavaScript ont joué un rôle énorme dans son adoption. Solidity prend en charge l'héritage parallèlement à la linéarisation C3 et aux héritages multiples. Cependant, il est légèrement différent de Java dans le fait que Solidity est un langage typé de manière inerte ne comportant que des types de retour dynamiques. De plus, Solidity comporte également certains éléments de Python et C++. 

Les utilisations de Solidity pour le développement de contrats intelligents servent divers cas d'utilisation tels que,

  • Portefeuilles multi-signatures
  • Vote
  • Enchères à l'aveugle
  • financement participatif

Raisons d'apprendre la solidité

On peut clairement remarquer à quel point la demande d'emplois de développeur Solidity a soudainement augmenté récemment. Avec un langage aussi efficace pour développer des contrats intelligents sur plusieurs réseaux blockchain, les développeurs de contrats intelligents pourraient améliorer leur productivité. Dans le même temps, les entreprises travaillant sur des fonctionnalités de contrats intelligents sur des réseaux blockchain pourraient également tirer le meilleur parti de Solidity. 

Ces raisons sont-elles suffisantes pour poursuivre le rôle de carrière d'un programmeur Solidity ? Beaucoup de gens auraient des doutes sur le choix de Solidity pour développer des contrats intelligents alors qu'il existe de nombreux autres choix. Pourquoi Solidity est-il un choix populaire pour le développement de contrats intelligents ? Les raisons suivantes peuvent offrir une réponse viable à votre question. 

  • Prise en charge de la machine virtuelle Ethereum, qui facilite l'exécution du code au niveau de la machine créé par Solidity.
  • La flexibilité de compilation est un autre avantage prometteur du langage de programmation Solidity. Les développeurs peuvent choisir un compilateur en ligne de commande sur leur PC ou un compilateur en ligne Remix selon leurs préférences.
  • Le facteur le plus important de la demande croissante de rôles de développeur Solidity est l'amélioration constante de Solidity lui-même. De nouvelles mises à jour de langage introduisent de nombreuses nouvelles fonctionnalités ainsi que des corrections de bogues pour améliorer l'expérience des développeurs.

Popularité de Solidity

Au-dessus de toutes les choses notables que vous devez considérer avant de poursuivre des emplois en tant que développeurs Solidity, la fonctionnalité du langage de programmation Solidity est inévitable. C'est l'un des langages de programmation les plus populaires actuellement pour le développement de contrats intelligents. 

Selon l'enquête Solidity Developer Survey 2020, près de 65 % des personnes interrogées utilisent Solidity depuis plus d'un an. 

Environ 93 % des répondants à l'enquête ont suggéré qu'ils utilisaient Solidity dans des projets personnels autres que le travail. Fait intéressant, près de 68 % des participants ont déclaré utiliser Solidity au travail. 

Un autre aspect frappant de l'enquête est l'aperçu des résultats des langages de programmation préférés. Les répondants ont placé Solidity en troisième position derrière JavaScript et Python. Cependant, Solidity est l'un des langages de programmation les plus utilisés, en particulier compte tenu des opinions des répondants à l'enquête Solidity Developer Survey 2020. Près de 21 % des répondants à l'enquête ont désigné Solidity comme le langage de programmation le plus utilisé.

Qu'est-ce qui est possible avec la solidité ?

Toutes les discussions sur la popularité de Solidity font partie intégrante de tout didacticiel de développeur Solidity. Maintenant que vous connaissez Solidity et qu'il s'agit d'un langage de programmation important pour le développement de contrats intelligents, vous vous interrogez peut-être sur la prochaine étape. Tout débutant chercherait les possibilités avec Solidity. Que pouvez-vous faire avec Solidity ? Avant de commencer à vous renseigner sur Solidity et à trouver des perspectives d'emploi en tant que développeurs Solidity, vous devez savoir de quoi Solidity est capable. Les différentes utilisations de Solidity incluent,

Création de dApps

La première chose que vous devez noter à propos du travail d'un programmeur Solidity est l'exigence de développer des applications décentralisées ou des dApps. Solidity aide à créer des dApps que les gens pourraient utiliser comme d'autres applications. De nombreuses dApps développées sur Ethereum ont été conçues pour fonctionner sur Solidity. 

Lire la suite : Qu'est-ce qu'une application décentralisée (DApp) | Applications décentralisées dans Blockchain

Contrats intelligents

Les fonctionnalités de Solidity pour la création de contrats intelligents sont les points forts de la popularité croissante des emplois de développeur Solidity. Les applications décentralisées reposent sur des contrats intelligents, qui peuvent aider les gens à échanger de l'argent, des biens, des actions et d'autres objets de valeur. Les développeurs peuvent utiliser Solidity pour personnaliser les contrats intelligents en fonction de différents cas d'utilisation, supprimant ainsi les notaires. 

OIC

Vous pouvez également identifier une application prometteuse de Solidity dans la création d'ICO. Les développeurs pourraient facilement créer des jetons personnels suivis du lancement des ICO sur Ethereum. Ces types de symboles sont appelés jetons ERC20. 

Opportunités pour les développeurs Solidity

L'aperçu de base de Solidity, ses caractéristiques et ses fonctionnalités, ainsi que sa popularité parmi les développeurs, présentent des raisons suffisantes pour que quiconque poursuive des rôles de développeur Solidity. Cependant, les aspirants professionnels auraient encore beaucoup d'autres doutes quant aux possibilités d'une carrière en tant que programmeurs Solidity. 

L'une des principales préoccupations des aspirants développeurs de Solidity concernerait évidemment les estimations salariales attendues des développeurs de Solidity. Une répartition claire du salaire annuel moyen des développeurs Solidity dans différentes régions géographiques peut éclairer davantage les opportunités de carrière chez Solidity. 

The average annual salary for a Solidity programmer in the USA is around $127,500. At the same time, the average annual salary for Solidity developers in Asia is $125,000. However, the Solidity developer salary for remote working positions is $145,000 annually. Interestingly, your experience and skills play a major role in your professional growth as Solidity developers, subsequently enhancing your salary. 

What is the Work of Solidity Developers?

Many beginners and professionals seeking jobs in Solidity development would obviously seek the easiest route. As a result, you may come across the question of “How long does it take to become a Solidity developer?” especially in the initial stages of preparation. However, the fundamentals of Solidity will only help you understand the language. 

Vous avez besoin de mois de formation, d'apprentissage et de pratique rigoureux pour utiliser Solidity afin de développer des contrats intelligents ou des dApps. L'aperçu des raisons de poursuivre des emplois de développeur Solidity avec un aperçu des fonctionnalités utiles du langage de programmation et sa popularité offrent une motivation. Cependant, de nombreux débutants ne savent pas par où commencer dans leur parcours pour devenir des développeurs Solidity. 

La première étape de votre parcours pour devenir un développeur Solidity serait un aperçu des responsabilités associées. Que ferez-vous dans le rôle de développeurs Solidity ? La réponse vous aidera à comprendre dans quoi vous vous embarquez et à déterminer si la programmation Solidity vous convient. Les responsabilités importantes dans le travail ou les développeurs Solidity sont les suivantes,

  • Interprétation des besoins du client pour l'architecte de solutions blockchain.
  • Superviser et participer à des projets de développement de contrats intelligents.
  • Développement de nouvelles fonctionnalités et améliorations avec stabilité, efficacité et tests améliorés.
  • Travailler sur l'intégration du code Solidity sur diverses plates-formes clientes.
  • Évaluation des revues techniques des solutions.
  • Assurer l'intégration de la blockchain avec les applications existantes.
  • Collaboration avec les chefs de produit et les équipes multidisciplinaires pour découvrir de nouvelles idées sur le développement de contrats intelligents.

Compétences requises pour les emplois de développeur Solidity

Maintenant que vous savez ce que vous avez à faire en tant que développeurs Solidity, vous devez être conscient que vous avez besoin de compétences. Sans les compétences et les connaissances pertinentes, vous pouvez à peine réussir à effleurer la surface des responsabilités des programmeurs Solidity. Par conséquent, vous devez remplir toutes les conditions préalables nécessaires au travail de développeur Solidity avant de vous lancer dans la formation. Solidity est un langage de programmation de contrats intelligents, et vous avez besoin des caractéristiques suivantes avant de commencer à en savoir plus à ce sujet. 

  • Tout d'abord, vous devez développer une compréhension formelle de la blockchain Ethereum, de son fonctionnement et de ses cas d'utilisation.
  • Vous devez également avoir une impression fondamentale de la technologie blockchain et des concepts associés.
  • Une expérience de base avec les langages de programmation peut également constituer un avantage vital pour l'apprentissage de Solidity.

Fait intéressant, presque toute personne aspirant à créer des contrats intelligents peut apprendre Solidity. Au fur et à mesure que vous progressez dans votre carrière en tant que programmeur Solidity, vous devrez remplir d'autres exigences de compétences telles que, 

  • Expérience de travail pratique sur différentes plateformes blockchain.
  • Expérience professionnelle en architecture ou en conception de projets blockchain basés sur Solidity.
  • Expérience pratique de l'architecture, du développement et des applications de contrats intelligents.

Au-dessus de toutes ces compétences requises à différentes étapes de votre carrière dans les emplois de développeur Solidity, vous auriez besoin des traits suivants à tout moment. 

  • Engagement envers le paysage DLT et Web 3.0.
  • Zèle pour en savoir plus sur les technologies émergentes de blockchain.
  • Esprit d'équipe avec des capacités à travailler en équipes multidisciplinaires.
  • Compétences en gestion de projets et de clients.

Feuille de route pour devenir développeur Solidity

Le décor est planté, les opportunités sont claires et vous avez besoin d'instructions pour commencer à vous préparer aux travaux de programmation Solidity. Eh bien, vous pouvez apprendre Solidity comme bon vous semble et ce qui vous convient le mieux. Cependant, une approche guidée de vos préparations peut jouer un rôle crucial dans le suivi de votre croissance en tant que professionnel de la programmation Solidity. 

Plus important encore, une feuille de route pourrait également vous aider à trouver la réponse exacte à la question « Combien de temps faut-il pour devenir un développeur Solidity ? » avec un aperçu des étapes à franchir. Voici les étapes importantes que vous pouvez suivre dans une feuille de route de carrière pour les développeurs Solidity. 

Commencer par les Fondamentaux

Couvrez tous les concepts simples que vous pouvez sur tout ce qui concerne la solidité et les contrats intelligents. Découvrez l'évolution du Web 3.0 et les bases de la blockchain, ainsi que les réseaux de blockchain notables. De plus, vous devez également vous familiariser avec les principes fondamentaux des applications décentralisées et leur fonctionnement. Pendant que vous êtes aux bases, vous devez également perfectionner vos compétences en programmation pour les tâches de développement front-end et back-end. Dans le même temps, vous devez également consulter la documentation Solidity pour découvrir les fonctionnalités utiles qu'elle offre pour le développement de contrats intelligents. 

Plongez dans les détails techniques

Une fois que vous avez terminé avec les bases, vous pouvez passer à l'étape suivante de votre parcours d'apprentissage. En savoir plus sur les bases du contrat intelligent Solidity et sur le fonctionnement de l'EVM avec Solidity. De plus, vous devez en savoir plus sur les opérateurs Solidity et sur la manière dont ils offrent des fonctionnalités cruciales. Plus important encore, les aspirants à un emploi de programmeur Solidity devraient également en savoir plus sur Remix, l'IDE Solidity. Remix est une condition essentielle pour écrire, compiler et déboguer du code Solidity. 

Faites confiance à des ressources d'apprentissage crédibles

Internet est une mine d'informations sur tout ce à quoi vous pouvez penser. Cependant, vous ne pouvez pas choisir une ressource d'apprentissage aléatoire pour devenir un développeur Solidity. Recherchez des cours de formation sur Solidity avec une explication détaillée de tous les sujets et concepts ainsi qu'une compréhension pratique de ses utilisations. 

Vous avez besoin de cours qui non seulement vous enseignent Solidity, mais vous préparent également à l'utiliser dans des applications réelles. De plus, vous devez rechercher des plateformes qui offrent des références vérifiables pour votre expertise en Solidité par le biais d'une certification. Une fois que vous avez maîtrisé l'utilisation de Solidity pour le développement de contrats intelligents, la certification peut améliorer vos chances de devenir programmeur Solidity.

La route vers votre objectif peut avoir des difficultés réparties partout. Cependant, le dévouement pour Solidity et une carrière dans le développement de la blockchain pourraient vous faire avancer même sur les chemins les plus difficiles. Solidity est sans aucun doute l'un des langages de programmation les plus couramment utilisés pour le développement de contrats intelligents à l'heure actuelle. 

Avec les opportunités de carrière prometteuses sous la forme d'estimations lucratives des salaires des développeurs Solidity et des fonctionnalités et améliorations émergentes dans Solidity, la demande d'emplois dans la programmation Solidity augmenterait à l'avenir. Vous pouvez capitaliser sur les opportunités de carrière en tant que développeur de contrats intelligents Solidity ou développeur dApp en choisissant le bon chemin. Apprenez-en plus sur Solidity et explorez dès maintenant les différentes possibilités de carrière en tant qu'expert Solidity.

Merci!

What is GEEK

Buddha Community

Norbert  Ernser

Norbert Ernser

1648718280

Compétences requises pour devenir un développeur Solidity

Dans cet article, vous apprendrez comment devenir un développeur Solidity et les compétences requises pour les emplois de développeur Solidity.

Les contrats intelligents ont transformé le visage de l'automatisation sur les plateformes numériques d'une manière complètement nouvelle. L'utilisation de contrats intelligents a facilité les environnements sans confiance dans lesquels les parties impliquées dans une transaction peuvent faire confiance à un code automatisé plutôt qu'à une institution centralisée. Les contrats intelligents font partie intégrante du paysage numérique décentralisé émergent, ce qui implique le besoin de développeurs de contrats intelligents experts. 

Considérant l'utilisation de Solidity comme outil privilégié pour le développement de contrats intelligents, la demande de postes de développeur Solidity a augmenté ces derniers temps. Qu'est-ce que la Solidité ? Avez-vous besoin de compétences particulières pour apprendre le langage de programmation des contrats intelligents ? Le rôle d'un programmeur Solidity facilitera-t-il un développement professionnel prometteur à long terme ? La discussion suivante vous aide à découvrir les réponses à toutes ces questions avec un guide détaillé sur la façon de devenir des développeurs Solidity.

Lire la suite : Contrats intelligents dans Blockchain et comment ça marche

Qu'est-ce que la Solidité ?

La première chose évidente que vous découvrirez dans un didacticiel de développeur Solidity est une introduction au langage de programmation lui-même. Solidity est essentiellement un langage de programmation orienté objet, tout comme JavaScript, axé particulièrement sur le développement de contrats intelligents. Il prend en charge les capacités multiplateformes, bien que la plupart des applications de Solidity soient sur Ethereum. 

L'idée du langage de programmation Solidity, proposée par Gavin Wood, a pris forme en 2014. Les similitudes de Solidity dans la syntaxe avec JavaScript ont joué un rôle énorme dans son adoption. Solidity prend en charge l'héritage parallèlement à la linéarisation C3 et aux héritages multiples. Cependant, il est légèrement différent de Java dans le fait que Solidity est un langage typé de manière inerte ne comportant que des types de retour dynamiques. De plus, Solidity comporte également certains éléments de Python et C++. 

Les utilisations de Solidity pour le développement de contrats intelligents servent divers cas d'utilisation tels que,

  • Portefeuilles multi-signatures
  • Vote
  • Enchères à l'aveugle
  • financement participatif

Raisons d'apprendre la solidité

On peut clairement remarquer à quel point la demande d'emplois de développeur Solidity a soudainement augmenté récemment. Avec un langage aussi efficace pour développer des contrats intelligents sur plusieurs réseaux blockchain, les développeurs de contrats intelligents pourraient améliorer leur productivité. Dans le même temps, les entreprises travaillant sur des fonctionnalités de contrats intelligents sur des réseaux blockchain pourraient également tirer le meilleur parti de Solidity. 

Ces raisons sont-elles suffisantes pour poursuivre le rôle de carrière d'un programmeur Solidity ? Beaucoup de gens auraient des doutes sur le choix de Solidity pour développer des contrats intelligents alors qu'il existe de nombreux autres choix. Pourquoi Solidity est-il un choix populaire pour le développement de contrats intelligents ? Les raisons suivantes peuvent offrir une réponse viable à votre question. 

  • Prise en charge de la machine virtuelle Ethereum, qui facilite l'exécution du code au niveau de la machine créé par Solidity.
  • La flexibilité de compilation est un autre avantage prometteur du langage de programmation Solidity. Les développeurs peuvent choisir un compilateur en ligne de commande sur leur PC ou un compilateur en ligne Remix selon leurs préférences.
  • Le facteur le plus important de la demande croissante de rôles de développeur Solidity est l'amélioration constante de Solidity lui-même. De nouvelles mises à jour de langage introduisent de nombreuses nouvelles fonctionnalités ainsi que des corrections de bogues pour améliorer l'expérience des développeurs.

Popularité de Solidity

Au-dessus de toutes les choses notables que vous devez considérer avant de poursuivre des emplois en tant que développeurs Solidity, la fonctionnalité du langage de programmation Solidity est inévitable. C'est l'un des langages de programmation les plus populaires actuellement pour le développement de contrats intelligents. 

Selon l'enquête Solidity Developer Survey 2020, près de 65 % des personnes interrogées utilisent Solidity depuis plus d'un an. 

Environ 93 % des répondants à l'enquête ont suggéré qu'ils utilisaient Solidity dans des projets personnels autres que le travail. Fait intéressant, près de 68 % des participants ont déclaré utiliser Solidity au travail. 

Un autre aspect frappant de l'enquête est l'aperçu des résultats des langages de programmation préférés. Les répondants ont placé Solidity en troisième position derrière JavaScript et Python. Cependant, Solidity est l'un des langages de programmation les plus utilisés, en particulier compte tenu des opinions des répondants à l'enquête Solidity Developer Survey 2020. Près de 21 % des répondants à l'enquête ont désigné Solidity comme le langage de programmation le plus utilisé.

Qu'est-ce qui est possible avec la solidité ?

Toutes les discussions sur la popularité de Solidity font partie intégrante de tout didacticiel de développeur Solidity. Maintenant que vous connaissez Solidity et qu'il s'agit d'un langage de programmation important pour le développement de contrats intelligents, vous vous interrogez peut-être sur la prochaine étape. Tout débutant chercherait les possibilités avec Solidity. Que pouvez-vous faire avec Solidity ? Avant de commencer à vous renseigner sur Solidity et à trouver des perspectives d'emploi en tant que développeurs Solidity, vous devez savoir de quoi Solidity est capable. Les différentes utilisations de Solidity incluent,

Création de dApps

La première chose que vous devez noter à propos du travail d'un programmeur Solidity est l'exigence de développer des applications décentralisées ou des dApps. Solidity aide à créer des dApps que les gens pourraient utiliser comme d'autres applications. De nombreuses dApps développées sur Ethereum ont été conçues pour fonctionner sur Solidity. 

Lire la suite : Qu'est-ce qu'une application décentralisée (DApp) | Applications décentralisées dans Blockchain

Contrats intelligents

Les fonctionnalités de Solidity pour la création de contrats intelligents sont les points forts de la popularité croissante des emplois de développeur Solidity. Les applications décentralisées reposent sur des contrats intelligents, qui peuvent aider les gens à échanger de l'argent, des biens, des actions et d'autres objets de valeur. Les développeurs peuvent utiliser Solidity pour personnaliser les contrats intelligents en fonction de différents cas d'utilisation, supprimant ainsi les notaires. 

OIC

Vous pouvez également identifier une application prometteuse de Solidity dans la création d'ICO. Les développeurs pourraient facilement créer des jetons personnels suivis du lancement des ICO sur Ethereum. Ces types de symboles sont appelés jetons ERC20. 

Opportunités pour les développeurs Solidity

L'aperçu de base de Solidity, ses caractéristiques et ses fonctionnalités, ainsi que sa popularité parmi les développeurs, présentent des raisons suffisantes pour que quiconque poursuive des rôles de développeur Solidity. Cependant, les aspirants professionnels auraient encore beaucoup d'autres doutes quant aux possibilités d'une carrière en tant que programmeurs Solidity. 

L'une des principales préoccupations des aspirants développeurs de Solidity concernerait évidemment les estimations salariales attendues des développeurs de Solidity. Une répartition claire du salaire annuel moyen des développeurs Solidity dans différentes régions géographiques peut éclairer davantage les opportunités de carrière chez Solidity. 

The average annual salary for a Solidity programmer in the USA is around $127,500. At the same time, the average annual salary for Solidity developers in Asia is $125,000. However, the Solidity developer salary for remote working positions is $145,000 annually. Interestingly, your experience and skills play a major role in your professional growth as Solidity developers, subsequently enhancing your salary. 

What is the Work of Solidity Developers?

Many beginners and professionals seeking jobs in Solidity development would obviously seek the easiest route. As a result, you may come across the question of “How long does it take to become a Solidity developer?” especially in the initial stages of preparation. However, the fundamentals of Solidity will only help you understand the language. 

Vous avez besoin de mois de formation, d'apprentissage et de pratique rigoureux pour utiliser Solidity afin de développer des contrats intelligents ou des dApps. L'aperçu des raisons de poursuivre des emplois de développeur Solidity avec un aperçu des fonctionnalités utiles du langage de programmation et sa popularité offrent une motivation. Cependant, de nombreux débutants ne savent pas par où commencer dans leur parcours pour devenir des développeurs Solidity. 

La première étape de votre parcours pour devenir un développeur Solidity serait un aperçu des responsabilités associées. Que ferez-vous dans le rôle de développeurs Solidity ? La réponse vous aidera à comprendre dans quoi vous vous embarquez et à déterminer si la programmation Solidity vous convient. Les responsabilités importantes dans le travail ou les développeurs Solidity sont les suivantes,

  • Interprétation des besoins du client pour l'architecte de solutions blockchain.
  • Superviser et participer à des projets de développement de contrats intelligents.
  • Développement de nouvelles fonctionnalités et améliorations avec stabilité, efficacité et tests améliorés.
  • Travailler sur l'intégration du code Solidity sur diverses plates-formes clientes.
  • Évaluation des revues techniques des solutions.
  • Assurer l'intégration de la blockchain avec les applications existantes.
  • Collaboration avec les chefs de produit et les équipes multidisciplinaires pour découvrir de nouvelles idées sur le développement de contrats intelligents.

Compétences requises pour les emplois de développeur Solidity

Maintenant que vous savez ce que vous avez à faire en tant que développeurs Solidity, vous devez être conscient que vous avez besoin de compétences. Sans les compétences et les connaissances pertinentes, vous pouvez à peine réussir à effleurer la surface des responsabilités des programmeurs Solidity. Par conséquent, vous devez remplir toutes les conditions préalables nécessaires au travail de développeur Solidity avant de vous lancer dans la formation. Solidity est un langage de programmation de contrats intelligents, et vous avez besoin des caractéristiques suivantes avant de commencer à en savoir plus à ce sujet. 

  • Tout d'abord, vous devez développer une compréhension formelle de la blockchain Ethereum, de son fonctionnement et de ses cas d'utilisation.
  • Vous devez également avoir une impression fondamentale de la technologie blockchain et des concepts associés.
  • Une expérience de base avec les langages de programmation peut également constituer un avantage vital pour l'apprentissage de Solidity.

Fait intéressant, presque toute personne aspirant à créer des contrats intelligents peut apprendre Solidity. Au fur et à mesure que vous progressez dans votre carrière en tant que programmeur Solidity, vous devrez remplir d'autres exigences de compétences telles que, 

  • Expérience de travail pratique sur différentes plateformes blockchain.
  • Expérience professionnelle en architecture ou en conception de projets blockchain basés sur Solidity.
  • Expérience pratique de l'architecture, du développement et des applications de contrats intelligents.

Au-dessus de toutes ces compétences requises à différentes étapes de votre carrière dans les emplois de développeur Solidity, vous auriez besoin des traits suivants à tout moment. 

  • Engagement envers le paysage DLT et Web 3.0.
  • Zèle pour en savoir plus sur les technologies émergentes de blockchain.
  • Esprit d'équipe avec des capacités à travailler en équipes multidisciplinaires.
  • Compétences en gestion de projets et de clients.

Feuille de route pour devenir développeur Solidity

Le décor est planté, les opportunités sont claires et vous avez besoin d'instructions pour commencer à vous préparer aux travaux de programmation Solidity. Eh bien, vous pouvez apprendre Solidity comme bon vous semble et ce qui vous convient le mieux. Cependant, une approche guidée de vos préparations peut jouer un rôle crucial dans le suivi de votre croissance en tant que professionnel de la programmation Solidity. 

Plus important encore, une feuille de route pourrait également vous aider à trouver la réponse exacte à la question « Combien de temps faut-il pour devenir un développeur Solidity ? » avec un aperçu des étapes à franchir. Voici les étapes importantes que vous pouvez suivre dans une feuille de route de carrière pour les développeurs Solidity. 

Commencer par les Fondamentaux

Couvrez tous les concepts simples que vous pouvez sur tout ce qui concerne la solidité et les contrats intelligents. Découvrez l'évolution du Web 3.0 et les bases de la blockchain, ainsi que les réseaux de blockchain notables. De plus, vous devez également vous familiariser avec les principes fondamentaux des applications décentralisées et leur fonctionnement. Pendant que vous êtes aux bases, vous devez également perfectionner vos compétences en programmation pour les tâches de développement front-end et back-end. Dans le même temps, vous devez également consulter la documentation Solidity pour découvrir les fonctionnalités utiles qu'elle offre pour le développement de contrats intelligents. 

Plongez dans les détails techniques

Une fois que vous avez terminé avec les bases, vous pouvez passer à l'étape suivante de votre parcours d'apprentissage. En savoir plus sur les bases du contrat intelligent Solidity et sur le fonctionnement de l'EVM avec Solidity. De plus, vous devez en savoir plus sur les opérateurs Solidity et sur la manière dont ils offrent des fonctionnalités cruciales. Plus important encore, les aspirants à un emploi de programmeur Solidity devraient également en savoir plus sur Remix, l'IDE Solidity. Remix est une condition essentielle pour écrire, compiler et déboguer du code Solidity. 

Faites confiance à des ressources d'apprentissage crédibles

Internet est une mine d'informations sur tout ce à quoi vous pouvez penser. Cependant, vous ne pouvez pas choisir une ressource d'apprentissage aléatoire pour devenir un développeur Solidity. Recherchez des cours de formation sur Solidity avec une explication détaillée de tous les sujets et concepts ainsi qu'une compréhension pratique de ses utilisations. 

Vous avez besoin de cours qui non seulement vous enseignent Solidity, mais vous préparent également à l'utiliser dans des applications réelles. De plus, vous devez rechercher des plateformes qui offrent des références vérifiables pour votre expertise en Solidité par le biais d'une certification. Une fois que vous avez maîtrisé l'utilisation de Solidity pour le développement de contrats intelligents, la certification peut améliorer vos chances de devenir programmeur Solidity.

La route vers votre objectif peut avoir des difficultés réparties partout. Cependant, le dévouement pour Solidity et une carrière dans le développement de la blockchain pourraient vous faire avancer même sur les chemins les plus difficiles. Solidity est sans aucun doute l'un des langages de programmation les plus couramment utilisés pour le développement de contrats intelligents à l'heure actuelle. 

Avec les opportunités de carrière prometteuses sous la forme d'estimations lucratives des salaires des développeurs Solidity et des fonctionnalités et améliorations émergentes dans Solidity, la demande d'emplois dans la programmation Solidity augmenterait à l'avenir. Vous pouvez capitaliser sur les opportunités de carrière en tant que développeur de contrats intelligents Solidity ou développeur dApp en choisissant le bon chemin. Apprenez-en plus sur Solidity et explorez dès maintenant les différentes possibilités de carrière en tant qu'expert Solidity.

Merci!

Solidity Guide For Beginners

Ethereum is known for its wide use in blockchain programming. Especially Solidity is used to write most of the blockchain applications known for today. Here, I’ll help you to learn solidity effortlessly.

1-Learn JavaScript

Image for post

Because you interact with the internet and the ethereum nodes at the same time, learning JavaScript becomes necessary to understand the data structures of solidity. Even more, ethereum nodes interact with nodeJS. Furthermore, solidity is written in JavaScript and it requires a basic understanding of JavaScript to work with the ethereum environment.

2-Look for courses (online/offline)

When I started learning solidity, my first course was face to face offered free because of my club’s connections. But I never stopped and decided to go further by purchasing a udemy course and looking for high-quality YouTube courses, you can level up your solidity skills by practicing. About offline courses, they can be really expensive for you to afford and online courses can allow you to look at the videos and ask questions lifetime.

3-Take notes and practice

Mentioned in my previous posts, taking notes by hand allows you not to forget easily when not practicing for a very long time. Even more, remembering the data structures can help you analyzing the codes even with the hugest projects imaginable. I managed to find most of the mistakes in my acceleration project in ethereum despite I was a beginner.

4-Setting up a text editor (optional)

You don’t have to if you prefer using remix IDE for projects. But you might need to consider certain text editors for the best results in programming on ethereum. But, they require you to download certain packages before starting to write your code on these text editors to compile solidity code on your computer.

#solidity-programming #solidity-tutorial #ethereum #solidity #javascript

Diego  Elizondo

Diego Elizondo

1652926080

Cómo Construir Un Analizador En Rust Por Diversión Y Ganancias

Un viernes por la mañana, holgazaneando, estás pensando en los nuevos programas de Netflix para ver. Su jefe viene y le pide que escriba un analizador para un archivo de unidad de Systemd .

Lo necesita para el lunes.

Cada vez que pensabas que el fin de semana estaba disponible

Estás nervioso.

La última vez que se le pidió que escribiera un analizador, se metió en la madriguera del conejo de la web, copiando y pegando fórmulas Regex hasta que funcionó™.

Básicamente lo que todos los desarrolladores habían hecho (sangre en la mano)

Tomas un sorbo de tu té de boba para calmarte. Buscas Systemd en Google y te gusta... no, no es tan simple como pensabas.

Ese sentimiento cuando estás tan desesperado porque te quitan el fin de semana

Tu buen truco de copiar y pegar expresiones regulares sale volando por la ventana. Las posibilidades de pasar un fin de semana sin interrupciones para atracones de programas se acercan rápidamente null.

#PEG al rescate

No pierdas la esperanza todavía. Permítame presentarle Parse Expression Grammer (PEG) , una manera fácil de familiarizarse con los analizadores y ahorrar su valioso fin de semana.

PEG es una forma legible de escribir reglas de sintaxis y es bastante similar a las expresiones regulares, que es diferente de una contraparte de gramática libre de contexto como Backus-Naur Form (BNF) en la que las expresiones deben reducirse a símbolos más pequeños. Lo siento, Noam Chomsky , quizás otros días de trabajo.

Usaré una biblioteca de análisis de Rust PEG llamada Pest , que es bastante impresionante. Si aún no lo has hecho, esperaré mientras instalas Rust .

En serio, ¿quién no se oxida en estos días?

#Empezando

Comencemos con una gramática simple para analizar una declaración de declaración de variable similar a JavaScript. Comenzaremos pensando en un conjunto de reglas para entradas válidas.

#Una declaración de declaración:

  • comienza con una palabra clave var, seguida de uno o más identificadores.
  • es insensible al espacio en blanco
  • termina con un punto y coma ( ;)

#Un grupo de identificadores:

  • está precedido por una varpalabra clave
  • está delimitado por comas
  • es insensible al espacio en blanco

#Un identificador:

  • puede contener cualquier número de dígitos, caracteres y guiones bajos en mayúsculas y minúsculas
  • no puede comenzar con un dígito
  • no puede contener ningún espacio

Un identificador es un término , lo que significa que es una pieza irrompible del token. También lo son las varpalabras clave y los puntos y comas.

Regresa un poco al lado BNF, usando Extended Backus-Naur Grammar (EBNF) , podrías definir formalmente la gramática anterior de esta manera:

<alpha>  := 'a' | 'b' | 'c' | 'd' | 'e' | /* ... */ 'z'
         |  'A' | 'B' | 'C' | 'D' | 'E' | /* ... */ 'Z'

<digit>  := 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

<Decl>   := 'var' <Idents> '\n'? ';'
<Idents> := <Ident> ('\n'? ',' <Ident>)*
<Ident>  := <alpha>+ (<alpha> | <digit> | '_')*

El nombre de la regla en mayúsculas representa un símbolo que no termina (es decir, se puede dividir en términos más pequeños). El nombre en minúscula representa un término.

En aras de la brevedad, omitimos los espacios en blanco implícitos de las reglas. Básicamente, pueden existir uno o más espacios en blanco entre cada símbolo que ve.

¡Vamos a profundizar en ello! Las reglas <alpha>y <digit>se explican por sí mismas, por lo que dejaremos que lo adivines.

<Decl>es la regla más compleja para una instrucción de declaración, que presenta una varpalabra clave, un <Idents>símbolo, una nueva línea opcional y termina con un punto y coma. Básicamente, esta regla dice: "Cualquier entrada de cadena que comience con var, seguida de uno o más espacios, luego una subregla <Idents>, seguida de uno o más espacios y finalmente termine con un solo punto y coma es válida y felizmente la masticaré. "

<Idents>puede ser un solo <Ident>símbolo, seguido de cero o más pares de comas y <Ident>.

Finalmente, un <Ident>debe comenzar con uno o más caracteres, seguido de cero o más caracteres, dígitos o guiones bajos.

#Ok, código por favor

¡Espera, joven Anakin! Cabeza caliente, eres. He aquí que, con la gramática definida, podremos analizar estas declaraciones:

var foo, bar, baz;

var   foo_1, baRamYu,baz99;

var foo_x
  , baroo
  , bazoo
  ;

No, no me olvidé de formatear mi código. ¡Es JS válido, y también es para nuestro analizador! Aquí hay algo que nuestras reglas no soportarán:

var 99Problems

¿Alguien quiere adivinar qué está mal aquí? ✋ Deja tu respuesta en el comentario. (psss, si tu respuesta es correcta, te sigo + 3 me gusta en tu publicación 👍)

#Entra el óxido y las plagas

Ok, espero que ya tengas Rust instalado (En tu terminal, intenta escribir which cargoy ver si aparece). Comience creando un nuevo proyecto binario de Rust con

$ cargo new --bin maybe-js; cd maybe-js

Dentro de la carpeta del proyecto, abra el Cargo.tomlarchivo y agregue lo siguiente en dependencies, y ejecútelo cargo updatepara instalarlo.

[dependencies]
pest = "2.0"
pest_derive = "2.0"

Una vez hecho esto, cdingrese srcy cree un archivo llamado grammar.pesty pegue lo siguiente en él:

alpha = { 'a'..'z' | 'A'..'Z' }
digit = { '0'..'9' }
underscore = { "_" }
newline = _{ "\n" | "\r" }
WHITESPACE = _{ " " }

declaration = { "var" ~ !newline ~ idents ~ newline? ~ ";" }
idents = { ident ~ (newline? ~ "," ~ ident)* }
ident = @{ !digit ~ (alpha | digit | underscore)+ }

Ahora bien, si he tenido su atención durante los últimos minutos, no debería ser difícil adivinar lo que está sucediendo aquí. (Oh, ¿no lo he hecho? De todos modos... aquí vamos)

Los cinco primeros son todos términos. Son conjuntos de valores válidos. el | se llama Choice Operator , que es como "o-si no".

first | or_else

Al hacer coincidir una expresión de elección, firstse intenta. Si first coincide con éxito, la expresión completa se realiza correctamente de inmediato. Sin embargo, si firstfalla, or_elsese intenta a continuación.

La newlineregla tiene un peculiar _antes del corchete, que en Pest habla significa "silencioso": simplemente no lo queremos como parte de nuestros tokens analizados, pero de todos modos es parte de una sintaxis válida.

La WHITESPACEregla tiene un lugar especial en Pest. Si lo definió, Pest insertará automáticamente espacios en blanco opcionales implícitos (de acuerdo con la WHITESPACEregla que defina) entre cada símbolo. Nuevamente, _dice que queremos silenciarlo, ya que no queremos toneladas de espacios en blanco como parte de nuestro árbol de sintaxis.

La declarationregla es muy similar a la contraparte de EBNF que aprendimos antes. Las tildes ("~") simplemente significan "y luego". La regla comienza con una palabra clave "var", seguida de cualquier cosa que no sea un salto de línea (el "!" hace lo que hubiera adivinado intuitivamente: negar una regla), seguida de una subregla idents, un salto de línea opcional y finaliza con un punto y coma.

La identsregla es nuevamente similar al ejemplo EBNF. Es un solo ident, seguido de cero o más idents separados por comas.

La identregla es un poco especial. La "@", conocida como Atomic , delante del corchete está ahí para decir: "No quiero que se apliquen espacios en blanco implícitos a esta regla". Seguro que no queremos incluir ningún espacio en nuestro nombre de variable. Además, marcar una regla como atómica de esta manera trata la regla como un término, silenciando las reglas internas de coincidencia. Cualquier regla interna se descarta.

string_lit = { "\"" ~ inner ~ "\"" }
inner = { ASCII_ALPHANUMERIC* }

Tenga en cuenta que ASCII_ALPHANUMERICes una regla incorporada conveniente en Pest para cualquier carácter y dígito ASCII.

Si analizamos una cadena "hola" con esta regla, esto generará primero un string_litnodo, que a su vez tiene un innernodo que contiene la cadena "hola", sin comillas.

Árbol de regla no atómica

Agregar un sigilo "@" delante del string_litcorchete:

string_lit = @{ "\"" ~ inner ~ "\"" }
inner = { ASCII_ALPHANUMERIC* }

string_litTerminaremos con un nodo plano que contiene ""hola"".

Árbol de la regla atómica

Un sigilo similar "$" conocido como Compound Atomic , protege los espacios en blanco implícitos dentro de la regla. La diferencia es que permite que las reglas de coincidencia internas se analicen normalmente.

La !digitparte evita que la regla avance si comienza con un número. Si no es así, una o más combinaciones de caracteres, números y guiones bajos están bien.

#Pero espera, ¿dónde está el código?

¡Dang, mi inteligente explorador! Pareces arrinconarme en cada movimiento. Sí, eso no era código en absoluto, sino una definición de gramática de Pest. Ahora tenemos que escribir un código de Rust para analizar un texto. Inicie src/main.rsy agregue lo siguiente:

/// You need to do this to use macro
extern crate pest;                                                                                                                                                                                   
#[macro_use]                                                                                                                                                                                         
extern crate pest_derive;                                                                                                                                                                            

/// 1. Import modules                                                                                                                                                                                            
use std::fs;                                                                                                                                                                                         
use pest::Parser;                                                                                                                                                                                    
use pest::iterators::Pair;                                                                                                                                                                           

/// 2. Define a "marker" struct and add a path to our grammar file.                                                                                                                                                                                                 
#[derive(Parser)]                                                                                                                                                                                    
#[grammar = "grammar.pest"]                                                                                                                                                                            
struct IdentParser; 

/// 3. Print the detail of a current Pair and optional divider
fn print_pair(pair: &Pair<Rule>, hard_divider: bool) {
    println!("Rule: {:?}", pair.as_rule());
    println!("Span: {:?}", pair.as_span());
    println!("Text: {:?}", pair.as_str());
    if hard_divider {
        println!("{:=>60}", "");
    } else {
        println!("{:->60}", "");
    }
}

fn main() {
    /// 4. Parse a sample string input
    let pair = IdentParser::parse(Rule::declaration, "var foo1, bar_99, fooBar;")
        .expect("unsuccessful parse")
        .next().unwrap();

    print_pair(&pair, true);
    
    /// 5. Iterate over the "inner" Pairs
    for inner_pair in pair.into_inner() {
 
        print_pair(&inner_pair, true);

        match inner_pair.as_rule() {
            /// 6. If we match an idents rule...
            Rule::idents =>  {
                /// 7. Iterate over another inner Pairs
                for inner_inner_pair in inner_pair.into_inner() {
                    match inner_inner_pair.as_rule() {
                        /// 8. The term ident is the last level
                        Rule::ident => {
                            print_pair(&inner_inner_pair, false);
                        }
                        _ => unreachable!(),
                    }
                }
            }
            _ => unreachable!(),
        }
    }
}

Está bien si no entiendes la mayoría de las cosas aquí. Ejecutémoslo cargo runen el directorio de su proyecto y miremos la salida impresa.

Rule: declaration
Span: Span { str: "var foo1, bar_99, fooBar;", start: 0, end: 28 }
Text: "var foo1, bar_99, fooBarBaz;"
============================================================
Rule: idents
Span: Span { str: "foo1, bar_99, fooBar", start: 4, end: 27 }
Text: "foo1, bar_99, fooBarBaz"
============================================================
Rule: ident
Span: Span { str: "foo1", start: 4, end: 8 }
Text: "foo1"
------------------------------------------------------------
Rule: ident
Span: Span { str: "bar_99", start: 10, end: 16 }
Text: "bar_99"
------------------------------------------------------------
Rule: ident
Span: Span { str: "fooBar", start: 18, end: 27 }
Text: "fooBarBaz"
------------------------------------------------------------

El concepto más importante aquí es un Pair. Representa un par de tokens coincidentes o, de manera equivalente, el texto distribuido que una regla con nombre coincidió correctamente.

A menudo usamos Pairs para:

Determinar qué regla produjo elPair

Usar el Paircomo materia prima&str

Inspeccionar las sub-reglas internas nombradas que produjeron elPair

let pair = Parser::parse(Rule::enclosed, "(..6472..) and more text")
    .unwrap().next().unwrap();

assert_eq!(pair.as_rule(), Rule::enclosed);
assert_eq!(pair.as_str(), "(..6472..)");

let inner_rules = pair.into_inner();
println!("{}", inner_rules); // --> [number(3, 7)]

A Pairpuede tener cero, una o más reglas internas. Para máxima flexibilidad, Pair::into_inner()devuelve Pairs, que es un tipo de iterador sobre cada par.

💡 Pair::into_inner()es un idioma muy común cuando se trabaja con Pest. Asegúrate de entender qué Paires a.

#Vamos a analizar Systemd

Si has llegado hasta aquí, te mereces este gatito.

Ahora es el momento de poner el trabajo. Aquí hay un ejemplo de un archivo de unidad Systemd:

[Unit]
Description=Nginx
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
Environment=PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/home/ec2-user/.local/bin
Environment=LD_LIBRARY_PATH=/usr/local/lib
Environment=PKG_CONFIG_PATH=/usr/local/lib/pkgconfig
ExecStart=/usr/local/sbin/nginx-runner.sh
Restart=on-failure
RestartSec=0
KillMode=process

[Install]
WantedBy=multi-user.target

El archivo está agrupado en secciones, cada una con un nombre entre corchetes. Cada sección contiene cero o más pares de nombre y valor de propiedad, separados por un signo igual "=".

Tratemos de desarrollar un conjunto de reglas. Cree un nuevo proyecto de óxido con cargo new --bin systemd-parser, luego cree un archivo con el nombre src/grammar.pestcon las siguientes reglas:


/// Implicit white spaces are ok.
WHITESPACE = _{ " " }

/// Set of characters permited 
char = { ASCII_ALPHANUMERIC | "." | "_" | "/" | "-"  }

/// name is one or more chars. Note that white spaces are allowed.
name = { char+ }

// value can be zero or more char, plus = and : for path variables.
value = { (char | "=" | ":" )* }

/// section is a name, enclosed by square brackets.
section = { "[" ~ name ~ "]" }

/// property pair is a name and value, separated by an equal sign.
property = { name ~ "=" ~ value }

/// A Systemd unit file structure
file = {
    SOI ~
    ((section | property)? ~ NEWLINE)* ~
    EOI
}

En el main.rsarchivo, comience con lo siguiente

extern crate pest;
#[macro_use]
extern crate pest_derive;

use std::fs;
use std::env::current_dir;
use std::collections::HashMap;
use pest::Parser;

#[derive(Parser)]
#[grammar = "grammar.pest"]
struct SystemdParser;

/// Implement a simple AST representation
#[derive(Debug, Clone)]
pub enum SystemdValue {
    List(Vec<String>),
    Str(String),
}

// ...

Como primer paso, después de las importaciones y la configuración iniciales, definimos una SystemdValueenumeración como una representación simple del tipo de datos en un archivo Systemd. SystemdValue::Str(String)capturará un solo valor de propiedad y SystemdValue::List(Vec<String>)capturará varios valores de propiedad con un nombre de clave de propiedad duplicado. Por ejemplo, en el nginx.servicearchivo anterior hay varias Environmentpropiedades.

Aquí está la mainfunción:


fn main() {
    // Read and parse the unit file.
    let unparsed_file = fs::read_to_string("nginx.service")
        .expect("cannot read file");
    let file = SystemdParser::parse(Rule::file, &unparsed_file).expect("fail to parse")
        .next()
        .unwrap();

    // Create a fresh HashMap to store the data.
    let mut properties: HashMap<String, HashMap<String, SystemdValue>> = HashMap::new();

    // These two mutable variables will be used to store
    // section name and property key name.
    let mut current_section_name = String::new();
    let mut current_key_name = String::new();

    // Iterate over the file line-by-line.
    for line in file.into_inner() {
		match line.as_rule() {
			Rule::section => {
                // Update the current_section_name
                let mut inner_rules = line.into_inner();
                current_section_name = inner_rules.next().unwrap().as_str().to_string();
			}
			Rule::property => {
                let mut inner_rules = line.into_inner();
                // Get a sub map of properties with the current_section_name key, or create new.
                let section = properties.entry(current_section_name.clone()).or_default();

                // Get the current property name and value.
                let name = inner_rules.next().unwrap().as_str().to_string();
                let value = inner_rules.next().unwrap().as_str().to_string();

                // If the property name already exists...
                if name == current_key_name {
                    // Get the section of the map with the key name, or insert a new SytemdValue::List.
                    let entry = section.entry(current_key_name.clone()).or_insert(SystemdValue::List(vec![]));
                    // Push the value onto the inner vector of SystemdValue::List.
                    if let SystemdValue::List(ent) = entry {
                        ent.push(value);
                    }
                } else {
                    // Create a new SystemdValue::List and save it under name key.
                    let entry = section.entry(name.clone()).or_insert(SystemdValue::List(vec![]));
                    // Push the current value onto the vector, then set the
                    // current_key_name to the current name.
                    if let SystemdValue::List(ent) = entry {
                        ent.push(value);
                    }
                    current_key_name = name;
                }
			}
			Rule::EOI => (),
			_ => unreachable!(),
		}
    }
}

Todo esto está bien, pero no usamos SystemdValue::Strninguna parte del código. Para mantener limpio el código, decidimos tratar cada propiedad como HashMap<String, SystemdValue::List(Vec<String>), donde la clave del mapa es la clave de propiedad y el vector String almacena la lista de valores de propiedad. Si no hay valor, el vector está vacío. Si hay un valor, este vector contiene ese único valor, y así sucesivamente.

Para que la API sea un poco más fácil de usar, escribiremos una pequeña función auxiliar para procesar todos los correos electrónicos de un solo valor Systemd::List(Vec<String>)y convertirlos en archivos Systemd::Str(String).

// Iterate over the nested maps, and convert empty and 
// single-element `SystemdValue::List<Vec<String>>` to 
// `SystemdValue::Str(String)`.
fn pre_process_map(map: &mut HashMap<String, HashMap<String, SystemdValue>>) {
    for (_, value) in map.into_iter() {
		for (_, v) in value.into_iter() {
			if let SystemdValue::List(vs) = v {
				if vs.len() == 0 {
					let v_ = SystemdValue::Str(String::new());
					*v = v_.clone();
				} else if vs.len() == 1 {
					let v_ = SystemdValue::Str((vs[0]).clone());
					*v = v_.clone();
				}
			}
		}
    }
}

¡Ahora estamos listos para imprimirlo para que el mundo lo vea!

fn main() {

    // Our main code 

    pre_process_map(properties);

    println!("{:#?}", properties);
}

¡Auge! ¡Felicidades! Acaba de escribir un analizador de archivos Systemd, además de uno mini JS. 🤯 Ahora tendrás algo de tiempo libre para divertirte el viernes por la noche. Con otra tarde, es posible que incluso descubras cómo serializar el archivo de tu unidad Systemd en JSON para impresionar a tu jefe el lunes.

Puede consultar el código del analizador implementado como biblioteca en [este repositorio] (https://github.com/jochasinga/systemd-parser)

Fuente: https://hackernoon.com/how-to-build-a-parser-in-rust-for-fun-and-profit

#rust 

SOLID Coding in Python

The principle of SOLID coding is an acronym originated by Robert C. Martin, and it stands for five different conventions of coding.

If you follow, these principles you can improve the reliability of your code by working on its structure and its logical consistency.

The SOLID principles are:

  • The Single-Responsibility Principle (SRP)
  • The Open-Closed Principle (OCP)
  • The Liskov Substitution Principle (LSP)
  • The Interface Segregation Principle (ISP)
  • The Dependency inversion Principle (DIP)

These five principles are not a specific ordered list (do this, then that, etc) but a collection of best practices, developed through the decades. They are gathered into an acronym, as a mnemonic vehicle to be remembered, similar to others in computer science, e.g.: DRYDon’t Repeat YourselfKISSKeep It Small and Simple; as pieces of accumulated wisdom. A little side note, the acronym was created years after these five principles were set together.

In general, the SOLID principles are basic learning steps for every code developer but are usually ignored by those who does not consider the highest quality of code their absolute priority.

However, as a Data Scientist myself, I have seen that following these principles is beneficial. Specifically, it improves testability, reduces technical debts, and the time needed to implement changes when new requirements from clients/stockholders arise.

In the following article, I want to explore these five principles and offer some examples in Python. Usually, the SOLID principles are applied in the context of object-oriented design (i.e.: Python’s classes), but I believe they are valid regardless of the level, and I would like to keep the example and explanation here, to a level for an “advanced beginner”, overseeing formal definition.v

#solid #python #coding #programming #data-science #solid coding in python

Madisyn  Lakin

Madisyn Lakin

1626988140

Solid.js - The NEXT React? in-depth Code Analysis.

Learn more about Solid.js: https://www.solidjs.com/

Keep up with Ryan by following him:

A super in-depth code conversation about the inner-workings of Solid.js from a React developer’s perspective.

Why is Solid so good? It shares a nearly-identical API as React, but handles props and state in a completely different way using observables and reactivity.

#react #solid #solid.js #javascript