Codemotion Magazine

We code the future. Together

Home » Articles » Events » Waiting for Codemotion Rome 2020
Events

Waiting for Codemotion Rome 2020

Do you want to learn more about the talk proposals submitted to Codemotion Rome 2020? And do you also like data science? Well, this post is for you!

by

Table Of Contents

What data science can tell us about it

The Call for Papers has been closed and 646 proposals have been submitted to Codemotion Rome 2020. We’re still waiting for the confirmed talks and all tracks, but first speakers have been already announced on the official page, so do not forget to check that out to be up to date with the event, and book your ticket if you haven’t yet.

While waiting for the final agenda I thought it may be interesting to look into the submissions with a lens in order to discover the small world of the authors: so without wasting too much time let’s dig into the Codemotion world of developers and their communities.

Loading the data

Each author that submitted a talk to a Codemotion conference filled a form where its employer (company) and related communities are included to the submission: while some fields are mandatory, for instance the company field, some others are not, like communities, so we know beforehand that some authors may haven’t filled up the communities field as it wasn’t strictly necessary.

But let’s move on with the data loading process and leave the rest of thoughts on the data to the analysis. The data has been exported in a JSON file ready to be imported in a database.

The data in its raw format is a simple JSON file codemotion-rome-2020-papers.json of this shape

To perform the analysis I used a graph database, in particular,  Neo4J, using its Desktop version which provides an easy management utility for quick and dirty analysis of datasets.

Once created the Codemotion Rome 2020 database on the application, it’s time to perform the import task, hence we’ll need to setup the right environment:

  • give the database the permission to read a file from disk (it’s disabled by default)
  • put the file into the import folder
  • enable the APOC plugin (a set of utility functions for the database)
  • write the cypher query to ingest the data

For the first point, it requires a single line to be added to the neo4j.conf file, mind that it is possible to do it in Settings tab while on Neo4J Desktop:

// append it to neo4j.conf to give permission to read from disk
apoc.import.file.enabled=true

Next move to the Plugins tab and install the APOC plugin:

When APOC completed the installation process, click on the “Open Folder” button and then on “Import” folder: copy the JSON file with the data into the folder.

Finally restart the database pressing the STOP and PLAY button on the Desktop application to make the new configuration take effect, and when ready click on the “Open Browser” button.

In the query box we’re going to paste the import query for the data:

// load the file content into a variable name "value"
WITH "file:///codemotion-rome-2020-papers.json" AS url
CALL apoc.load.json(url) YIELD value
 
// now iterate on each topic and create a node for each topic
FOREACH (t IN value.topics |
 MERGE (topic:Topic {id: t.idtopic})
   ON CREATE SET
     topic.name = t.nametopic
)
 
// from the value, now pick one paper per time with UNWIND
WITH value AS v
UNWIND v.papers AS p
 
// create a node for each Paper (talk/submission)
MERGE (paper:Paper {id: p.idcall4paper})
 ON CREATE SET
   paper.title = p.title,
   paper.abstract = p.abstract,
   paper.level = p.level,
   paper.performedAlready = p.performed,
   paper.length = p.length,
   paper.language = p.language
 
// Now create a node for each speaker who submitted
MERGE (speaker:Speaker {id: p.speaker.idspeaker})
 ON CREATE SET
   speaker.name = p.speaker.name,
   speaker.surname = p.speaker.surname,
   speaker.bio = p.speaker.biography
 
// And create a :PRESENTED link between the speaker and its paper
MERGE (paper)<-[:PRESENTED {submitted: p.submission_date}]-(speaker)
 
// Create a company node and link it to the current speaker
MERGE (company:Company {name: p.company})
MERGE (speaker)-[:WORKS_AT]->(company)
 
// pick the "community" field and split it by comma,
// if any, create a node and link it to the current speaker
FOREACH(comm in SPLIT(p.community, ', ') |
 MERGE (community:Community {name: comm})
 MERGE (speaker)-[:BELONGS_TO]->(community)
)
 
