Le Big Data en 2018

Ce n’est plus un secret, le nombre de données à stocker ne cesse d’augmenter. Qu’est ce que le BIG DATA ? Quels sont les fournisseurs, les technologies et les méthodologies qui permettent de gérer ces exaoctets d’informations ? Qu’est ce qu’un DATA LAKE ? Quelles sont les limites de confidentialité et d’étiques liées au traitement des données ?

Réponses en images grâce au MEET UP « Le Big Data en 2018″ animé chez EXteam par notre collaborateur Juba Nait Abdesselam.

Les slides :

La vidéo du MEET UP :

EXteam recrute un EXPERT TECHNIQUE JAVA/DEVOPS (H/F)

Mission :

– La réalisation d’audits d’applications JEE, préventifs ou curatifs, principalement orientés disponibilité, performances et sécurité.
– La prise en charge des missions de conseil et expertise JEE à destination des équipes en charge de la réalisation des applications ainsi que les équipes en charge des infrastructures d’hébergement de celles-ci.
– La participation et/ou le pilotage des task forces en tant qu’expert Java/JEE.
– Expertise et accompagnement dans la mise en place des toolchains Dev’Ops

Environnement technique :

Expérience de plusieurs années en développement Java/JEE
Très bonne connaissance de frameworks java du marché (servlet, web services, spring, Angular, hibernate .)
Bonnes compétences: IBM Websphere Application Server ou autre solution de serveur d’application JEE
Une maitrise de la sécurité WEB
Une connaissance des outils d’introspection (Introscope, dynaTrace) est un plus.
Expérience en tant qu’utilisateur ou concepteur de toolchain de développement et des outils du marché (Git, Jenkins, et/ou autres)
Expérience de la méthodologie scrum agile

LES FONCTIONS

Contribution de SAVANE VAMARA / Ingénieur Java Big Data EXteam chez EDF.

Les fonctions sont les pièces maîtresses dans les langages de programmation fonctionnelles.

fonctionNous allons explorer certaines propriétés des fonctions et voir comment nous pouvons les utiliser dans un langage de programmation fonctionnel.

Définition de la fonction

Une fonction est une boîte noire qui, lorsqu’on lui donne une entrée nous donne toujours la même sortie.

Une fonction n’a aucun effet secondaire, et s’il y en a , il pourrait s’agir d’une procédure mais pas une fonction.

La fonction est un terme qui vient des mathématiques et il n’y a pas de concept d’effet secondaire là-dedans.

Les valeurs en entrée à une fonction sont appelées « domaine d’une fonction ».

La sortie d’une fonction s’appelle codomain et l’ensemble des sorties sont appelées l’ image de la fonction.

Nous pouvons décomposer comme ceci:

f: A -> B

A est le domaine et B est le codomaine.

Comme nous l’avons dit A est le domaine B est le codomaine et [2, 4, 6] est l’image de la fonction.

Arité

L’arité est le nombre d’arguments qu’une fonction peut prendre.

Nous disons que l’arité de f(x: Int) est 1. C’est une fonction unaire ou c’est une fonction avec un argument.

AritéPar conséquent l’arité d’une fonction peut être exprimée avec un nombre ou de terme.

Unaire, binaire, ternaire, etc …

Ce sont des mots qui viennent du latin mais on utilise généralement le grec au lieu du latin.

On peut dire aussi que l’arité d’une fonction est monadique , dyadique ou triadique.

Composition de la fonction

La composition de la fonction est l’une des bases de la programmation fonctionnelle.

Composition de la fonction

L’idée est que si vous avez une fonction f = A->B et une fonction g = B->C vous pouvez créer une 3ème fonction h = A->C qui utilise en interne f et g pour créer ce C qui est: h = g(f(x)).

Si nous l’exprimons en termes mathématiques, nous pouvons dire que h = f∘g “h est égal à f après g” ou ce qui est le même:

Un exemple de composition de fonction est : h = Cgf

def intToString(i: Int) : String = i.toString

def stringToDouble(s: String) : Double = s.toDouble

val composedFunction = stringToDouble _ compose intToString

Nous avons déclaré deux fonctions intToString et stringToDouble, lorsque nous les composons, nous créons une troisième fonction qui accepte un int et renvoie un double.

Donc si nous l’appelons:

composedFunction(“32”) il retourne 32.0 qui est le résultat après la conversion de cette chaîne en int et du int en un double.

Notez que lors de la composition des fonctions est appliquée de droite à gauche cette fois: intToString et puis stringToDouble.

intToString - stringToDouble

Nous pouvons faire la même chose sans modifier l’ordre des fonctions avec la fonction andThen ce sera comme ceci:

val composedFunction2 = intToString _ andThen stringToDouble

