Participation Duchess à Hacktoberfest 2021

Cette année Duchess s’est lancée un nouveau défi : travailler sur la présence des femmes dans l’Open Source à travers une participation à Jenkins à l’occasion de l’événement annuel Hacktoberfest.
Un grand bravo aux contributrices ! 🥳

Interview d’Anne-Laure Gaillard

https://www.linkedin.com/in/annelauregaillard/

Bonjour Anne-Laure, peux-tu te présenter ?

Après un doctorat en informatique puis quelques années dans le développement logiciel, je me suis spécialisée dans la qualité logicielle, notamment dans le domaine du test. Je suis partisane de la doctrine « La qualité est l’affaire de tous ». Passionnée par l’agilité, je fais partie du comité d’organisation de l’Agile Tour Bordeaux depuis 2020.
J’aime également me lancer dans des défis sportifs, j’ai traversé la Garonne à la nage et terminé deux triathlons. Le meilleur pour la fin, je suis maman de deux enfants qui m’ont appris qu’il est possible de parler Pokémon avec l’un tout en dessinant une licorne avec l’autre.

Que pensais-tu de l’Open Source, et éventuellement de Jenkins, avant de faire le hackathon ?

Durant mes études j’ai côtoyé pas mal de « Geeks et Geekettes » qui contribuaient aux distributions Linux (Gentoo et Debian). Leurs capacités techniques me semblaient plus élevées que les miennes et l’univers de l’Open Source me paraissait inaccessible. En ce qui concerne Jenkins, je suis utilisatrice (et maintenant contributrice) mais pas administratrice.

Qu’est-ce qui t’as motivée pour participer à ce hackathon ?

J’ai osé me lancer grâce aux Duchess (et surtout à Angélique, merci à elle). Le fait d’avoir le soutien et l’appui de la communauté a été ma motivation.

Que retiens-tu de cette expérience ?

D’un point de vue professionnel, j’ai perfectionné ma connaissance de Git et j’ai pu voir une partie des processus qualité des projets Open Source. Ma première Pull Request a été approuvée par… 9 personnes ! La 4ème personne a relevé une coquille. Qui pourra me dire que la revue de code n’est pas utile ?
D’un point de vue personnel, je retiens deux choses. La première, les communautés Open Source ne sont pas des communautés élitistes, “chaque contribution compte” aussi petite soit-elle, les personnes rencontrées sont très positives et bienveillantes. La seconde, s’illustre par une citation de Grace Hopper “Si c’est une bonne idée, allez-y et faites-le. Il est beaucoup plus facile de s’excuser que d’obtenir la permission”.

As-tu des choses à ajouter ?

Après Jenkins j’ai également réalisé des PRs sur d’autres projets Open Source. Le problème : avec la diversité des projets Open Source, comment choisir de répartir son temps ?

Ses contributions

https://github.com/jenkinsci/jenkins/pull/5779
https://github.com/jenkinsci/jenkins/pull/5785
https://github.com/jenkinsci/jenkins/pull/5804
https://github.com/jenkinsci/jenkins/pull/5806
https://github.com/jenkinsci/jenkins/pull/5807
https://github.com/jenkinsci/jenkins/pull/5808
https://github.com/jenkinsci/jenkins/pull/5822
https://github.com/jenkinsci/jenkins/pull/5823

https://github.com/mattermost/quality-assurance/pull/25
https://github.com/mattermost/quality-assurance/pull/23

https://github.com/sarequl/Netflix-Helper/pull/6

Interview de Bertha Torres

twitter: @tatoberres
linkedin: https://www.linkedin.com/in/bertha-torres-62b672209/

Bonjour Bertha, peux-tu te présenter ?

De formation littéraire et enseignante des langues pendant plus de 15 ans, c’est lors d’un déménagement dans une zone de haute montagne qu’un besoin d’explorer mes autres compétences s’est installé.
Ainsi, une formation en autodidacte suivie d’un dossier validé de financement de formation diplômante se sont enchaînées et m’ont confirmé que la vie est trop courte pour la gaspiller dans ce qui ne nous fait pas du sens.

Que pensais-tu de l’Open Source, et éventuellement de Jenkins, avant de faire le hackathon ?

