Revue de presse Inno #11

Développement Web

Bien démarrer avec le rendu côté serveur avec Angular

Par Kévin Barralon

Cette semaine, nous avons mis en ligne un tutoriel pour les développeurs qui utilisent le framework JavaScript Angular. Ce tutoriel a pour but de les aider à initialiser un projet Angular avec le rendu côté serveur pré-configuré. L’intérêt de la mise en place d’un rendu côté serveur permet de rendre le contenu d’une application lisible par les robots (Google, Facebook, Twitter) mais aussi d’améliorer les performances d’une application Angular, avec le transfert d’état entre le côté serveur et le côté client. Ces fonctionnalités étant une nouveauté du framework, la dernière version de Angular (v5) fut utilisée dans ce tutoriel.

Vous pouvez accéder à une version plus complète de ce tutoriel en lisant cet article : Comment créer une application Angular avec le rendu côté serveur ?

Emballer vos applis JavaScript avec Parcel

Par Jacob Cook

L’écosystème JavaScript est connu pour son évolution rapide et constante. Le développement d’une application moderne en JavaScript nécessite une panoplie d’outils et librairies, y compris des “bundlers”, qui gèrent la génération et emballement des “assets” nécessaires lors de la création d’une site Web. Jusqu’à présent, il y a eu deux grands projets de “bundlers” : Browserify et Webpack. Ils ne sont pas vraiment connus pour être faciles à apprendre ou à utiliser. On n’a qu’à aller chercher Google pour savoir “pourquoi est-ce que Webpack est si… lent ? …compliqué ?” et ainsi de suite.

Il est clair que l’écosystème a besoin d’un coup de pouce à ce sujet. Il y a un nouveau projet qui compte justement donner ce coup de pouce, et il s’appelle Parcel. Il fait pas mal les mêmes choses que Webpack à la base (code splitting, transpilation et transformation, hot module replacement) mais avec très peu de “bootstrapping” à faire, et pas beaucoup d’options ou de configurations à écrire pour assurer son bon fonctionnement. Il utilise aussi un système de compilation à multi-cœur, ce qui lui permet d’être bien mieux optimisé en terme de performance et d’utilisation CPU de votre ordinateur à travers plusieurs “workers”.

Reste à voir si Parcel sera couronné le “bundler” JavaScript par excellence, mais si les premiers retours d’utilisations se confirment, il apportera une bouffée d’air frais aux développeurs Web qui ne veulent que démarrer leur prochain projet moderne avec rapidité et efficacité. Et sans avoir besoin d’aspirine ! Pour en savoir plus sur Parcel : https://parceljs.org/

Pause Hivernale !

Merci de nous avoir suivi pendant ces 11 numéros. Toute l’équipe vous souhaite un joyeux temps des fêtes.

On se revoit en Janvier 2018 !
Votre équipe Inno Hebdo

Revue de presse Inno #10

Design

Qu’est ce que design system ?

Par Patrick Bracquart

Depuis plusieurs années, la complexité des sites et applications nous ont poussé à repenser le design et les méthodologies tant les champs de compétences nécessaires se sont élargis (analyste web, designer UI/UX, designer d’interaction, développeur front-end, …). C’est dans ce contexte qu’est apparu le design system.

Le design system est le référentiel UI/UX d’un projet. C’est un guide qui va servir de support pour toute la chaîne de production, peu importe le sujet (style de vie, alimentation, services…), le terminal (ordinateur portable, mobile, montre intelligente…), ou encore le livrable (site web, application mobile, interface de gestion…).

Design System

Plus complet qu’une ligne directrice, le design system ne fait pas qu’annoncer les éléments du design (atomic) et les interactions. Il renseigne aussi sur les normes de développement à suivre, l’accessibilité, l’iconographie, la vidéo, etc. afin que tout reste parfaitement cohérent.

Mobile

Comment utiliser les espaces de nommage versatiles en Swift ?

Par Thibault Wittemberg

