Affichage des articles dont le libellé est paradigmes. Afficher tous les articles
Affichage des articles dont le libellé est paradigmes. Afficher tous les articles


Libellés : , ,

Développeur artisan


We are tired of writing crap.


"Learning. Caring. Practicing. Sharing." The Four Pillars Of Software Craftsmanship

J'ai décidé dans cet article de me faire l'écho d'une mouvance qui refait surface récemment, le "software craftsmanship". Elle a pour but de valoriser le métier du développement logiciel comme l'artisanat au sens puriste du terme : un travail nécessitant savoir-faire, maîtrise et respect.

Après m'être renseigné, j'ai pu constaté que les débats autour de ce thème étaient déjà très avancés puisque l'idée n'est pas nouvelle (initiée au tout début des années 2000 notamment par le livre The Pragmatic Programmer: From Journeyman to Master).

Mon but ici n'est donc pas de lancer un n-ième débat mais plutôt de partager ces valeurs qui à mon sens peuvent apporter beaucoup de choses dans la façon de voir et de fonctionner dans ce métier. Pour illustrer ceci, je ne citerai que Robert Martin et son article sur le sujet qui résume en quelques points ces idées :

What we are not doing:

  • We are not putting code at the center of everything.
  • We are not turning inward and ignoring the business and the customer.
  • We are not inspecting our navels.
  • We are not offering cheap certifications. 
  • We are not forgetting that our job is to delight our customers. 

What we will not do anymore:

  • We will not make messes in order to meet a schedule.
  • We will not accept the stupid old lie about cleaning things up later.  
  • We will not believe the claim that quick means dirty.
  • We will not accept the option to do it wrong.
  • We will not allow anyone to force us to behave unprofessionally. 

What we will do from now on:

  • We will meet our schedules by knowing that the only way to go fast is to go well.
  • We will delight our customers by writing the best code we can.
  • We will honor our employers by creating the best designs we can.
  • We will honor our team by testing everything that can be tested.
  • We will be humble enough to write those tests first.
  • We will practice so that we become better at our craft.  

We will remember what our grandmothers and grandfathers told us:

  • Anything worth doing is worth doing well.
  • Slow and steady wins the race.
  • Measure twice cut once.
  • Practice, Practice, Practice.

Je vous invite donc à lire attentivement les différentes opinions listées dans les sources, elles apportent toutes un point de vue instructif et qui laisse quelques champs de réflexion...

Sources :


Fichier(s) joint(s) :

Publié par Paul-Emmanuel Faidherbe 0 commentaires


Libellés : , , , ,

Un peu de culture générale sur la programmation

Parce qu'on ne devient pas un bon développeur en se contentant de "pisser du code" (dixit un des mes anciens profs!), il faut savoir de temps en temps prendre du recul et apprendre des choses plus théoriques, globales sur notre métier.

Cette idée est illustrée par le précepte très répandu "Sharpening the saw", tiré du livre "The 7 Habits of Highly Effective People" de Stephen R. Covey :

There's a guy who stumbled into a lumberjack in the mountains. The man stops to observe the lumberjack, watching him feverishly sawing at this very large tree. He noticed that the lumberjack was working up a sweat, sawing and sawing, yet going nowhere. The bystander noticed that the saw the lumberjack was using was about as sharp as a butter knife. So, he says to the lumberjack, "Excuse me Mr. Lumberjack, but I couldn't help noticing how hard you are working on that tree, but going nowhere." The lumberjack replies with sweat dripping off of his brow, "Yes... I know. This tree seems to be giving me some trouble." The bystander replies and says, "But Mr. Lumberjack, your saw is so dull that it couldn't possibly cut through anything." "I know", says the lumberjack, "but I am too busy sawing to take time to sharpen my saw."

J'ai donc décidé aujourd'hui d'écrire cet article sur la programmation en générale (différents types, classification...). Voici son contenu :

  1. Paradigmes les plus courants
  2. Classification selon les grammaires
  3. Différentes générations de langages

