Before the COVID-19 outbreak, Codemotion Rome 2020 Call for Papers had been closed with 646 proposals being submitted. After all these months, there are still some important lessons that we can learn from those proposals. The following article represents a way to look back into those submissions.
If you want to know more about how modern technologies and tools can support you for – and during – the organisation of a virtual event, don’t miss this article showcasing the best tools we used to host our online conferences since the COVID-19 outbreak.
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 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.
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=trueNext 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, r1Because 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, degreeThese 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!