C’est pareil et à mon avis moins déroutant…

Cette dernière expression pourrait être énoncée sans les opérateurs infixes comme suit:

val composedFunction2 = (intToString(_)).andThen(stringToDouble)

Fonctions d’ordre supérieur

L’idée derrière les fonctions d’ordre supérieur est que les fonctions sont des valeurs donc les fonctions peuvent être transmises comme les entiers, les chaînes, etc …

Fonctions

Les fonctions qui acceptent d’autres fonctions comme arguments ou fonctions de retour sont appelées des fonctions d’ordre supérieur.

Un exemple d’une fonction d’ordre supérieur vraiment commune est map, sa définition dans la classe List de Scala est:

def map[B](f: A => B): List[B]

La signification de map est d’appliquer une transformation à chaque élément de la liste et de renvoyer une nouvelle liste avec tous les nouveaux éléments transformés.

Si un langage supporte des fonctions d’ordre supérieur, nous disons que les fonctions dans cette langue sont traitées comme des first class citizen, c’est-à-dire que les fonctions sont des fonctions de première classe.

First Class

Donc quand nous nous référons à un langage de programmation, nous disons que la langue supporte les first class citizen mais si nous nous référons à une fonction nous disons que la fonction est une fonction de première classe.

L’un des usages pratiques des fonctions d’ordre supérieur est de créer des fonctions en ligne que nous appelons des fonctions anonymes ou des littéraux de fonction.

Un exemple utilisant la carte précédemment définie pourrait être ceci:

List(1).map(i => i + 1)

Comme vous pouvez le voir, la fonction i => i + 1 est passée en argument de la mapfonction.

Application partielle

Application partielle signifie que pour une fonction qui accepte un certain nombre d’arguments N nous pouvons fixer ou lier certains de ses arguments qu’il faut pour réduire l’arité de la fonction.

Considérez ces deux fonctions:

def sum(a: Int, b: Int) = a + b

def sumOfOneWith(a: Int) = sum(1, a)

Notez que sumOfOne la somme des fonctions est partiellement appliquée en réduisant son arité à 1.

C’est très utile et si vous jetez un coup d’œil sur Internet vous verrez des personnes utiliser cette technique en remplacement de l’injection de dépendance.

Currying

Currying ou la curification est une technique qui nous permet de décomposer une fonction avec arité N (où N est > 1) dans une chaîne d’appels à des fonctions plus petites avec une arité 1.

Voyons un exemple:

def sumCurried = (a: Int) => (b: Int) => a + b

sumCurried(1)(1) == 2

Maintenant sumCurried est une fonction qui renvoie une autre fonction et cette dernière calcule le résultat.

En faisant cela nous avons réduit l’arité de la somme à 1 en l’exprimant comme une fonction plus petite.

Scala peut automatiquement activer une fonction en utilisant la curriedfonction, un exemple de la version précédente de sum:

sum _ curried

Ceci est un exemple d’implémentation de curry ou la curification:

def curry[A, B, C](f: (A, B) => C): A => (B => C) = a => b => f(a, b)

Ce qu’il fait c’est de recevoir une fonction avec arité 2 , de retourner une fonction avec une arité 1 , qui retourne une autre fonction avec une arité 1 et finalement cette fonction appelle la fonction donnée avec les paramètres requis.

Prenez le temps de digérer cela et si vous en avez l’occasion, amusez-vous un peu jusqu’à ce que vous compreniez le concept.

C’est une technique puissante mais il faut du temps pour bien la comprendre.

Nous pouvons aussi bien curifié une fonction.

C’est le même concept mais tout autour nous prenons une fonction avec moins d’arité et nous la convertissons en une autre avec une plus grande arité.

Le double de la fonction précédente est:

def uncurry[A, B, C](f: A => (B => C)): (A, B) => C = (a, b) => f(a)(b)

Cette fois il prend une fonction avec une arité 1 et renvoie une fonction avec une arité 2 qui applique finalement ces arguments à l’original.

Currying VS application partielle

Alors quelle est la différence entre curry ou curification et application partielle?

Comme nous l’avons déjà dit:

Currying ou curification:
Possibilité de décomposer une fonction avec arité N (où N est > 1) dans une chaîne d’appels à des fonctions plus petites avec arité 1

Application partielle:
Possibilité d’appliquer une fonction avec un ensemble donné d’arguments pour réduire l’arité de la fonction d’origine.

Une exigence de faire une application partielle est que la fonction est déjà curifié pour que nous puissions appliquer les arguments un par un.

Contact

N’hésitez pas à nous solliciter pour vos projets ou pour en savoir plus sur nos expertises, nos offres et nos domaines de compétences.