Avec Swift, certaines API, telles que RxSwift, utilisent une technique qui confine le code qu’elles exposent dans un espace de nommage dédié. Cela facilite grandement la lecture du code et permet par ailleurs d’étendre cet espace de nommage pour lui ajouter vos propres fonctionnalités.

Espaces de nommage versatiles en Swift

Dans cet article (en anglais), nous verrons qu’il est assez simple de créer votre propre espace de nommage et d’une façon si générique, que cela permet à un contributeur externe de l’étendre de façon élégante.

Revue de presse Inno #9

Spécial PyCon Canada 2017 (Suite !)

Que retenir de la dernière PyCon Canada ? Quelques éléments de réponse avec les développeurs de l’équipe Innovation de Savoir-faire Linux !

Conférence ‘Double Click: Continue Building Better CLIs’

Par Kévin Barralon

Cette conférence donnée lors de la PyCon Canada visait à présenter Click, un package Python permettant de créer des CLIs (Commande Line Interface) en peu de lignes de code.

L’utilisation est simple et intuitive : la configuration d’une commande passe essentiellement par l’ajout de décorateurs à votre fonction.

Par exemple, voici une fonction simple chargée de répéter un nom passé en argument :

# hello.py
import click

@click.command()
@click.option('--count', default=1, type=int, help='Number of greetings.')
@click.option('--name', prompt='Your name',
              help='The person to greet.')
def hello(count, name):
    for _ in range(count):
        click.echo(f'Hello {name}!') # Syntaxe de Python 3.6 !

if __name__ == '__main__':
    hello()

En quelques lignes de codes, vous avez créé une commande qui :

  • prend une option --count avec une valeur par défaut de 1 et dont le type exigé est un integer.
  • prend une option --name qui permet grâce à l’argument prompt passé dans votre décorateur de proposer à l’utilisateur de renseigner son nom.

Ces valeurs sont transmises directement aux paramètres count et name de la fonction décorée. Ci-dessous le code pour lancer la commande dans votre terminal :

python3 test.py --count=3

Your name: Casimir
Hello Casimir!
Hello Casimir!
Hello Casimir!

L’autre point intéressant (et pratique également !) est que si vous passez l’option --help à l’appel de votre fichier, vous obtenez l’affichage de la Docstring de votre fonction, ainsi que les informations pour chaque option fournies grâce à l’argument help passé dans vos décorateurs :

python3 hello.py --help

Usage: test.py [OPTIONS]

Simple program that greets NAME for a total of COUNT times.

Options:
--count INTEGER Number of greetings.
--name TEXT The person to greet.
--help Show this message and exit.

Plutôt que de passer des options à votre commande, vous pouvez également définir des arguments. Pour l’exemple :

@click.command()
@click.argument('filename')
def touch(filename):
    click.echo(filename)

Puis :

python3 touch.py foo.txt
foo.txt # Résultat

Comme vous pouvez le constater, les possibilités de Click sont vraiment nombreuses. Quelques unes en supplément pour l’occasion :

  • possibilité d’ajouter l’argument multiple=True dans votre décorateur @click.option qui vous renverra un tuple des options passées à l’appel de votre commande.
  • ajouter un callback en argument du @click.option qui changera le comportement de votre commande (par exemple pour définir des règles de validations sur-mesures).
  • de passer des variables d’environnement à votre décorateur (ex: envar="USERNAME").
  • définir un nombre limité ou illimité d’arguments qui retourneront un tuple.
  • ajouter une méthode File en guise de type dans votre décorateur (par exemple : @click.argument('input', type=click.File('rb'))) qui se chargera également d’ouvrir votre fichier et de le fermer automatiquement.

La liste de toutes les possibilités offertes par le package est disponible dans la documentation, très bien faite par ailleurs.

Bonus !

La conférence sur f-strings a vraiment motivé les troupes ! Voici un article de Maxime qui fait écho à celui de Sébastien la semaine dernière :

Les f-strings, qu’est-ce que ça mange en hiver?

Par Maxime Dupuis

