Pause café #83. Quels traits de caractère distinguent les programmeurs exceptionnels. Guide de programmation simple : fonctions et méthodes

Quels traits de caractère distinguent les programmeurs exceptionnels ?

Source : Hackernoon Qu'est- ce qui différencie les grands programmeurs des bons ? J'ai découvert deux traits de caractère que partagent les grands programmeurs : ils étaient cohérents et persistants. Ces traits en eux-mêmes ne sont pas des signes de génie et, s’il le souhaite, n’importe qui peut développer ces traits et les appliquer ensuite dans son travail.

1. Soyez cohérent

Les bons programmeurs ne programment pas de temps en temps. Ils disposent plutôt d'un horaire précis pour améliorer leurs connaissances et leurs compétences pendant leur temps libre : avant ou après le travail et le week-end. Par exemple, un programmeur que je connais consacre les deux premières heures de sa journée, six jours par semaine, à des projets ou à des tâches d'études personnelles. Cela ne veut pas dire que ces personnes écrivent du code 24 heures sur 24. Comme nous tous, ils ont du temps pour leur vie personnelle, leurs obligations et leurs intérêts. Mais ils sont cohérents : programmer est devenu leur habitude. Comment devenir cohérent ? C’est ce que beaucoup d’entre nous tentent de réaliser. J'ai découvert qu'il existe plusieurs façons de procéder. Tout d’abord, déterminez le nombre d’heures par semaine que vous pouvez consacrer à la programmation. Ce nombre correspond à votre « kilométrage du programme » hebdomadaire. En tant qu'ancien coureur de fond, je courais un certain nombre de kilomètres chaque semaine. C'était ma course hebdomadaire. J'ai maintenant mon expérience en programmation : c'est le nombre d'heures que je passe à programmer chaque semaine. La plupart des gens négligent cette étape. Ils passent directement au projet qu’ils souhaitent réaliser ou au sujet qu’ils souhaitent étudier, sans penser à la manière dont ils trouveront le temps de le faire. De ce fait, ils travaillent la nuit ou 16 heures par jour. Il y a un problème avec cette approche : elle n'est pas viable à long terme. Perfectionner vos compétences en tant que programmeur n'est pas quelque chose que vous faites au cours d'une semaine ou deux chargées. Au lieu de cela, vous devez continuellement y travailler pendant longtemps. C'est pourquoi il est si important d'identifier votre expérience en programmation. Pour ce faire, pensez à utiliser un journal de temps pour voir où et comment vous passez votre temps. Prenez un morceau de papier et notez tout ce que vous faites chaque jour et combien de temps vous le faites, y compris consulter les réseaux sociaux ou vos e-mails pendant cinq minutes. Cela vous permettra de trouver plus facilement des créneaux libres dans votre emploi du temps. Vous pourriez même avoir un peu plus de temps pour faire le ménage ou regarder la télévision. Vous pouvez ensuite créer un plan de formation en programmation auquel vous devez vous conformer. Un plan de formation est l’un des moyens les plus efficaces d’être cohérent. Il vous permet de diffuser tous les détails à l'avance. Tout ce que vous avez à faire est de mettre ce plan en œuvre chaque jour. Mes plans d'entraînement de course à pied décrivaient le nombre de kilomètres que je devais parcourir chaque jour et la vitesse à laquelle je devais les parcourir. Maintenant, je crée des plans d'entraînement programmés qui servent le même objectif : ils me disent ce que je dois faire chaque jour. À la fin de la journée, j'ouvre Evernote sur mon ordinateur et je fais un planning pour le lendemain. Voici un exemple : Je suis ce processus tout au long de ma journée de travail : je désigne le temps que je vais consacrer à une tâche et ce que je veux accomplir pendant ce temps. Je crée également un plan d'entraînement mensuel. J'y inclut trois choses que je souhaite accomplir, apprendre ou terminer au cours du mois à venir. J'avais l'habitude de faire des plans trimestriels. Mais ensuite j’ai découvert que trop de choses peuvent changer en trois mois. Un plan mensuel vous laisse suffisamment de temps pour franchir des étapes significatives dans votre formation.

2. Soyez persévérant

Le deuxième trait des bons programmeurs est la persévérance. Ils examinent toutes les options pour résoudre le problème et trouvent la réponse. Cela semble être le secret. Les grands programmeurs que j'ai rencontrés ont une étrange capacité à résoudre les problèmes et à proposer différentes solutions ou solutions à une situation difficile. Bref, ils disposaient d’un système pour résoudre les problèmes. Je n'ai jamais eu de système de solutions au lycée. Chaque fois qu’on me posait un problème en cours de mathématiques, je m’y plongeais directement à toute vitesse. Ensuite, j'ai continué à faire cela lorsque j'ai commencé à programmer. Pas d'idée. Il n'y a pas de système. Pas le temps de réfléchir. Aucune analyse. Sans surprise, dans les deux cas, je faisais patiner mes roues inutilement et je me heurtais constamment à des obstacles. J'ai maintenant un système de résolution de problèmes qui m'aide à décomposer un problème pour trouver différentes options. Par exemple, la première étape de mon processus de résolution de problèmes consiste à énoncer le problème. C'est le premier. Une fois que j'ai compris le problème, je me concentre sur chacune des étapes suivantes.