// if any co-speaker declared, create a node and link it with the speaker
FOREACH (co IN p.cospeakers |
 MERGE (cospeaker:Speaker {id: co.idspeaker})
   ON CREATE SET
     cospeaker.name = co.name,
     cospeaker.surname = co.surname,
     cospeaker.bio = co.biography
    
 MERGE (paper)<-[:PRESENTED {submitted: p.submission_date}]-(cospeaker)
 // Look at the company of the co-speaker and link it with him
 MERGE (company:Company {name: co.company})
 MERGE (cospeaker)-[:WORKS_AT]->(company)
 // Same for the communities
 FOREACH(comm in SPLIT(co.community, ', ') |
   MERGE (community:Community {name: comm})
   MERGE (speaker)-[:BELONGS_TO]->(community)
 )
)
 
// last, connect the paper with the topic based on its Id
WITH paper, p
MATCH (t:Topic{id: p.idtopic})
MERGE (paper)-[:IS_ABOUT]->(t)

The model created for the data is the following:

While the model may looks pretty basic and simple, it is enough to perform some interesting analysis of the domain.

Codemotion Rome 2020, explore the data: Communities

Codemotion has been always a strong supporter of the IT community, initially via the conference only, then evolved into the #Aperitech brand for the italian local meetups, recently extended in the whole Europe with their own Codemotion meetup platform. So this can be a good opportunity to gain an insight of the communities impact on the Codemotion Rome 2020 conference, starting from the submission analysis.

First it is possible to quantify the number of communities involved in the dataset, somehow related via the speaker bio: how many communities will be  (indirectly) involved with the next edition of the Codemotion conference?

// how many communities are there in the dataset?
MATCH (c:Community) RETURN count(c)

492 communities have been named by the various speakers.

This is quite a basic query and with this number it’s hard to get any value out of that simple number: as an analyst I’m interested to gain value from more interesting questions that can give an insight of the conference speaker audience.

An interesting insight can be the analysis of clusters of communities, starting with the paper association: given a submission and the communities related, is it possible to see any cluster of communities?

// Community -> Paper
MATCH (community)<-[:BELONGS_TO]-()-[:PRESENTED]->(paper:Paper)
WHERE NOT community.name = ""
WITH community, paper, apoc.create.vRelationship(paper, "RELATED", {}, community) AS r1
RETURN community, paper, r1

Because from the model above the “Paper” node and “Community” node are indirectly connected, it is necessary to create a virtual edge using an APOC utility in a way to create a direct relationship between the two, inferred from the indirect one.

The result given is the following:

From a 10.000 foot view, while it is not possible to read the text in each node and link of the graph, it’s already possible to detect some clusters of communities (centered) and filter out some small graph components (those at the border).

In particular there’s a quite sizable cluster in the center with quite few communities involved: what are those communities? Why are they so connected? Is there a shared property?

Zooming in the particular graph component it is possible to read the communities name:

It looks a cluster of DotNet communities in fact (with some exceptions), therefore the first guess of shared property worked quite well: in this case all these communities are sharing the Microsoft framework foundation, while they are geographically distributed across Italy and Europe more in general.

But of these communities, what is the most “popular” one: the one where most of the “speakers” come from?

To answer this question we can count the ‘degree” of each community node – therefore count all the “RELATED” relationship going out of each community node – and show it in a table:

// Community degree sorted by degree
MATCH (community:Community)
WHERE NOT community.name = ""
WITH community, size((community)<-[:BELONGS_TO]-()-[:PRESENTED]->(:Paper)) as degree
ORDER BY degree DESC
RETURN community.name, degree

These are in fact the first top 5 results:

In the first 3 positions we can see DotNet Communities related to 12, 11 and 10 submission respectively. To compare the first Google community, GDG, is the 5th in the ranking with 9 related submission – still quite a good result!

Want to know more about Codemotion Rome 2020?

Wait for the next post about data analysis applied to the Codemotion Rome 2020 submission, where I’m going to explore the “Topics” and how communities relate to them.

Tagged as:

Related articles