Le but de cet article est d'attirer l'attention sur ces notions. Je vous laisse libres d'approfondir le sujet en suivant les liens à la fin de l'article.

Paradigmes les plus courants

La première façon de classifier les langages de programmation est de les grouper selon leur fonctionnement fondamental. Ici sont donc présentés les 5 principaux paradigmes incluant des langages parmi les plus connus :

  • Programmation déclarative : consiste simplement à décrire les informations utilisées ou leur agencement. Exemples : HTML
  • Programmation séquentielle : l'exécution du programme suit le déroulement des instructions qui le compose. Exemples : PHP
  • Programmation procédurale : se base sur l'appel de méthodes. Une vision un peu plus modulaire de la programmation séquentielle. Exemples : PHP, C
  • Programmation orientée objet : met en relation des entités logicielles représentant des concepts ou des idées indépendants. Exemples : JAVA
  • Programmation évènementielle : contrairement à la séquentielle, le déroulement du code réagit à la réception d'évènements de l'application. Exemples : JavaScript, ActionScript

Classification selon les grammaires

La grammaire d'un langage de programmation est une série de règles définissant sa syntaxe. Java est basée sur une grammaire de type 3 dans la classification de Chomsky.

Noam Chomsky est un linguiste américain qui a beaucoup travaillé sur l'étude des langues naturelles et qui a également fortement contribué à l'évolution de la structuration des langages formels, notamment en informatique. Sa classification peut se résumer ainsi :

  • Les grammaires de type 1, sans contrainte (où chaque phrase est composée d'un seul et unique mot)
  • Les grammaires de type 2, dites contextuelles (chaque phrase est composée d'une partie centrale encadrée de 2 mots)
  • Les grammaires de type 3 ou hors-contexte (il existe plusieurs types de décomposition d'une même phrase à une étape donnée)
  • Les grammaires de type 4, dites régulières (la partie droite ou gauche d'une phrase est elle-même une phrase)

Concrètement, appliqué à Java, c'est sa grammaire de définition qui permet au compilateur de dire que la phrase suivante est juste :

public static void main(String[] args)

Plutôt que :

public void static main(String[] args)

Qui lèvera une erreur de compilation. C'est donc ce système de grammaire qui permet de créer des compilateurs, à l'image des fonctionnalités proposées par les outils Lex et Yacc. Un autre outil plus répandu reposant sur ce même principe : les expressions régulières. En effet, elle permettent de créer une grammaire à base de symboles terminaux, mots, phrases etc permettant de tester des chaines de caractères (des mini-compilateurs en quelque sorte!).

Je ne vais pas m'attarder plus longtemps sur ce sujet, à la fois vaste et très complexe, mais je pense qu'il est bon d'au moins jeter un oeil à ce principe et aux façons dont il peut être appliqué en programmation (notamment en survolant la définition de la grammaire Java). Je fournis plus bas tous les liens nécessaires pour creuser la discussion.

Différentes générations de langages

Pour terminer, il faut savoir que chaque langage appartient à une génération, représentant son niveau d'abstraction :

  1. 1GL (First generation language) : composés uniquement de 1 et 0, ils sont directement interprétés par la machine.
  2. 2GL (Second generation language) : ce sont des langages d'assembleur. Une syntaxe un peu plus intelligible mais directement convertible en langage machine.
  3. 3GL (Third generation language) : regroupe tous les langages structurés. Introduisent les notions de fonctions, d'objets et les paradigmes vus plus haut. Dans les faits, ces langages ne dépendent plus du processeur, mais d'un compilateur spécifique, comme pour Java.
  4. 4GL (Fourth generation language) : ceux-ci ont généralement une syntaxe un peu plus proche du langage naturel, mais sont destinés à des usages assez spécifiques, comme SQL.
  5. 5GL (Fifth generation language) : répondent aux besoins de la programmation par contraintes, plutôt que par algorithme, comme dans le cadre de l'intelligence artificielle.


Sources


Fichier(s) joint(s) :

Publié par Paul-Emmanuel Faidherbe 2 commentaires
Inscription à : Commentaires (Atom)