Les chaînes de caractères-f, ou f-strings, sont une nouvelle façon de faire de l’interpolation en Python. Elles se définissent en mettant un f (ou F) en amont de la déclaration d’une chaîne de caractères : f'Ma chaîne f'.

Elles sont très semblable en comportement aux chaînes patrons (template strings) en JavaScript qui, elles, sont définies en utilisant le caractère `.

L’utilité des f-strings vient du fait qu’elles peuvent contenir des variables qui seront automatiquement interpolées avec les valeurs des variables locales définies du même nom :

>>> age = 42
>>> prenom = 'Maxime'
>>> f"Je m'appelle {prenom} et j'ai {age} ans"
"Je m'appelle Maxime et j'ai 42 ans"
>>> # L'utilisation d'une variable non-définie nous donnera une erreur de type NameError :
>>> f"{nondefini}"
Traceback (most recent call last):
File "", line 1, in
NameError: name 'nondefini' is not defined

Là où l’utilisation de chaînes de caractères-f devient intéressante est notamment du fait que ce type de chaînes est très rapide ! Si on les compare aux autres façons de créer des chaînes en Python, on a :

python3.6 -m timeit -c 'age=42; prenom="Maxime"; f"Mon nom est {prenom} et mon age est {age} ans"'
10000000 loops, best of 3: 0.172 usec per loop
python3.6 -m timeit -c 'age=42; prenom="Maxime"; "Mon nom est {prenom} et mon age est {age} ans".format(prenom=prenom, age=age)'
1000000 loops, best of 3: 0.714 usec per loop
python3.6 -m timeit -c 'age=42; prenom="Maxime"; "Mon nom est %s et mon age est %s ans" % (prenom, age)'
1000000 loops, best of 3: 0.283 usec per loop
python3.6 -m timeit -c 'age=42; prenom="Maxime"; "Mon nom est " + prenom + " et mon age est " + str(age) + " ans"'
1000000 loops, best of 3: 0.449 usec per loop
python3.6 -m timeit -c 'from string import Template; age=42; prenom="Maxime"; Template("Mon nom est $prenom et mon age est $age").substitute(prenom=prenom, age=age)'
100000 loops, best of 3: 8.75 usec per loop

Mais l’utilité des f-strings ne réside pas uniquement dans sa rapidité : Il est également possible d’appeler des fonctions, faire du traitement, et toutes autres choses :

>>> total = 10.0
>>> taxes = 1.15
>>> f'Total: {total + taxes}'
'Total: 11.15'
>>> prenom = 'Maxime'
>>> f'Mon nom est {prenom.upper()}'
'Mon nom est MAXIME'

Si cela vous intéresse et que vous n’avez pas encore découvert toutes les nouveautés que Python 3.6 peut vous offrir, consultez les notes de version : «What’s New In Python 3.6».

Mobilité

SwiftGen

Par Thibault Wittemberg

Lorsque nous développons une application iOS, nous avons régulièrement besoin d’accéder à des ressources. La façon traditionnelle pour les utiliser dans le code est de les instancier avec leurs identifiants (chaînes de caractères) :

let avatar = UIImage(named: ‘darthVader’) // gets the ‘darthVader’ image from the assets folder
let name = NSLocalizedString (‘darthVader’, comment: ‘’) // gets the localized string with the key ‘darthVader’ from the Localizable.strings file

Il en va de même pour les fonts, les storyboards et les couleurs.

Pour rappel, Swift se veut un langage assez strict sur la gestion des types et favorise la détection d’erreurs lors de la phase de compilation plutôt que lors de la phase d’exécution. Ceci étant, que se passe-t-il si l’une des ressources que l’on souhaite instancier n’est pas trouvée à l’exécution ? Puisque cette instantiation se base sur une chaine de caractères, elle est soumise à des erreurs (fautes de frappe par exemple).

La solution ? L’outil Swiftgen, qui nous permet de sécuriser cette manipulation :

  • Il évite les erreurs de frappes,
  • Il permet la complétion syntaxique,
  • Il assure que la ressource existe au moment de la compilation.

Son principe de fonctionnement est le suivant :

  • L’exécutable « Swiftgen » est installé sur le poste de développement (soit via Homebrew soit via CocoaPods),
  • Une phase de build custom lance cet exécutable lors de chaque compilation,
  • Swiftgen parcours les ressources du projet et génère le code Swift les représentant de façon « type safe ».

Les identifiants des ressources seront ainsi transformés en « enum » dont l’utilisation est bien plus sécurisée et facile. Notre exemple deviendrait :

let avatar = Asset.darthVader.image
let name = L10n.darthVader

Il est même possible de customiser les templates qui serviront à la génération du code si l’on souhaite appliquer un coding style différent de celui offert par défaut.

Lorsqu’il est combiné au framework « Reusable » (du même auteur), nous disposons d’outils quasiment indispensables (et que nous mettons en place systématiquement chez Savoir-faire Linux) et dont on souhaiterait disposer par défaut dans l’environnement de développement d’Apple.

Swiftgen est pensé pour être intégré à l’environnement d’intégration continue d’un projet (l’exécutable peut être embarqué dans une dépendance CocoaPods, évitant ainsi de l’installer sur la machine de build).

Contribution

Nouvelle version de savoirfairelinux/num2words 0.5.6

Par Ernesto Ortiz

Cinq mois depuis la version précédente de num2words v0.5.5, cinq mois vraiment actifs.

Beaucoup de nouveaux contributeurs ont apporté de grandes améliorations et ont ajouté un support pour de nouvelles langues !
Voici quelques-uns des nouveaux changements avec des « remerciements spéciaux » aux contributeurs !

  • Num2words a changé les conventions de codage pour suivre PEP8,
    La couverture du code a beaucoup augmenté et nous avons besoin de votre aide pour continuer à améliorer cela, alors regardez les problèmes,
  • Maintenant, nous pouvons utiliser d’autres convertisseurs to_currency, to_year, to_ordinal_num,
  • Merci à Tufan Kaynak d’avoir apporté son soutien à la localisation turque,
  • Merci à Jesús Leganés-Combarro d’avoir soutenu la localisation franco-algérienne,
  • Merci à Armin Oliya pour son soutien à la localisation néerlandaise,
  • Merci à Sergio Zholudov pour son soutien à la localisation ukrainienne,
  • Remerciements à Blaž Bregar pour son soutien à la localisation slovène,
  • Merci à Mārtiņš Šulcs d’avoir apporté de nombreuses améliorations au code de base, aux fonctionnalités de to_currency et plus encore !

Un merci spécial à tous ceux qui ont pris le temps de signaler de nouveaux problèmes, de faire une pull request et de partager leur temps dans ce projet !

Vous pouvez vérifier la nouvelle version dans :

Savoir-faire Linux ouvre un centre d’expertise en ingénierie logicielle libre et systèmes embarqués à Rennes

Rennes, le 30 novembre 2017 – Savoir-faire Linux est fière d’annoncer l’installation à Rennes d’un centre d’expertise en ingénierie logicielle libre et systèmes embarqués pour desservir ses clients français et européens.

Savoir-faire Linux s'installe à RennesSavoir-faire Linux est une entreprise québécoise experte en technologies libres et open source, leader au Canada et implantée en France depuis 2014. Elle a installé cet été son équipe au sein du nouvel espace collaboratif la NewsRoom, situé en plein cœur de Rennes, avec l’aide de Bretagne Commerce International et Business France. Cette équipe de démarrage a comme mission d’offrir son expertise en Linux embarqué et en technologies broadcast pour les acteurs de l’ingénierie produits, de la télé numérique, des systèmes mobiles et embarqués et de l’IoT.

Ce pôle Rennais travaille en synergie avec les équipes canadiennes pour offrir, à travers une approche nord-américaine, un haut niveau d’expertise à chaque cycle de développement et apporter une vision audacieuse sur des solutions matérielles et logicielles répondant aux besoins d’innovation et de rapidité de développement, de la phase d’idéation à la mise en marché.

Rennes, un choix stratégique

Cette installation à Rennes est un choix stratégique puisque Savoir-faire Linux mise sur son écosystème régional, riche en talents et en entreprises axées sur l’innovation pour développer son réseau. « Depuis notre arrivée en France en 2014, nous avons pu constater que notre double culture française et nord-américaine était porteuse d’innovation pour nos clients. Lors de l’International Broadcasting Convention au mois de septembre à Amsterdam, nous avons rencontré plusieurs entreprises de l’écosystème rennais et pu ainsi confirmer la pertinence de notre investissement. C’est dans cette logique d’expertise et de double culture que nous avons voulu constitué notre équipe de démarrage » explique Christophe Villemer, vice-président exécutif de Savoir-faire Linux et directeur général de la filiale France.

Éloi Bail, ingénieur Produits Senior qui après 5 ans chez Savoir-faire Linux au Canada, démarre cette aventure dans sa Bretagne natale : « Mon expérience au Canada, notamment dans le secteur industriel, du transport et du broadcast et notre réseau outre-Atlantique est un atout majeur pour pousser l’innovation, optimiser les coûts de développement et les cycles de production chez nos clients. » précise-t-il.

Une expertise pointue des communautés open source et des processus d’innovation

Savoir-faire Linux et ses ingénieurs en logiciels libres
Savoir-faire Linux et ses ingénieurs en logiciels libres

Forte d’une équipe multidisciplinaire de plus de 120 ingénieurs et développeurs, la compagnie s’appuie sur 18 ans d’expérience et de nombreuses contributions au noyau Linux (29e contributeur mondial en septembre 2017) ainsi que sur de nombreux projets open source tels que Buildroot, Uboot, Qt, Yocto ou GStreamer. Parmi ses dernières réalisations, Savoir-faire Linux collabore avec le télé-diffuseur Radio-Canada pour mener des contributions importantes au framework multimédia FFmpeg, dont les avancées ont été présentées en septembre dernier à l’IBC d’Amsterdam.

Ces solides liens avec les communautés ainsi que son intérêt pour les technologies innovantes comme la Blockchain et la robotique confère à Savoir-faire Linux une place privilégiée pour accompagner ses clients français vers une stratégie d’innovation ouverte et le développement de leurs nouveaux produits. Gilles Doffe, ingénieur Produits Senior, qui a rejoint Savoir-faire Linux avec plus de 10 années d’expérience dans le bassin rennais, précise à ce sujet qu’il a « choisi d’intégrer Savoir-faire Linux pour les valeurs d’innovation qu’elle défend, son implication dans l’open source, son approche novatrice du service et son soucis de la qualité. Sa solide expérience dans des domaines pointus comme le transport, l’industriel et la télé-diffusion en fait une nouvelle offre de choix en France et en Europe ».

Le réseau French-Tech

En tant qu’entreprise engagée et passionnée, Savoir-faire Linux souhaite participer activement au dynamise territorial. Forte de son rôle actif dans Bleu Blanc Tech, la French Tech à Montréal, l’entreprise franco-québécoise souhaite s’impliquer localement dans la French Tech Rennes Saint-Malo et sera notamment partenaire de la Digital Tech qui se tiendra les 7 et 8 décembre à Rennes et y co-animera un atelier sur les technologies Blockchain et les smart-contracts.

Revue de presse Inno #8

Spécial PyCon Canada 2017

Un numéro spécial PyCon cette semaine ! Fier commanditaire de la PyCon Canada 2017 qui se déroulait du 18 au 21 novembre à Montréal, Savoir-faire Linux vous partage dans cette nouvelle édition, les retours de nos spécialistes Python qui étaient sur place.

PyCon 2017

L’équipe de Savoir-faire Linux à la Pycon

Tutoriel : Writing Tests that Write Themselves ! Par David Kua

Par Ernesto Rodriguez Ortiz

Vous allez aimer la puissance des tests basés sur les propriétés !

Je viens de découvrir les tests basés sur les propriétés lors de la récente PyCon Canada 2017. Un grand merci à David Kua qui a préparé, présenté et partagé avec nous un excellent tutoriel autour des tests basés sur les propriétés en utilisant la librairie Hypothesis (Welcome to Hypothesis!). Le test basé sur les propriétés a été popularisé par la bibliothèque Haskell Quickcheck. Une belle découverte donc, qui me fait désormais oublier les contraintes liées aux tests !

Comment ça marche ?

L’hypothèse génère des données aléatoires correspondant à vos spécifications et vérifiant que votre garantie est toujours valable pour chaque cas de test. Regardez cet exemple vraiment simple :

# FILE NAME division.py

#! / usr / bin / env python
# - * - codage: utf-8 - * -

from hypothesis import given, settings
import hypothesis.strategies as st


# On a écris ces deux lignes trop vite ...
def division (x, y):
    retour x / y


# Hypothèse va nous montrer nos erreurs ...
@given (st.integers (), st.integers ())
@settings (max_examples = 1000)
def test_commutativity_pbt (x, y):
    affirmer la division (x, y) * y == x

Ensuite, lancez :

pytest --hypothesis-show-statistics division.py

Vous devriez voir comment Hypothesis a trouvé le cas :

ZeroDivisionError: division by zero

C’est un outil vraiment puissant, surtout si vous feuilletez l’excellent tutoriel de David Kua et consultez la documentation de Hypothesis.

Closing Keynote – Mariatta Wijaya

Par Sébastien Blin

Lors de la conférence de clôture, Mariatta Wijaya – Core Developer de Python – nous a présenté Python 3.6, en mettant de l’avant une PEP de cette version : la PEP 498: Literal String Interpolation. Mariatta est revenue sur l’histoire de cette PEP, en partant du courriel reçu de la liste de diffusion, il y a quelques années. Les “f-string” permettent d’améliorer la construction de chaînes de caractères contenant des variables, le tout de manière plus performante et plus lisible que l’opérateur % ou la fonction str.format :

>>> import datetime
>>> name = 'Fred'
>>> age = 50
>>> anniversary = datetime.date(1991, 10, 12)

>>> f'My name is {name}, my age next year is {age+1}, my anniversary is {anniversary:%A, %B %d, %Y}.'
'My name is Fred, my age next year is 51, my anniversary is Saturday, October 12, 1991.'

>>> f'He said his name is {name!r}.'
"He said his name is 'Fred'."

Elle a ensuite énoncé les autres PEP releasées avec Python 3.6 (dont la PEP 628 pour math.tau, qui n’existe pas, mais tau vaut 6.28). La liste complète des PEPs pour Python 3.6 est visible ici : Python 3.6 Release Schedule.

Dans tous les cas, Mariatta nous invite à passer à Python 3.6, dès aujourd’hui, ainsi qu’à contribuer à l’évolution de ce langage, au travers l’écriture de PEPs, sur ce dépôt Github.

Contributions

GitHub dévoile son outil de discussion par équipe

Par Romain Bertozzi

La contribution au logiciel libre, c’est avant tout du partage où la communication prend une place essentielle. Dans ce contexte, GitHub a annoncé lundi 20 novembre dernier, le déploiement de discussions par équipe avec Introducing Team discussions.

L’idée est de soulager les issues et pull requests de conversations dont certaines n’ont pas forcément leur place. Ces issues et PR gagneront donc en efficacité et en lisibilité.

De plus, ces nouvelles discussions, publiques ou privées, auront leurs URLs dédiées et pourront être efficacement partagées et citées. Chez Savoir-faire Linux, nous accueillons cette nouvelle avec enthousiasme.

Nous pensons en effet que cela amènera plus de clarté aux échanges qui façonnent la direction d’un projet. La centralisation et la facilité de partage des discussions sont des atouts qui permettront de favoriser la transparence et la pérennité des échanges.

Reste à voir comment cette fonctionnalité sera adoptée par les utilisateurs de Github, et si ces mêmes utilisateurs ne disposent pas déjà d’alternatives et d’habitudes bien ancrées.