So, thank you Paul, welcome everybody.
So we will today present to you the Cortex platform, which is an open platform for research
in social sciences.
And it's a collective presentation where all the team is here, but we have three of us
will be presenting today out of the team that you see on the picture.
So what is the Cortex?
It's an online platform built on top of an architecture and its main goal is to help
the social scientists with a research question to actually find the benefit of a computational
method to fit a specific question.
So it has been founded in 2009 and it's driven by social science research and is supported
by several French national institutes at the beginning, in particular INRA, and then later
on some funding, some research funding and some European project called RIS, European
project of infrastructure.
We are now at our second version of this online platform called Cortex Manager.
So this is the part that you can actually go online.
It has been designed from the very beginning, as I said, for the social scientists.
So we took the point of departure was that the social scientist doesn't have any IT capabilities,
doesn't have any, on average, doesn't have any resource on the computer, especially 15
years ago.
So one of the main benefits of the platform would have to be empowering him with the power
of computing and of methods.
It's a collaborative platform, so a lot of projects can be shared between scientists.
And there is, as a web interface connected to a workspace online, you don't have to,
of course, have it on your computer, which was, again, quite new at the time.
And it's very important to note that it's very permissive.
So it's a bunch of methods that you can apply on all kinds of data that we will detail later.
And this was one of the main foundation of our platform in the beginning, that all the
methods are runnable on all the viable that you have at your disposal.
So how is it going from ten, ten, ten, twelve years after that?
So we have over 250 peer-reviewed publications that we are counting from now.
And of them, 75 documents in 2022.
So it's growing, and it's growing quite fast the last few years.
So 50,000 analysis, so 50,000 jobs have been done on the platform by scientists last year,
by over 1,000 active users, 400 institutions, and in 50 countries.
So it's pretty worldwide issue-wide.
The team we have now in 2223 is consisted of eight technical persons, so engineers mainly,
two researchers, one trainee, and two close collaborators in companies, or independent.
Very important is located at University Gustave Eiffel in Paris, near, in the greater Paris,
so near Marne-la-Vallée.
So you have Disneyland not far away.
And this infrastructure is composed as a classic web-oriented application and infrastructure.
So obviously we have the web interface that you can go to as a user, regular user, that
encloses a lot of web services, so the main interface, but also an API that you can go
and act upon from outside.
So this allows us to open all our better-than-services to external applications, and specifically
external projects that we are part on.
We are built on an infrastructure of servers that are hosted at Marne-la-Vallée, so in
our university.
So everything is local.
We don't have anything hosted online, which is 300 CPU, 3.5 terabytes of RAM, and 40 terabytes
of storage, which is big and not big at the same time nowadays, but it's enough for our
needs.
We have two main services that we are providing.
First is the storage of big database that we are collecting and curating, like for example
the patents, the European patents.
We have several other databases that we are putting inside some projects, so we can help
specific projects with this data that we have stored in the infrastructure.
And the second part is the processing that we offer, so the method, the scientist method
that I will talk about later, that are run inside of projects on the platform directly
by the researchers.
So the researchers are actually actioning those methods directly from the web interface
with the parameters and their data.
And we of course have this monitoring of the whole infrastructure, so it stays online.
So once you have an infrastructure, it has to do something for scientists, and that's
the goal of the platform.
So how does it do, and what does it do for science?
First what?
So this is the right part of the previous diagram.
So we have a bunch of heterogeneous methods.
So from science to metrics, the biometrics, the study of basically publications, scientific
publications and tracks, natural language processing, so terms of traction, name-intensive
recognition and stuff like that, social network analysis, so the study of all the interactions
inside publications and texts in between actors, keywords, et cetera.
Stochastic block models, then I will end the table somewhere in the room.
We'll talk to you about later.
Knowledge dynamics, so through time, the study of the knowledge through time, and the special
analysis, which is a big part of our infrastructure now, because we have geocoding, geolocating
inside publications, and geo-mapping framework.
Okay, next we'll be, I will give, join you the mic to talk to you about how to cite
cortex, because this is one of the big, I will try to note.
Then as cortex is a research software being used mainly by researchers, then suppose the
to be cited, besides the fact that there is no yet strong culture of citing software properly
inside academic works, it's expected to be done.
Then according to that, in 2022, we documented how cortex must be cited inside academic works,
and here we have just an example, for example, if I am writing a paper, and if I cite cortex,
this is how cortex will be handed at the end of the paper in the reference section, for
example, and with this, we can give, for example, the credit to the developers, like, for example,
Philip, Ale, and many others, who is contributing with this software for a long time, and must
be recognized by this work academically speaking, then this is important, then that's what
we did, and nowadays, we are lucky because a few years ago, we are missing the infrastructure
to how to define, how to document, and how to cite software, and now we have, for example,
the citation.cff, that it's a citation file format, that it's been adopted a lot, and
I think it will be the standard way to do it, and on top of it, we have many tools.
Here is one example, CFF convert tool, where we can convert the CFF file format, for example,
to big tech, to bibliotech, or to APA format, and many other formats, then we can keep the
automated data about the software important for citation in one single file, and from
this file, we can derivate to many others, and it's really an easy way to do it.
And then in Cortex, it's a solved problem, but we still have an issue about how to identify
permanently this object.
I say object as a digital object, okay, it's a software, but it's a digital object from
the point of view of science, and how we can identify it permanently, for example, for papers,
we have a DOI, that it's very well known, and so it's very well for papers, PDF, but
for software, we have a problem to, we can need to cite software in many different levels
of granularity, for example.
We can cite the software, just the software name, or a specific version of the software,
or a specific line of a specific file inside the source code of the software.
Again, this is still an open question, because, for example, we have a proposition from the
community to solve it, but there is no one single kind of permanent ID that covers all
the levels of granularity, for example.
We have the proposition from the Software Heritage Project, that it's the suite, the
Software Heritage ID, that we can use it to cite software in the very specific code fragment
to the snapshot of the full source code, but, for example, we can't use Software ID to cite
software in a high level, like the software version of this, only this project name.
For that, we should use another kind of ID, that's it.
And it's an open question that we should work this year or next year, and that's it.
Now it's the time for you, Juan.
You?
I don't know.
So one question we've been asking ourselves is how to open the platform fully.
What did we do to do that until now, and what to do in the future?
So there is no platform, web platform, without free open source software today, and we are
using a lot already, and I just put some of them on this page.
You can see here, from any layer of the infrastructure, from the virtual machine, the containers,
the scripts, the operating systems, et cetera, et cetera, until the actual methods and interface
that you produce to the user.
We are using free open source software, or at least open source software, because I don't
want to start a debate here, but that's the general idea.
Now this is not Cortex producing that.
The Cortex is wrapping around this open source software, and it's open access for now.
So it's free and open to everybody to use as an interface, but the code is not entirely
free.
We've been trying to do that a little bit more than the last few years, and hopefully
in the next few years, even more.
And Ale will talk to you about how to do that, and what are the challenges to actually produce
a good open source software and methods.
Hello, everybody, I'm Ale.
I work with the guys and go in Cortex.
So this is not really a talk about Cortex, I'm not going to do a demo or something.
Because we thought of this talk as a moment to discuss what's going on with us, what is
going on in the platform, because up to now, like Philippe just explained, everybody can
come and use, but most of the software in Cortex has been developed without, well, with
open source in mind, but not in practice, for practical reasons.
So are we missing one slide?
No, yeah, so everything from the methods, the interfaces, the back ends, everything
has, so even our documentation is on Wordpress or Q&A also.
So everything is based on open source, but up to now, we didn't have real open source
practices.
So how are we managing this transition from a project that is very aligned with open
source community, but that doesn't manage to do open source, to start doing open source?
So there was really a big part was just getting even more open source into the project.
So we're starting to use project management tools that we were using, like some of them,
but not as much, not as systematically.
So this is a real common problem with research software, where researchers, they don't always
have the reflex to go into GitLab or GitHub or whatever and use issues and use dashboards
and project management, sometimes not even a thing in their head.
And that's kind of the background that we were facing, like years and years of research
and developing stuff, using open source software, but using version control because, well, it
was still the infrastructure guys really needed that to work with, but it was really like
the bare minimum.
So how do you start to get people more involved?
So we just, the first step was really pushing everybody to start using the usual tools,
and sometimes first moving some projects and moving the discussion into issues on GitLab
and all that.
And then, okay, so, and then, and also adopting for our discussions more open source software,
like Matrix, so it's like, I don't know if anybody knows Matrix here, maybe today everybody
already knows Matrix, it wasn't really a given last year.
And then, once we had like adopted the general workflow, the projects were still, most of
the projects were still private, but they had the workflow of an open source project,
so it helped get people into a better mindset and the people who would arrive and start working
with us would like more easily recognize the pattern of working with open source.
Then because we had this system that runs the jobs and everything, and usually in the
old scripts, they would just use the structure that was in the system directly, and it was
pretty hard to adapt and evolve them.
So then we developed some kind of intermediate libraries so that it gets easier to, so making
it easier to develop new methods in the platform.
So we had to develop this intermediate, I won't have time to go into show the details,
but just getting the idea that we have to get people into the workflow, develop libraries
and interfaces and intermediate layers that help and automate some of the processes, give
people more freedom to work, actually we also started integrating containers in the job
manager and everything so that we could end with this intermediate layer so that people
could have more freedom to make it easier for them to keep doing their non-standard,
non-advisable, non-best practices stuff, but that works for them because their researchers
are not coders, they're not always coders.
And finally, and even for the people in the team that are more skilled programmers, of
course, they want to have the possibility to do all this stuff.
And finally, one thing is very important is at the management level, because this is
like a kind of already intermediate kind of big-ish thing where we have hundreds of users
everywhere, so we had to discuss this in the strategic planning so that our institutional
partners could get it.
So basically, just get it everywhere as soon as possible and then start, once you can show
some of the benefits, also work at the institutional level.
So these are some of the challenges.
Most part of the team didn't have the know-how, part of the researchers we work with.
People have limited resources, they have priorities, and I'm just reading out of there, but that's
it.
It's not very surprising.
There's this learning curve of open source and everything.
And there's always doubts about where is this going to lead us.
There's licensing doubts, so there's part of, like, next thing I'm going to quickly show
is that we're starting to open up stuff, and there's lots of stuff that hasn't been open
yet simply because somewhere, we know that somewhere in some file, somebody used an extract
from a software library that is not clearly documented, where it has been used, and we
need to find it and check if the license is compatible.
So we're always like, okay, where are we going?
But getting things to as close as possible on every dimension is what's keeping us moving.
It's keeping the feeling that something is moving, even if we're not seeing everything.
But then we, well, through this effort, eventually, we managed to open source already a good part
of specifically the science part, so the infrastructure, the dashboard, the interfaces, the front-end
of the web application, and the job-managing part, or this part is not necessarily, it's
taking longer because it's also another part of the infrastructure.
But the main, most important, short-term part is to let the scientific part of it be available.
So here's just some examples, I'm not going to, but yeah, so there's two parsers, an
importer for a big database of scientific publications, a kind of generic parser that
we use for, we're in a sociology of science lab, so even though the tools are more like
general humanities and social sciences, we have a lot of interesting things that come
from PubMed, data that comes from PubMed, and similar databases, so this is like also
a parser for that, and here's one example of a project that's in progress because even
though we reworked the project, parts of it still use some libraries that we're not sure,
so we have to check, take the time to check if we need to change anything or replace.
Just quickly show what some one of these things look like, well, this is just the repository
for one of the projects, you have the source code, some documentation, it makes pretty
graphs, and you have to use it like this, like this.
So just getting things into what we all know about, what you know as an open source format,
how do I go back to the presentation, F, no, no, there you go.
What else there's to say, that's it, so thank you, I think, I mean, if you, if you, if you
have any of you work in a similar institution where open source is not an evidence but it's
something that you have to struggle with, we're very happy to exchange after, during
or after the conference, did you skip the, no, no, you have no more time, thank you.
Thank you.
Any questions?
Yeah, thank you a lot, I like your time because there is a lot of nice to choose, and you just
wanted to share with us, and I'm very happy to hear that you are bringing up the gauging.
Yeah, so the question was, what was preventing us to opening it from the beginning, and to
make open source software from the beginning.
So as Ale was saying, the first thing I think is just the lack of know-how, especially 15
years ago when we started, the second thing I would say is that we, we basically didn't
have a precise idea of what we were building, we just went basically script by script project
by project, and this, this is how we built slowly the, the platform, then it became a
platform, a proper platform, I mean, with the, with the resources and everything, and
then, then it was already used, and, and we trained people on those methods already,
so the problem of opening, of doing open source software is you have to think about it from
the beginning, or at least refactor enough the, the code, so it's big, it's, it has no
problem of, of license, and stuff like that, so this is, this is just a, you know, an ongoing
streak.
Yeah, speak loud, sorry, I can't, I can't hear you.
Yeah, it's about, yeah, some, some people upload software to Zenodo or upload a documentation
or, that's, that creates one kind of identifier, which you could also make a, some people just
make a publication related to the software, so people can cite a DOI, Zenodo is going
to give a DOI, so it's the same, pretty much the same thing.
The problem is that, I think like Jenner was explaining is that sometimes you want to cite
a specific version of the software or a specific file in a specific version, or you want to
cite the software without mentioning a specific version, and, and you don't want to upload
one version to Zenodo for every possible thing.
Yeah, yeah, yeah, I, I don't know exactly deep what Zenodo offers, but I know that Zenodo
offers a way to manage many different kind of digital objects, data, images, software,
etc., and not only Zenodo.
In our case, what is missing is to study all the options to see which fits better in, in,
in our case, you know, is more to, to understand, because in, in fact, inside the, the, the software
engineering community discussing this topic is still an open question, exactly how to
do it.
And when we, we search about this topic, it's quite difficult to find tutorials or someone
teaching you how to, what kind of permanent indentifier you should use.
For example, software heritage ID, for example, here is an example of the type of persistent
indentifier that name it as intrinsic persistent indentifier.
What means it doesn't, doesn't depend on, on, on a service registry where you need to
ask a new ID to, to use it.
It's like a hash, a hash ID of a commit is this kind of a intrinsic persistent indentifier
that we can generate by the source code itself.
Another option is to use maybe Zenodo or maybe any other thing to generate a DOI.
Then for that, we are, we are going to ask to the registry, the DOI server to generate
a DOI for us.
And we have many options, we don't know yet deep and maybe Zenodo could be really interesting.
I would be happy to, to learn with you, your experience because it's a lot of things to,
to learn.
Sorry.
Okay, thanks for coming back to stop here.