• Analyse des données d'entrée et des résultats attendus.
• Création d'un algorithme d'action.
• Écriture de pseudocode.
• Résoudre une version simplifiée du problème.

J'espère que vous comprenez l'idée. Les étapes ne sont peut-être pas faciles, mais elles sont gérables. En résolvant un problème difficile, nous devenons de meilleures personnes. Cela inspire également confiance. Une fois que nous avons résolu un problème difficile, nous sommes prêts à en affronter de nouveaux.

3. Attitude face aux problèmes ?

Pour devenir de meilleurs programmeurs, il y a autre chose que nous devons prendre en compte : l'attitude. Vous devez avoir une nouvelle approche des problèmes et des ambiguïtés. Un jour, j'ai posé quelques questions à un développeur senior sur un problème sur lequel j'étais coincé. J'étais perplexe et déçu. Au début, le développeur était également perplexe. Cependant, sa réponse m'a choqué. "Wow, c'est un problème sympa", a-t-il déclaré. Son intérêt a été piqué par les détails qu'il a découverts. Cela ne veut pas dire que les grands programmeurs ne se retrouvent pas eux aussi coincés dans certains problèmes. Ils restent coincés. Mais la différence réside dans l'attitude. La leçon que j’ai apprise ce jour-là est la suivante : les bons programmeurs n’ont pas peur de s’aventurer dans l’inconnu. Ils comprennent qu'ils apprendront certainement quelque chose de nouveau en étudiant ce problème. Nous pouvons apprendre beaucoup en étudiant d'autres programmeurs. Mais en fin de compte, la responsabilité nous incombe : nous devons nous mettre au travail chaque jour et agir.

Guide de programmation simple : fonctions et méthodes

Source : DZone Qu'est-ce qui fait une bonne fonction ou méthode ? Cela nécessite une combinaison de facteurs, dont chacun compte. Examinons quatre des plus importants.

Nom significatif

Les fonctions doivent avoir des noms qui décrivent leur objectif ou leur fonctionnalité. Lorsqu’une fonction porte un nom significatif, il est facile de lire et de comprendre son objectif. Par exemple, si le but de la fonction est de rechercher un client par ID, un bon nom pourrait être findCustomerById(id: String) . Une autre option pourrait être findCustomer(id: String) . Ici, la fonction signature implique que l'acheteur est retrouvé grâce à son identifiant. Le mot « trouver » implique également que l’acheteur peut ou non être trouvé. Si le nom de la fonction est modifié en getCustomer(id: String) alors sa signification change car elle n'implique désormais aucune restauration ; soit le client est trouvé, soit la fonction échoue et lève éventuellement une exception. Les deux noms sont des noms valides pour une fonction, mais ont des significations différentes et leurs implémentations doivent donc également être différentes.

Le moins de paramètres possible

J'aime suivre la règle de trois. Cela signifie que la fonction doit avoir trois paramètres ou moins. Lorsqu'une fonction nécessite plus de trois paramètres, elle doit être réécrite et les paramètres placés dans un conteneur de données, tels que sa classe, sa classe de données, son objet JavaScript, etc. Il s'agit d'un moyen simple de réduire le nombre de paramètres et d'organiser les données au sein d'une application. Prenons par exemple une fonction qui a un comportement identique mais des signatures différentes :

fun addCustomer(
  firstname: String,
  lastname: String,
  streetAddress: String,
  city: String,
  zipCode: String
)

Voici une autre option :

data class Address(
  val street: String,
  val city: String,
  val zipCode: String,
  val streetNumber: String
)

data class Customer(
  val firstname: String,
  val lastname: String,
  val address: Address
)

fun addCustomer(customer: Customer)

La fonction fait ce qui est attendu

Une fonction doit faire ce qu'on attend d'elle. Ni plus ni moins. Si la fonction est nommée findAddress(latitude, longitude) alors elle doit trouver l'adresse aux coordonnées données ou, si l'adresse ne peut pas être convertie en coordonnées, renvoyer None , null , Empty ou quel que soit le type approprié pour la langue donnée. La fonction ne doit rien faire d'autre, comme rechercher des adresses à proximité ou créer des enregistrements de coordonnées. Une fonction peut avoir des effets secondaires tels que la journalisation ou l'analyse, mais ceux-ci sont invisibles en entrée et en sortie.

La fonction peut être testée

Les fonctionnalités doivent être conçues de manière à pouvoir être testées. Dans l'exemple de code précédent, j'ai défini la fonction addCustomer , mais je n'ai défini aucun type de retour, sa testabilité est donc discutable. Bien sûr, il peut être testé à l'aide de simulations ou d'espions en fonction de l'implémentation interne, cela peut être réalisé en fournissant simplement le type de retour :

fun addCustomer(customer: Customer): Customer

Avec cette signature de fonction, nous pouvons renvoyer l'entité client ajoutée au composant appelé. Nous pouvons également vérifier si la fonction fait ce qu'elle est censée faire avec cet objet client (c'est-à-dire lui attribuer un identifiant unique).