La participation à l’Open Source s’est présentée dans ce processus d’exploration comme une opportunité d’apprentissage… que je pensais inaccessible bien sûr ! Je ne me voyais pas toucher au code. Mais à l’aide des Duchess France, j’ai appris à contribuer à mon niveau et à comprendre le processus de contribution. Ça me permettra, au fur et à mesure de mes apprentissages, de contribuer dans plus des domaines.

Peux tu nous raconter comment est née la version femme de Jenkins ?

Eh bien… Dans la vidéo de présentation pour Hacktoberfest on en parlait de l’artwork (https://www.jenkins.io/artwork/) et Angélique aussi en a parlé dans la première réunion… et c’est vrai qu’en regardant ce qu’il y a, on y voit de tous types, sauf des femmes. Donc j’ai imaginé une gouvernante, très sûre d’elle, bien efficace, une pointe maligne, scrupuleusement peignée, habillée en tailleur, qui pourrait représenter la personnalité de ce qui fait Jenkins.

As-tu des choses à ajouter ?

Cette fois-ci, j’ai pu participer avec des Pull Requests en traduction et dessin. Je recommencerai sans doute !

Ses contributions

https://github.com/jenkins-infra/jenkins.io/pull/4627
https://github.com/jenkinsci/jenkins/pull/5796
https://github.com/jenkinsci/jenkins/pull/5797
https://github.com/jenkinsci/workflow-job-plugin/pull/214
https://github.com/jenkinsci/workflow-job-plugin/pull/215
https://github.com/jenkinsci/ant-plugin/pull/78
https://github.com/jenkinsci/ant-plugin/pull/77

Interview de Pauline Iogna

twitter : @pauline_io

Bonjour Pauline, peux-tu te présenter ?

Je suis une développeuse backend Java/Scala, membre active de Duchess France

Que pensais-tu de l’Open Source, et éventuellement de Jenkins, avant de faire le hackathon ?

Je n’avais pas vraiment d’avis sur Jenkins avant de faire le hackathon. Comme beaucoup je suis utilisatrice de Jenkins mais je ne connaissais pas le code source.

Qu’est ce qui t’as motivée pour participer à ce hackathon ?

Participer au hacktoberfest. Juste apporter une contribution, même modeste sur un projet open source.

Qu’as- tu découvert à travers ce hackathon ?

Techniquement, j’ai découvert comment faire du MVC avec Apache Jelly.
J’ai aussi redécouvert le processus des contributions Open Source.
Le système du hacktoberfest est vraiment bien pensé pour on-boarder les gens qui veulent démarrer sur des projets Open Source. Avec en plus l’aide d’Angélique pour animer des sessions sur le Slack Duchess France, nous avons eu les meilleures conditions pour contribuer sur ce projet important.

Que retiens-tu de cette expérience ?

Pas si simple de contribuer sur un projet qu’on découvre, il faut un peu d’investissement et de patience. Sur Jenkins les committers sont très réactifs, les Pull Request sont revues rapidement, les feedbacks sont utiles et bienveillants.
Il y a un Jira qui répertorie les features et les bugs à traiter sur le projet. Certains tickets sont taggués “newbie” ce qui permet à ceux qui débutent de choisir des tickets faisables rapidement.

Ses contributions

https://github.com/jenkinsci/jenkins/pull/5835
https://github.com/jenkinsci/jenkins/pull/5793

Quelques mots sur l’organisation Duchess

Le cadre était intentionnellement simple et flexible. Nous avons commencé par une réunion de lancement en ligne pour décrire un peu le contexte et plus précisément l’univers de Jenkins dont voici l’enregistrement:

Ensuite nous avons échangé principalement via le Slack Duchess de façon asynchrone sur un channel dédié, ainsi en direct avec une réunion de 30 minutes tous les vendredis.

Soirée UX-Design : Dev et UX sont dans un bateau !

Dans le cadre du CFP de Devoxx, j’ai repéré plusieurs personnes qui ont proposé des sujets top autour de l’UX Design. Avec les Duchess on s’est dit « mais nous n’avons jamais organisé de soirée autour de l’UX !! ». Nous avons donc rapidement contacté 4 expertes, et une soirée UX+Dev aura lieu chez Seloger le mercredi 14 Mars à Paris !

 

Lire la suite

Hands-On : Streaming Data le 2 Novembre

Première soirée de la rentrée, ce jeudi 2 novembre, nous aurons l’occasion d’organiser un meetup autour du sujet « Streaming Data ». Pour en savoir plus sur le thème, voici un livre intéressant publié sur Manning.
Lire la suite

Hands on – Angular JS

Notre série de Hands On continue avec un atelier Angular JS.
Avec les nouveautés autour d’Angular JS, mieux vaut tard que jamais pour s’y initier. Angular JS est un framework JavaScript, il permet d’étendre le langage HTML grâce aux  « Directives » et permet d’utiliser les données via des « Expressions ». Lire la suite

Hands on – Programmation Réactive

Après le hands-on GO et la soirée Scalabilité, on reste mainstream avec un hands-on sur la programmation Réactive le mercredi 10 février, de 19h15 à 22h30 ! Lire la suite

Hands-On Golang le jeudi 14 Janvier

L’année 2016 démarre en beauté avec un Hands-On Golang spécial débutant ! Cet atelier sera animé par Jawher Moussa et moi même et aura lieu à Xebia ce jeudi 14 Janvier. Lire la suite

Getting started with Spark in practice

Some months ago, we, Sam Bessalah and I organized a workshop via Duchess France to introduce Apache Spark and its ecosystem.

This post aims to quickly recap basics about the Apache Spark framework and it describes exercises provided in this workshop (see the Exercises part) to get started with Spark (1.4), Spark streaming and dataFrame in practice.

If you want to start with Spark and come of its components, exercises of the workshop are available both in Java and Scala  on this github account. You just have to clone the project and go! If you need help, take a look at the solution branch.

With MapReduce/Hadoop frameworks the way to reuse data between computations is to write it to an external stable storage system like HDFS. And it’s not very effective when you iterate because it suffers from I/O overhead.

If you want to reuse data, in particular, if you want to use Machine Learning algorithms you need to find a more efficient solution. This was one of the motivation behind the creation of the Spark framework: to develop a framework that works well with data reuse.

Other goals of Apache Spark were to design a programming model that supports more than MapReduce patterns, and to maintain its automatic fault tolerance.

In a nutshell Apache Spark is a large-scale in-memory data processing framework, just like Hadoop, but faster and more flexible.

Furthermore Spark 1.4.0 includes standard components: Spark streaming, Spark SQL & DataFrame, GraphX and MLlib (Machine Learning libraries). And these frameworks can be combined seamlessly in the same application.

Here is an example on how to use Spark and MLlib on data coming from an accelerometer.

 

RDD

Spark has one main abstraction: Resilient Distributed Datasets or RDDs.

An RDD is an immutable collection partitioned across the nodes of the cluster which can be operated on in parallel.

You can control the persistence of an RDD:

• RDDs can be stored in memory between queries, if you need to reuse it (improve the performances in this way)
• you can also persist an RDD on disk

RDDs support two types of operations (transformations and actions):

• a transformation creates another RDD and it is lazy operation (for example: map, flatmap, filter, groupBy…)
• an action returns a value after running a computation (for example: count, first, take, collect…)

You can chain operations together, but keep in mind that the computation only runs when you call an action.

 

Operation on RDDs: a global view

Here is a general diagram to understand the data flow.

1. To the left, the input data comes from an external storage. The data are loaded into Spark and an RDD is created.
2. The big orange box represents an RDD with its partitions (small orange boxes). You can chain transformations on RDDs. As the transformations are lazy, the partitions will be sent across the nodes of the cluster when you will call an action on the RDD.
3. Once a partition is located on a node, you can continue to operate on it.

N.B: all operations made on RDDs are registered in a DAG (direct acyclic graph): this is the lineage principle. In this way if a partition is lost, Spark can rebuilt automatically the partition thanks to this DAG.

 

An example: the wordcount

Here is the wordcount example: it is the “hello world” for MapReduce.

The goal is to count how many times each word appears in a file, using the mapreduce pattern.

https://gist.github.com/nivdul/0b84c5184ae42278b02f#file-wordcount

First the mapper step: we attribute 1 to each word using the transformation map.

Finally the reducer step: here the key is a word, and reduceBykey, which is an action, return the total for each word.

https://gist.github.com/nivdul/0b84c5184ae42278b02f

Exercises

In this workshop the exercises are focused on using the Spark core and Spark Streaming APIs, and also the dataFrame on data processing. The workshop is available in Java (1.8) and Scala (2.10). And to help you to implement each class, unit tests are in and there are a lot of comments.

Prerequisites

In order to get the exercises below, you need to have Java 8 installed (better to use the lambda expression). Spark 1.4.0 uses Scala 2.10 so you will need to use a compatible Scala version (2.10.x). Here we use 2.10.4.
As build manager, this hands-on uses maven for the Java part and sbt for the Scala one. As unit tests library, we use jUnit (Java) and scalatest (Scala).

All exercises runs in local mode as a standalone program.

To work on the hands-on, retrieve the code via the following command line:
#Scala
$ git clone https://github.com/nivdul/spark-in-practice-scala.git

#Java
$ git clone https://github.com/nivdul/spark-in-practice.git

Then you can import the project in IntelliJ or Eclipse (add the SBT and Scala plugins for Scala), or use sublime text for example.

If you want to use the spark-shell (only scala/python), you need to download the binary Spark distribution spark download.

# Go to the Spark directory
$ cd /spark-1.4.0

# First build the project
$ build/mvn -DskipTests clean package

# Launch the spark-shell
$ ./bin/spark-shell
scala >

 

Part 1: Spark core API

To be more familiar with the Spark API, you will start by implementing the wordcount example (Ex0).

After that you will use reduced tweets as the data along a json format for data mining (Ex1-Ex3). It will give you a good insight of the basic functions provided by the Spark API.

https://gist.github.com/nivdul/b41f54f02b983bc0bf05#file-reduced_tweets-json

You will have to:

• Find all the tweets by user
• Find how many tweets each user has
• Find all the persons mentioned on tweets
• Count how many times each person is mentioned
• Find the 10 most mentioned persons
• Find all the hashtags mentioned on a tweet
• Count how many times each hashtag is mentioned
• Find the 10 most popular Hashtags

The last exercise (Ex4) is a way more complicated: the goal is to build an inverted index knowing that an inverted is the data structure used to build search engines.

Assuming #spark is a hashtag that appears in tweet1, tweet3, tweet39, the inverted index will be a Map that contains a (key, value) pair as (#spark, List(tweet1,tweet3, tweet39)).

Part 2: streaming analytics with Spark Streaming

Spark Streaming is a component of Spark to process live data streams in a scalable, high-throughput and fault-tolerant way.

 

In fact Spark Streaming receives live input data streams and divides the data into batches, which are then processed by the Spark engine to generate the final stream of results in batches.

The abstraction, which represents a continuous stream of data is the DStream (discretized stream).

In the workshop, Spark Streaming is used to process a live stream of Tweets using twitter4j, a library for the Twitter API.

To be able to read the firehose, you will need first to create a Twitter application at http://apps.twitter.com, get your credentials, and add it in the StreamUtils class.

In this exercise you will:

• Print the status text of the some of the tweets
• Find the 10 most popular Hashtag over a 1 minute window

 

Part 3: structured data with the DataFrame

A DataFrame is a distributed collection of data organized into named columns. It is conceptually equivalent to a table in a relational database or a data frame in R/Python, but with richer optimizations under the hood.
In fact, the Spark SQL/dataframe component provides a SQL like interface. So you can apply SQL like queries directly on the RDDs.

DataFrames can be constructed from different sources such as: structured data files, tables in Hive, external databases, or existing RDDs.

In the exercise you will:

• Print the dataframe
• Print the schema of the dataframe
• Find people who are located in Paris
• Find the user who tweets the more

 

Conclusion

If you find better way/implementation, do not hesitate to send a pull request or open an issue on github.

Here are some useful links around Spark and its ecosystem:

• Apache Spark website
• Spark Streaming documentation
• Spark SQL and DataFrame documentation
• Databricks blog
• Analyze data from an accelerometer using Spark, Cassandra and MLlib