Introduction to the business models and governance of free software – G. Le Bouder, R.Semeteys

How is free software managed and financed? What are the existing models and how they have evolved over time? These questions are simple and yet the answers are not obvious.

In this episode, we give a first introduction with Raphaël Semeteys, architect and DevRel at Wordline and Gonéri Le Bouder, Senior Software Engineer at Red Hat.

Episode with Raphaël Semeteys and Gonéri Le Bouder

Walid : welcome to this new episode of Projets Libres. Today, we’re going to do an episode that I’ve wanted to do since the beginning, on which I broke my head a bit for a very long time. I asked for help from two people who know this subject very well with whom I have worked, the three of us worked together a very long time ago (at the time, we were at the Atos Open Source Center). It’s a subject that is also very fresh in our heads because yesterday and the day before, there was the Open Source Experience show in Paris and we talked to a lot of people about these issues of business models. It gave us a lot of new ideas and things to discuss.

Tonight, to talk about the business models of free software – we’re going to say an introduction, we’ll talk about other models in other interviews with other projects or publishers – I have two people with me, the first is Gonéri Le Bouder, with whom I work and I’ve been in contact for a very long time, who is a Senior Developer at Red Hat. I’ll let him introduce himself afterwards. He knows his licensing topics well because when I met him when we started working together, he was in the process of becoming a Debian developer. And the subject of licenses was a big one.

The second person is Raphaël Semeteys, with whom I also worked at Atos and who at the time had developed a method for qualifying and selecting free software called QSOS : we’ll talk about it quite quickly. Raphaël is an architect and DevRel at Worldline. Hello to both of you. It’s really nice to have you and I think it’s the first time the three of us have spoken again in a number of years.

Raphaël : That’s right. Hi everyone.

Gonéri : Hello everyone.

Presentation by Gonéri Le Bouder and Raphaël Semeteys

Walid : The first question I’m going to ask you both is to start by introducing yourself and explaining to me a little bit how you got into free software and quickly, what is your background? Goneri?

Gonéri : I’ve been doing free software for about 20 years. I started before KDE 1. I remember that I had a French version of a Slackware with a Kernel 2.6.36 or something like that. That was a long time ago. I was in high school, I had contacted the translation teams at KDE at the time and that’s when I started interacting with people like that. I wasn’t a developer at all, it allowed me to meet people. Then I also discovered the world of LUGs, Linux User Groups that there were in my region, in Brittany. After that, I didn’t really stop.

Walid : And now, what do you do?

Gonéri : I’ve been working at Red Hat for ten years. At the beginning, I gravitated towards OpenStack for about six years. I’ve been on the Ansible team for about four years. I’ve done a few things on the Ansible team. But right now, I’m working on something called Lightspeed, which aims to give Ansible artificial intelligence to help developers produce their playbooks.

Walid : Thank you, Gonéri. I’m going to be able to put the hashtag #IA on this episode. Thank you.

Gonéri : I’m sorry.

Walid : And you, Raphael?

Raphaël : I’m Raphaël, Raphaël Semeteys. I work at Worldline. I’ve been an architect and DevRel for a year. I’m used to doing information systems design and that kind of thing. Before, I was at Atos. The three of us, Gonéri, you and I, have been colleagues in the Atos Open Source Center, the open source competence center. For nine years, I first participated in the creation of the center and then I took care of a lot of monitoring and consulting activities around the adoption of open source, the risks we incur, etc. It is in this context that I created the QSOS method.

I discovered open source when I went to engineering school, to a telecoms school. I discovered the Internet and open source at the same time, it was in 1994. Right away, I was very, very interested in this idea of using the Internet to interconnect everyone and to start exchanging code and exchanging ideas in a free way. It’s true that I realized that the construction of the Internet was also very much based on free and open source software, since we had to create the infrastructure and it was based on free components.

I’m building a time server, I’m building a DNS server, I’m building an Apache server. Then afterwards, when the Web appeared, it became dynamic, PHP/MySQL sites, etc. So we realize that the two are very linked. And that’s something that interested me a lot from the start. Today, I’m no longer in a job that only does open source, but I advise on the selection of components to build offers, either platforms where we offer services at Worldline, or for projects that require customers. And there is also the problem of integrating these components into more complex architectures and above all of operating them, making the run of them and all this over time. It’s true that these are things that are important to look at. Worldline, indeed, is a company today, a global operator, let’s say, in the field of payment. But in fact, that’s not all we do. We also do everything that will be systems with a lot of transactions, so high volumes and very regulated.

Overview of the QSOS Method

Walid : Raphaël and I just spent two days at the Open Source Experience trade show. It was the great excitement. So now, we should talk a little bit, precisely, about QSOS, since that’s kind of the subject. Well, that was part of the matter. So, I would like us to just address very quickly what QSOS was.

Raphaël : QSOS stands for Qualification and Selection of Open Source Software. It’s a method, an approach that I created in the years 2005-2006, when I was in the Atos Open Source Center. First for internal needs: when we needed to select components for our own projects, that kind of thing. It started with something that looked a little bit like the comparison kit that you can have with the FNAC. We have a certain number of criteria and then we have stars and this allows us to compare. From there, we realized that it was also useful for customers. And then, finally, I integrated it into the consulting and monitoring process that I did on behalf of clients. It should be noted that at the beginning, we were on comparison grids on functionalities, therefore functional coverage or technical aspects. Very quickly, I added a whole set of criteria that is always the same, whatever the field, which I called “maturity” and which makes it possible to evaluate the maturity and sustainability of a solution and the project that builds it. Because it’s very important for a user, a company or an administration, to evaluate the risks they take in adopting open source software in relation to the fact that the software is sustainable, that it will still be there in a few years or that there are no license changes or changes in business model, as we will surely talk about later.

To do this, I have established a list of fairly precise criteria that we can look at because we are in the field of free software and it is accessible. Or when it’s not, precisely, it’s information too. For example, who controls the project? What is the license of the project? Who owns the rights to the code? What are the business models? Core committers, are they in one company or are they paid by several companies, or not paid at all? What is the level of industrialization of the project itself? How does it handle security? Is there governance?

There is a whole set of criteria. We don’t have a crystal ball, we can’t predict everything that will happen in the open source world, but it still allows us to anticipate certain risks. Indeed, and by the way, Gonéri, that’s what you brought to the table when I worked with you on this. Very quickly, you told me “But we should have a standard format to store the information of an evaluation.” And from this format, which was an XML format (at the time, it was still in fashion), we built a set of tools that make it possible both to build grids, since there is functional coverage that will change depending on the field, and once we have a grid, to carry out evaluations in the most objective way possible. Once we have evaluations that have been carried out by other people, it is to use them to compare them, with a third type of tool, to make a choice in a given field, to compare several types of software.

It can be databases, MySQL, Postgres, MariaDB, etc.: we make a choice based on specific criteria and we model the context we have. We choose by putting weights on these criteria. If a criterion that is not important, we put a weight of zero and then a criterion that is more important, we will put a higher weight. From there, we can generate graphs, quadrants where we see maturity in relation to functional coverage, etc. We used that a lot in monitoring work. In fact, just a few days ago, when we were at the Show, I met a client in the public sector who told me that they always use the QSOS method when they select software and even that they ask their service providers to use it to do monitoring studies. I’m quite happy and it proves that it’s useful.

Walid : It’s a fascinating subject, the evaluation and qualification of software. Working with you on QSOS taught me a lot.

The Community Model

Now, we’re going to get to the hard part of the subject. We’re going to start talking about business models. As I said in the intro, there are a plethora of business models. We have almost come to the conclusion that there are as many economic models as there are projects, since it is very much linked to the people who are doing the project, to the sector, to a very wide range of factors. The first model that we can talk about – and I’ve already talked about it on the podcast, you can listen to episode 1 with Dolibarr and the first episode on GLPI – is the community model. Here, the community model is a model that is very old and it is a model that has had its hour of glory, a little less so now.

Raphaël : Yes, indeed, even historically, the first open source businesses, or the first organizational models around open source projects that were made, were purely community projects. As I said, it is concomitant with the creation of the Internet. What did we do? We started building the tools we needed to build the infrastructure of the Internet, and then to develop software. It’s all the low-level frameworks, the code managers, all the IDEs, all of those things. It’s true that at the beginning, this type of project is really intended to be community-based. This is really the first type of model: we will have one or more developers who come together, who start working together. There is no governance or hyper-explicit structure to organize the work. Afterwards, when the model grows, it can turn into a governance that is not always so explicit, but where there is a role called “benevolent dictator” that can emerge. That’s the example we have with the Linux kernel, with Linus Torvald, which still has a bit of that role today. You have to remember that at the beginning, Linus, he just published on the Internet the fact that at the time, he was a young student, that he was working on a kernel.

Years later, the project has grown enormously. It has become structured, but there is still this role of benevolent dictator. At some point, someone is going to make decisions on the project. And when we start to have more and more contributors and in particular people who will have the role of committer, that is to say that they can modify the mainstream source code of the project, then it’s a role that is important. So there can be a principle of meritocracy that is being put in place. As the contributions are recognized and the rest of the core team, let’s say, has confidence in these people, they can have this right, this right to commit to the code. After that, the way it’s organized, it can be more or less structured. We saw it with the PostgreSQL project, for example, where they have a fairly loose structure, but it’s intentional, it’s done on purpose. I think it will be interesting to do an episode in the interviews, to see that they explain how they work. The risk in all this is that at the beginning, meritocracy works well, but afterwards, on fairly old projects, what about the new ones?

It’s a bit complicated, it can turn into an oligarchy a little bit. That’s the risk.

Walid : Gonéri, do you want to add any additional things?

Gonéri : Here, we talk more about how to organize a project, but not necessarily about financing. I think that in the beginning, in the case of Linux, it was mostly someone who was a volunteer and it went on for a long time. And I think that for a long time, it was the source of remuneration. It was volunteering or it was in the context of work to meet a local need. And this need to sustain projects was not really an issue, I think, at the time.

Walid : In France, on these models, these somewhat community models, we had a lot of projects that started by creating associations, for example. With people who were volunteers. Some have stayed with associations, others, indeed, may have transformed. I talk about it a little bit in the episode on GLPI, for example, where there was an association and this association itself, it had members and there were people who gravitated around it. And the management of the project, the maintainers, were volunteers. And they themselves, for example, had partnership agreements with private companies that also did consulting. It’s not always a model that is ultimately very obvious when you try to do business with associations. It’s not always very easy because we have people who are… finally it is an association, at least in France, potentially non-profit. And on the other hand, we have people who are also there to make money. So managing to find people and find a way to bridge the gap between the two is not always very easy.

Maybe this is one of the things that makes this model lose a little of its beauty? I don’t know. What do you think of it, Gonéri, for example?

Gonéri : I think he’s still very present. In fact, it’s a question of scale too. Let’s say that 30 years ago, a single person could develop software that was going to be used massively. Today, to have this impact, you still have to be a small team. There are additional costs that are coming. I don’t think it’s that simple, unless you’re developing a JavaScript library or things like that that that are very precise. We always come to the problem of the perimeter. I don’t know what you think of it, Raphael.

Raphaël : In terms of business model, it’s mainly that the developers are not paid by the project, since the project has no economic or legal existence. There is no notion of remuneration for their work. Or they are not paid at all, in which case there is an intense risk to the sustainability of the project. We saw it with projects like ColorJS or MakerJS where in the end, the lead dev got tired of not making money: he scuttled his project a bit, which hindered a lot of other open source projects that were using it.

It can also be models like we see today on the Linux kernel or even on Postgres: it’s coopetition, that is to say that there are companies that pay developers, it can even be full-time, to work on the Linux kernel or on Postgres, because they have an interest in it. This is part of their business model, since they will resell services or Enterprise versions such as EnterpriseDB. Or all manufacturers who want to make sure that, for example, Linux runs well on their machines. So here, we are a bit in that model.

After that, how can you also finance when you are in a pure community sector? It can be donations, especially with crowd sourcing, with sites like Patreon or that kind of thing. There are projects that live on donations, which can also be done by companies, either in the form of money or also equipment. It can be used to run infrastructure, run the CI/CD, tests, host the website, etc. And then, there are also some who can do merchandising, but in this case, you have to have a brand a little. All you need is a legal entity to carry the brand and sell T-shirts, mugs.

Walid : Can we give examples so that listeners can imagine a little bit of well-known, emblematic projects that use this somewhat community-based model like this?

Raphaël : Yes, indeed, we have examples of projects, they are often, as we said, the first ones that appeared and we find them a little in the things that will make up the infrastructure of the Internet today, for example in messaging. Whether it’s Sendmail or Postfix, these are pure community projects. It is on this basis that the entire Internet email infrastructure has been built today, for example. We also talk about Linux and everything that made it possible to develop the tooling.

Walid : Gonéri, did we also rate Debian, for example?

Gonéri : Debian, I think it’s a bit of a special example. This is specific to all Linux distributions. The strength of these organizations is that the work is very structured and it’s quite easy to become a little worker ant in the system and start building packages, things like that. There is still a foundation, there is a structure behind it, which has money, which has a little bit of means, legal level and all that. But it’s true that I would say that 90% of the work is done by these package maintainers who are really hardcore volunteers.

Walid : I was going to say people like VLC ?

Gonéri : Yes, there’s Vim too. Vim is really a pure community project. There has never been a structure behind it.

Walid : There’s also a way to get financial donations, it can be done through a number of different means: donations, merchandising. Yesterday and the day before yesterday there was talk of sponsorship. I must admit that I wasn’t very aware of that. Can you say a few words about it, the means for these projects to raise money Raphaël?

Raphaël : One of the sources of funding can be donations. Donations can be made by individuals with projects like Patreon or that sort of thing, or it can even be public sector grants. For example, with projects that come from Europe such as the NLnet foundation, a very interesting project to boost the entire ecosystem in Europe (Editor’s note: see the episode with Lwenn Bussière from NLNet). It does not finance on completely crazy amounts. It finances projects that really need it to boost them a little: it’s great. To do this, the project must be structured to have at least one legal and moral entity to receive these donations and to be able to use and organize them. It can also be about managing the brand with a logo, a brand. With this, they may also be able to generate money to finance the project by selling derivative products. You can see it when you go to the Open Source Experience Show, even in the association village, there are logos, there are brands, you can buy mugs, sweatshirts, lots of things like that. It’s true that it’s interesting.

Gonéri : in sponsorship, there was Transmeta. Transmeta is a company that wanted to make a processor in the 2000s. They paid Linus Torvald for that.

The principle was that he had to port Linux to this new processor. But the reality is that it was also a way for Transmeta to make itself known and to show that they contributed, that technically, they were good actors. Here, we were really in sponsorship. It was a way to popularize the Transmeta brand thanks to the work of Linus Torsvald.

Walid : To finish with this model, what about intellectual property?

Raphaël : Indeed, on this type of community project, as there is no business model as such, there is no need to make money from the code. There is no notion of intellectual property on the code over which an entity would need to have control. In fact, you can have a little bit of all types of licenses. We find a little bit of everything.

This was especially true for the first projects: that’s where the first types of licenses were created. Indeed, the project is not an entity that needs to have the rights to the code. And what will secure the project is that each contributor owns the rights to his or her own contribution. And that’s what makes the project so stable and strong compared to a takeover by another entity that could take control of the codebase, like in other models that we’ll see a little bit later. I’ll take examples of open source projects that started very early, such as PostgreSQL or the ones I mentioned earlier. Today, changing the license of these softs is something that would be very complicated because you would have to have the agreement of a little bit of everyone.
So it protects him.

Gonéri : PostgresSQL, it’s a BSD license, I think. You could change the license. By the way, there are proprietary versions of PosgreSQL.

Walid : Do they have to give their consent?

Gonéri : no, not with a BSD.

The foundations

Walid : Let’s move on to the next model. This is the foundation model, which is also a very common model. Raphaël, do you want to introduce this model a bit, please?

Raphaël : Yes, the foundations. It is the second model that has appeared and it is a possible evolution. When a project starts to have a lot of users and contributors, there may be the possibility of creating a foundation around the project. As we said earlier, the idea is to have a moral and legal entity that will be able to represent the project before the law, for example, and to manage the budget and distribute the money. The foundation will also organize and protect… Depending on the size and maturity of the foundation, there are roles that will emerge, which are quite clear, quite precise, with this idea of transparency around meritocracy and the fact of holding this role or not. What does that mean? Some of the roles that are structuring in relation to the operation and governance of the foundation can be paid outright. There is this notion of budget which is important. In general, as I say, it’s mostly on projects that have had a lot of users and contributors and that tend to create other side or related projects and therefore bring out this notion of ecosystem.

We see this with examples such as the Apache Foundation. Initially, it was a web server. Today, the Apache Foundation contains a lot of projects. The same goes for the Eclipse Foundation: it started with an IDE. Today, Eclipse does much more than an IDE, even Java.

Foundations of this type, at the beginning, tended to push open protocols and standards because they are in the process of promoting the emergence of ecosystems. It is through these protocols and standards that we will be able to integrate and build and articulate the different things like legos. Building things that are more and more complex, more and more fun.

The Document Foundation is a good example. When LibreOffice was forked from OpenOffice, one of the first reflexes that people who did it had was to create a foundation called The Document Foundation, with a clear objective which was to also promote open formats of office automation. We can see how a foundation can be larger than just a single project. In general, these foundations will tend to want to accept new projects, to promote innovation.

To do this, they will have notions of incubators in which there are projects that can claim to join the foundation and therefore to benefit a little from everything it offers in terms of organization, legal protection, etc. But this requires a process where the maturity of the project will be evaluated. They will check these notions of intellectual property, possibly ask to change the license, for a license that is more in line with the foundation’s strategy. Moreover, there are methods in some foundations that may not be as advanced as QSOS, because they need to verify these aspects.

Gonéri : There is also OpenStack. I’m thinking of the Linux Foundation where OpenTofu, the fork of Terraform , entered not too long ago. It’s a way to show that they were “serious”, to show that they really wanted to structure their fork.

Walid : I don’t know if you mentioned it, Raphaël, but there’s also the ownership of the trademarks and ownership of the code.

Raphaël : Unlike the first community models, the foundation needs to have the intellectual property on the code to be able to protect it, to protect the project at the legal and legal levels. So, this is where the notion of CLA, which stands for Contributor License Agreement, appears. There are variations: individual or enterprise, but the idea is the same behind it. When a contribution is made and will enter the official codebase of the mainstream project, there is a sharing or outright transfer of the intellectual property rights on the code, so that it is the foundation, a legal entity, that owns the code. And that’s what will allow him to protect things.

In terms of licenses, for example the ones I mentioned, Eclipse, Apache, and then after all the Mozilla universe, for example, created their own licenses because it actually corresponded to their vision of what open source was and how they wanted to operate.

It’s true that in general, foundations have preferred license variants. And all the projects that are under the cover of this foundation will share this license. It’s always the same idea to be able to recompose the projects with each other and therefore not have any compatibility problems between licenses since they are in a universe, in the end, that is homogeneous. Afterwards, indeed, the CLAs turned out to be a bit heavy because there are a lot of things to check before saying “Is everything OK in terms of the code to integrate it?” And so, some foundations that have adapted this concept a little bit with the notion of Developer Certificate of Origin, so it’s DCO. Here, the idea is to trust the developer by asking him to check him out on his side and to guarantee that everything was OK in relation to the contribution he was about to make. That he had the right, that he respected intellectual property, that he was not infringing patents or anything like that. So, it made it a little easier to contribute because otherwise, it could put off some contributors who said “It’s very heavy, it becomes bureaucratic to contribute”. It has lightened up a little with that.

Walid : On these CLA and DCO stories, we also talk about them in the episode with Benjamin Jean. We’ll certainly talk about it again in other episodes because I’ve met people who are very, very knowledgeable about this subject and because it’s quite fascinating, this subject.

Finally, what’s interesting, having discussed it with the people at the Eclipse Foundation, is that there’s a whole learning side for people who come and say, “I have a project, I don’t know how to structure it.” There is a whole education section on “How to do a free project well? How can we support people? How to contribute well? I found it quite interesting because indeed, when you’re a big company you don’t necessarily know how to make free software. They are also there to support you. That’s what’s quite interesting. There are different types of foundations. There are foundations that are rather historical. We talked about Apache, we talked about the Eclipse foundation. There are other new foundations as well. I won’t go any further on the subject because I don’t know him, but we’ll talk about it again, the same, I think, in other episodes.

Raphaël : Foundations, since they organize and try to promote ecosystems, tend to create standards, to create protocols to federate around the different projects they create, The Document Foundation around the LibreOffice project to defend open standards in everything office. And it can be found in many other fields and ecosystems, for example XMPP, even if today I don’t know if it’s still in fashion, but it’s really the idea. We will also find it in the Fediverse, with the creation of protocols.

In the business models of foundations, how do they ultimately get money back? It’s a bit like the first types of projects: they can receive donations. It also works quite well through donations, sponsorship. It can be the sponsors of companies who say “I’m participating in the foundation, Linux, Eclipse, etc.” by donating money. It can even be organized according to Silver, Gold, Platinum levels. Because it also creates advertising, in the end, people who sponsor, who participate in that. That’s when the foundations, obviously, are clearly visible.

Raphaël : It can be public subsidies as well. And then other ways that foundations have to generate money, it can be by creating merchandising, with logos, T-shirts, everything there can be as derivative products. There is also, but I don’t know if it brings them money, the organization of events like ApacheCon or EclipseCon. Today, there are many things that are done like this. It helps to animate and federate the community around the foundation. And that’s really what can also bring them money. I don’t think it’s their first source of income, but it’s worth noting nonetheless.

Walid : There is also a subject with the location of the foundation. We’ll talk about it in the next episodes, I think in particular with the founders of Tryton who forked TinyERP at the time, it wasn’t called Odoo yet. They have set up a foundation under Belgian law and which explain why and what a foundation is in Belgium? What are the specificities, etc. This is another subject that could also be dealt with and that deserves a lot of time to see why there is a foundation in one country, what is different from another, etc.

Service and Support + SaaS Models

Walid : The next model is another model that has existed for a very long time and that we ourselves have practiced quite a bit. This is the model that concerns services and support. Basically, there is a project and there are companies that sell services. It can be, for example, generic or specific development, software support. What we pay for is all these services. Gonéri, do you want to say a few words about it?

Gonéri : That was Red Hat’s business model. I think it’s evolved though, but in the beginning, the idea was that companies wanted to try Linux or migrate from their Unix system to Linux. They needed a partner to take the risks. And that’s where Red Hat came in. Customers were paying Red Hat for that guarantee. In exchange, Red Hat provided technical support. It still exists, but it’s true that now, Red Hat has become a company with different types of revenues. This strategy is only one of the sources of revenue.

Walid : Raphael?

Raphaël : From the moment that the projects, the communities, need to find a financial model and continue to pay the developers, in any case, what they make a living from it and therefore also to ensure the sustainability of the project in the long term. One model has been sales, and it still is: the sale of services and media on software that is created by the community. Indeed, with the creation of commercial companies that will offer and sell these services. So, it’s not a foundation, but it’s another way to make money and to sustain, in particular, developers. That’s something we’re going to look at in QSOS.

Precisely, is there a business model? Who pays developers? Somewhere. And then, it will depend on the services that are provided or offered by the company, because there is a whole range of services, starting with the support service, so fixing bugs in the code with potential commitments on the correction time. It will depend on the type of contract: of course, to do that, it’s better to have core developers and committers in your team, because otherwise, it’s going to be difficult to make commitments.

That’s a control that will be rather strong on the project, with commitments on the quality of the code and then also a little on the roadmap, on decisions to develop new features for clients, etc. The services can also be simply integration, customization, things that will not touch the code, at the heart of the software or that will be at the edge to integrate it into other environments. It can also be training or expertise and it can even go as far as certification or, for example with Linux Professional Institute or even at Red Hat, there are these notions of certification. These are things that pay off. This is obviously when the software itself has acquired value and there is a need to demonstrate that we have the expertise in the use and implementation of this software and its ecosystem. It’s also another model that worked quite well and still exists.

Gonéri : WordPress is also a good example. There are a multitude of small businesses that provide service on WordPress, which do not necessarily contribute directly.

Walid : You can listen to one of the previous episodes on WordPress. We talk about it with Jean-Baptiste Audras, who is a core committer of WordPress and who explains this a little.

Raphaël : Another service that can be offered is SaaS with the appearance of the Cloud: it’s about selling the service, not the software itself. This means that the software is still under an open source license, it can be distributed, used by people who want to install it themselves. But the company will also provide the hosted service, which it will host itself and to which it will commit in terms of SLAs and service contracts. This can be combined with other services, support, training, certification. We see, for example, this is the Red Hat model, it can even be sold as a subscription. A subscription is something that you pay for regularly and that covers a little bit of all that. This has worked quite well with vendors, companies or administrations who used to pay for regular annual licenses from proprietary software providers: there, they find their little ones. They were more comfortable, in any case, to approach the company and the way of working. On the other hand, since there is a commercial company, there is also a need to have access to the code, but there is not necessarily a complete need for the CLA or the DCO. It will depend a little on each project, on each model. It’s true that if we do training or expertise, we may not even intervene on the code and we don’t have an IP (intellectual property).

Walid : It’s not always easy with this model either, the service, because it fluctuates quite a bit. When you have developers and you don’t have a contract, it’s quite hard. Which also explains why some projects start from this model, because you’re looking for recurring revenue to be able to pay your developers. And the service is something that is rather random and therefore it is not obvious. Gonéri, did you want to say something?

Gonéri : No, I was thinking about SaaS, subscriptions. And indeed, I think that’s the answer to what you’re saying. It allows us to smooth out the sources of income a little, to have visibility on what is going to happen. And also to have user groups, to identify the requests that come from customers for improvements, things like that. Which you don’t necessarily have when you just do occasional support.

Walid : The question I’m asking myself, but maybe you have the answer: I have the impression that on new projects that are being set up or that are a few years old, the service is not a model that is used very much. But maybe I have a biased view of the thing. I don’t know, Raphael, what do you think?

Raphaël : Indeed, which will somehow guarantee that this model is good over time. The sustainability of the company and the projects is good because it is predictive. The problem with support is that we can’t predict the income it will generate, whereas when you sell services like this, especially in SaaS mode, it’s recurring, it’s predictable. It’s true that it allows you to secure and really pay developers and to have business plans and to convince investors about the financial health of the company. This model of support and service has had the wind in its sails. Today, this is not necessarily the dominant model. We will see that there are other models that are now more easily used, but there are people, projects that remain faithful to this vision: to have something purely community and to offer services. We met some of them at the show at Open Source Experience, it was very interesting. They are faithful to their values, they want to make money, they want to perpetuate their projects, but not at the price of these values.

Raphaël : It’s true that it’s interesting to see that there are companies that live and survive with this vision.

Walid : It’s true that there are people who are fundamentally hooked, in a good way, on this model, who know that they could, for example, make more money by switching to an editor mode and switching to an open core model, we’ll talk about that later, but who stay on that model because this model guarantees that 100% of the code is free. I know several examples of companies that say “No, no, but we, 100% of the code, it’s free, we do service, we know that we could earn more money otherwise, but we don’t want to, we want to stay on this model.” Goneri?

Gonéri : When you have a company that is based on support, on training, things like that, switching to another model, it’s not easy. Because the customers we have are people who are also there because they appreciate this approach. I think you’ve experienced it with GLPI: when you start telling all customers that you’re going to change, that you’re going to switch to a subscription system, that you find yourself pedaling a little for several years, that’s also something that slows down, I think, the transition to another model.

Walid : Absolutely.

Raphaël : After that, indeed, on this model of support and service, the challenge is to find a balance: to be able to survive over time at the economic level. There are quite a few projects and companies that have been looking for themselves in terms of business model. And sometimes, changing the business model means changing the license, when they have the intellectual property on the code. But the problem is that as soon as you touch the license, you touch the crux of the matter a little and you have to be very careful about the reactions of users who may not understand the change of license, because they are used to being able to use the software in a free way, in the sense of free software. And it can scare them. And then, we can also have reactions from contributors who say to themselves “But what? Change of license? Isn’t there another economic model that is emerging? or “In fact, in the end, people benefit from my work?” That kind of thing. So, it’s true that it’s always an important moment in the life of a project when there are these changes.
In general, license changes are associated with a change in business model, especially to move towards the open core type.

Walid : When your software has always been free and at some point, you start talking about money and talking about bad words like subscription, license, etc, indeed, for having lived it (we talk about it a lot in episode 2 on GLPI) it’s hard. It takes years and it’s not even necessarily the people who were there at the beginning who stay afterwards. Because the model has changed. Maybe that’s why projects that start don’t start with this model.

The Open Core

Walid : ok, next model. Very fashionable model, a big piece. This is the model that is called the open core model, also the publisher models. There are different flavors of open core model. It is a model that was invented in 2008. I thought it was more recent than that, but actually not. According to Wikipedia’s definition, “this consists mainly of offering a basic or limited version in terms of functionality of open source software, while offering a commercial version or add-ons in the form of proprietary software”. In the field I’m in, which is no-code, it’s the dominant model for open source products.
I’ll let you introduce. Raphaël, what can you say about this model?

Raphaël: There is always a commercial company that will be around the project, with other ways of finding financing. Usually, to generate money, it’s selling features or things that aren’t necessarily always open source. That’s why we talk about Open Core: with a core that can be open, which is open source and with advanced features around it or plugins, add-ons that will be paid. That’s what the company will pay itself on and be able to pay the developers and pay all the fees and try to make a profit. Often, these features are features that will be aimed at companies, since we are entering the world of business and business. These are not necessarily features that will be useful to isolated users or small teams. It’s going to be things like integration with the rest of an information system, managing users with specific rights, because we have a lot of them and we need to have types of users, roles, that kind of thing, or things that will be related to industrialization, observability, etc.

It’s also going to be the ability to commit to long-term releases with Long Term Support versions, that kind of thing. Afterwards, in the open core, there are as many models, as we have said in general, but in the open core, it is even more true. There are as many models as there are companies that practice it. We could talk about 50 shades of open source or open core.

This goes from the fauxpensource which is the release of the code to be visible and to try to recover users fairly quickly. But in fact, we are not trying to develop a community at all. Of course, look at the IP on the code, anyway, we’re not going to accept contributions, we’re not looking for them and we may try to get bought out by another company or to gain external investment. After that, it can go as far as companies that will try to articulate a community part and a business part in the cleanest way possible. And in fact, it is the way in which this articulation is made, more or less well, that will ultimately guarantee the success of this kind of undertaking.

When the company manages to benefit from a community that is dynamic, that is motivated, that increases the user base, that increases visibility and on the other hand, business versions that are clear with features that are really specific to certain types of users, they just have to transform some of their community users into commercial users and the company can have an economic balance sheet that is viable.

Walid : In open core, there are quite a few variations. There’s a subject that’s super interesting, that I try to address in podcasts, it’s how do you find the right balance between a free version that has enough features for people to use it on a daily basis, but on the other hand, some advanced features that make people want to take out a subscription. And there, there are lots of different models. There are some who will say “There are recurring things, things like in the proprietary version, I put for example everything related to authentication, SSO, that kind of thing.” There are some who will say “I’m putting all the features that are company, that is to say that all the little things for associations etc., it goes in the community version.” There are some who will say, as for example was the case for Passbolt, whom I interviewed or also on GLPI, “We have features, if we put them in the open source version, we know that it will generate a lot of support and we know that we don’t have the bandwidth to guarantee these supports, because these are features that we have to come back to regularly, etc. And so, we need people to take subscriptions to be sure that it is treated correctly.”
So, there’s really a fairly large panel and each project manages precisely what it puts in one version or what it puts in another in a different way. There are still other projects that will say “I, for example, put certain features in the non-free version and when I think they are profitable, I switch them back, I back them in the free version.” There are a lot of different things and here, it’s really a function of your market, maybe your competitors, the founders of the company, marketing, commerce. On the other hand, there are still a number of things in there, which is that very often, when you want to contribute as an individual or an external company, you sign an agreement with the CLA in general or something like that. And we have also seen companies that can potentially change their business model.

Gonéri : There is an intermediate model where it is the product-project model, which is used by Red Hat. Almost every time we have a community project with the flaws and qualities that it brings, with a short roadmap, little visibility in the long term, versions that follow one another. And on the other hand, we’re going to have a product where the roadmap is going to be more controlled, there are going to be commitments where the support is going to be longer, things like that. And in both cases, it’s free software, but we still have this product that is more similar to what we’ve just described, where we’ll be able to sell it as software that can be deployed, that can have long-term support.

Raphaël : Indeed, at the Open Core level, there is one point that is important, it will be on the license and intellectual property (IP). The company wants to have more or less control over the codebase. So it will need intellectual property in general on the code. And so, we find these notions of CLA (Contributor License Agreement), so that, precisely, the commercial entity can own the code base. In general, we can also find this model – at least, historically, there have been – of dual licensing, where the code is distributed (since it belongs to an entity, it can decide to distribute it as it wants, that’s always how it starts at the beginning), under a free license, but also under a license that is commercial and private, with a license agreement that is made with the customers. Depending on the use that will be made of the software, there is such and such a license that will allow it. A good example is MySQL. MySQL, from the beginning, it was under a double license, both GPL and proprietary without a GPL license as it’s a copyleft license.

In general, Dual Licensing works well with copyleft licenses. What for? Because when the company decides to distribute the software under a proprietary license. it will remove the contaminating, viral or persistent aspect (it depends on how you find the copyleft: is it good or bad, it doesn’t matter, there is no judgment). It will remove these constraints and therefore it will allow companies to contract directly with the company that distributes the software, in this case MySQL, without having to deliver modifications that they would have made in the code or around it by integrating. It is found quite a bit in embedded software, for example, when MySQL is integrated into software or even close to hardware. Indeed, it’s easier to sell to a company, as I said earlier, where a buyer will find things he knows, since in the end, he has a fairly classic license, as he is used to doing.

Walid : That’s a question I’d like to address. What is the role of venture capitalists (VCs) in all this? Because you set up your company, we’re going to give you money. A VC will put money in your box, he will wait for a return. What happens if he doesn’t get that feedback? What is the impact on your beautiful ideals of making free software, etc. ? We can see at the moment that there are still problems related to financing. And this open core model where you have a company that is a publisher, if on top of that, it has all the intellectual property on the code, nothing prevents it from changing licenses and starting with non-free licenses, in the end. This is an issue that needs to be taken into account more and more. And then, once you’ve changed your license, there’s nothing to say that you’re not going to change your license a second time as well.

Raphaël : This aspect of the code is important in terms of maturity. Because it’s true that this doesn’t even happen in the open source field: even on large projects, for example, when you do it for large companies or in the public sector, there is this need to have the guarantee that the code and the software will still be functional and therefore potentially have access to the code in 20 or 25 years. And so, there is no guarantee of the company’s sustainability and that’s why often, it can be asked to register the code, to deposit it, for example, with the Caisse des Dépôts to ensure that even if the company disappears, the code will still be available, and that there will always be someone who will be able to maintain it. I’m thinking, for example, of code that runs nuclear power plants or is sent into space. And it’s true that from this point of view, open source can be a guarantee for some of these players of sustainability and of keeping control of what they build because they have critical or long-term uses. It will reassure them.

Gonéri : It reminds me of the space industry where they had this kind of request.

Walid : We had requests for support for 20 years of the software and we explained that 20 years ago, the software didn’t even exist. It was a bit complicated for us…

There are several levels in open core and also, I think I’ll talk about that in other episodes, because we’ve talked a lot with people who now have open core models. Companies that are just starting out are starting directly on an open core model. That’s understandable. They have drawn a little conclusions from everything that has been done before. They believe that for them, it seems better and also to finance themselves.

But there are also companies that are looking for themselves and trying out several models before arriving at an open core model. And some say that it is indeed with this model that they have managed to finance themselves. We even talked to companies that are on open core models like this and who told us “When customers call us, we don’t even tell them that it’s free. They are looking for a solution, we tell them that we have a solution, we don’t even tell them that it’s free. You see, that’s understandable. That is to say, those who want to, they use the free version, but people, they come to us for a solution. We give them a solution.”

There are quite a few people who have come to this model by force and who have gone through support. They tried a lot of things, etc. And then, they came up with this model. You also have companies that are going to do free software but whose only goal of the founders is to be bought. And so the sustainability of the project can be a bit complicated too.

Gonéri : I think there is also the question of fundraising. Today, if you want to have a bank, investment funds, things like that, and if you say that you don’t have intellectual property (IP), that you only have communities and that the customers are people who give you money because they want to give it to you, it becomes very hard to have investments and to be able to grow your business quickly. I have seen several times cases where companies have chosen different licenses to be able to satisfy these requests from VCs. CLAs provide security at this level, it’s a way of saying “OK, in any case, if things go wrong, we always have a way to take a proprietary license at some point”. This can be a way of insuring the investor.

Raphaël : Sometimes it’s also not a model that we take this community aspect right away. Precisely, as I said, the articulation between business parts and community parts. I even have the example of a former colleague who was with us in the Open Source Center quite a few years ago and who left for an open source publisher like that, which provided services and a solution in the field of e-commerce. Initially, they did not necessarily have this community aspect in mind. He was hired, he came to do this, to develop the community part. He told me that it took a long time, because it’s not that simple. It’s a real change of mindset within companies, to understand that we open things up and let people come and modify the code base, all this with rules and everything, and that it really wasn’t that simple and that it took him a lot of time and energy. It’s true that, once again, as we can see, the models we’re talking about are not static. Companies will look for themselves as they go along, but every time there is a change in model, there is a questioning and this is not trivial.

It’s true that there can be risks around. There are companies that have been able to find models and stabilize themselves by changing the model once, twice or three times. We met people at the show who talked to us a little about it. There are some, they may have found themselves in a bit of a very complicated situation because either they lose their customers or they lose the community. It’s not guaranteed.

Gonéri : I have the impression that this model was good in the years 2000-2010, but that it is losing momentum. The model where we try to grow a community of users as quickly as possible, to show, to make ourselves known, to invest with capital that comes from investors who bet on us. I’m thinking of OpenStack, things like that, where it worked very well and now investors have kind of gone back to that model. They believe in it less, or they have seen that it is not necessarily always profitable. In the 2020s, it’s a model that doesn’t work too well.

License changes and projects that are closing

Walid : We then noticed that there were new trends, potentially new types of licenses, projects that change licenses to try to find a certain sustainability that even some of them were closing off completely. We had noted a fairly well-known example, which is SugarCRM, for example, which I think is quite emblematic. I don’t know if one of you wants to say a word about it or talk about another software?

Raphaël : A major trend that I have observed over time in the evolution of business models in open source has been license changes that are linked to the emergence of SaaS and the Cloud. What you have to understand is that open source licenses, the first, the main, the most used, they were created before the appearance of the cloud. So they were not designed or armed for that purpose. The only one who had really anticipated the thing a little bit when it appeared was Richard Stallman. It’s true that sometimes he is called a bit crazy, a guardian of the temple, but he had anticipated the thing. He said, “The Cloud is going to be a problem for us with the Free Software Foundation’s licenses.” That’s why he created the Affero GPL, which is the AGPL, to say “Virality doesn’t stop when you switch to a service mode provided on the cloud”. That is to say, if we make changes to the code and sell services, in this case, these changes, they must also be contributed. Copuleft still applies.

That’s why he created this license, while the other more open source, more permissive licenses don’t have a mechanism to guarantee the fact that a code base will continue to evolve because people use it and modify it. That’s why it has given rise to a whole movement with the emergence of Cloud Service Providers for whom, it doesn’t cost much, indeed, to reuse an open source component and provide it in SaaS mode with a lot of investment and quality of service, SLAs as we used to say, and it gives rise to projects like MongoDB. It was one of the first, in any case, one of the most visible that did this, that changed its license and created a new license called the ” Server-side Public License “, so the SSPL. She says that if you provide Mongo-as-a-Service, in that case, all the modifications you make in Mongo and around it to industrialize it, you must also pay it back to the common pot and to the project, so to us, Mongo. It’s like creating a kind of “copyleft” but on licenses that weren’t… On projects that weren’t planned like that at the beginning. And that’s really to fight against Amazon and other cloud providers.

Afterwards, there are others who have done it. There is also Elastic which has switched to an Elastic License where they go further. They outright ban “Elastic-as-a-service”, i.e. they ban “managed services”. They say that the only ones who will be able to really sell Elasticsearch or Kibana as-a-Service are us. That doesn’t mean that we can’t use it to sell services, but services that are much broader, that are not focused only on this basic service that is ours. That’s how they try to guarantee their sustainability too and to fight a little. Obviously, as soon as they did that, there were the big cloud providers who forced them by saying, “We’re going to continue to use the other versions, we’re going to evolve them.” Of course, from this point of view, if it’s not well explained first, it can scare users and customers.

So it’s more in line with the Open Source Definition since we’re putting a restriction, which is not in the open source definition or free software. Even more recently, we’ve seen other types of reactions to this. That’s MariaDB. MariaDB was already the fork of MySQL by Monty, who had created MariaDB when it was bought by Oracle. They innovated, they created the Business Source License, the BUSL, not to be confused with the BSL which is the Boost Server License, BSD type.

In the case of MariaDB, first, you can put restrictions on commercial use of the solution to say “If you want to use without wanting to make money directly with it, that’s OK. If you start wanting to make money, we have to talk. And above all, there is a notion of promise over time that what we put under this license will eventually become open source. As we have seen, MySQL was under dual commercial license and GPL. It’s still under the GPL, but the new features that come out on the MariaDB side, they’re going to be on BUSL and it’s after four years that they commit, it’s written in the license, to release the code and to get it back under the GPL license. It’s open source in the long run.

Walid : I saw on another project I’m following that is recent where it’s the same, they say “We’re on a BUSL license, but on the other hand, in four years, we’ll be in an MIT license.” Yes, except that it turns out, you, in four years, startup will no longer exist to you…

Raphaël : There’s a story of having confidence in the fact that the project will continue to evolve and innovate, but first, it needs, with this novelty, to guarantee its financial sustainability, but that doesn’t necessarily call into question the idea that it’s open source in the long run. On the other hand, it calls into question the definition of the Open Source Definition again.

Walid : That’s a kind of groundswell after all. There are still a lot of projects that decide to change licenses. Especially lately, we’ve heard a few, but some pretty emblematic ones, who decide to change licenses.

Gonéri : They are looking for or asked to change their business model. It’s true. The board is not necessarily the people you imagine. In the 2020s, 2010s, it was quite easy, I think, to have VC investments, if we were doing software, as long as we had a big user base, that we had notoriety, that we managed to lock in users, things like that and sell it to VCs. Today, VCs have understood that this is not true, that we could very well have Amazon that arrives and starts to make a SaaS commercial offer of these same software and in a few weeks, users start to migrate. We lose the investment that was made. And for me, these license changes are related to that. Each time, these are companies that are still American companies that have experienced rapid growth, where there have necessarily been injections of capital. There’s a good example that happened not long ago, and that’s Elasticsearch, which became OpenSearch. In fact, OpenSearch was Amazon’s aggressive fork that forked it because Elasticsearch changed its license to prevent Amazon from doing SaaS with it and draining revenue.

In fact, it’s a situation that is quite easy for a company like AWS to do SaaS because they have all the infrastructure, they have the knowledge, they have the vendors, they really have everything to be able to do SaaS. And behind that, we have the free software publishers who are not armed in the same way and who find themselves having to defend themselves against aggressive players like that. For me, it shows the interest of foundations anyway, because a foundation that was created 15 years ago, it will still be there in 15 years. It’s a model that is still… Which really stabilizes this kind of thing.
All the software that has been managed by foundations for a long time, to my knowledge, there have been no problems.

Walid : Before, we were doing the community model, we didn’t have any money, we were looking for another model. Now they were making open core models and they are looking for another model. What I remember a little bit from all this is that these ecosystems are constantly evolving. There are changes in models. It’s good, it’s not good, I don’t know, but in any case, it’s quite exciting to follow!

Ethical licensing

Walid : To finish this list, there are small side-projects that I still wanted us to talk about because we can’t pretend they don’t exist. I don’t know what the person’s name is, but it was while watching a conference at Capitole de Libre 2022 that I became aware of this. These are the licenses that are now called ethical licenses. Most of the people I talk to about it, they say, “Why do you want to talk about this stuff? In any case, it’s not free. But my opinion is that you can’t pretend that, because it’s not free, there’s no point in talking about it.
And so there are licenses that are not free because they put restrictions on use. We had mentioned several of them, Raphael. I met one not too long ago who was an Anticapitalist License. And you, you put others. Can you just list the ones you put in?

Raphaël : This is on the edge of open source. For example, the Hippocratic License or the Do Not Arm License. They want to make sure that they will put conditions on the behavior that users will have, or even the use they will have of the software. And that often covers social aspects related to the environment or human rights. In relation to the definition of open source, it becomes problematic and in general, it goes beyond the OSD. It’s no longer considered open source, because it puts restrictions.

This kind of phenomenon happened a little bit in the aftermath. At one time, it was fashionable to make codes of conduct on projects in large communities. It also corresponds, for me, to the renewal of contributors with new generations. They are their point of attention, their focus today. They have a vision of the world they project themselves onto and the environment will be important to them, social movements or this kind of consideration too. They will be attentive to this. We see it in companies when we hire them, but we also see it in communities and on projects.

To get these potential contributors back, we also have to put forward values in which they will find themselves. The problem is that indeed, afterwards, it no longer conforms to the definitions, which date, admittedly, from the FSF or the OSI. There are those who ask that these notions be revisited or reviewed. We find this phenomenon and it is a good example in everything related to artificial intelligence. In this area, there are also these licensing issues. To begin with, when we talk about licensing a model, for example generative AI, we have to see what we are talking about. Are we talking about the dataset, the model, the weights, the code that is associated, etc.? ? It can be quite complex. These are things that I am currently analyzing. We find this notion of “we are open, but we put restrictions on use”. We’re going to find this kind of thing again with what we call ” OpenRAIL licenses ” — “rail” means “responsible ai”, so a license where they will say “Yes, you can use this model, but obviously, you shouldn’t do any harm, you have to respect the law, etc.” But sometimes, this can restrict medical use, or in connection with the military.

We see that it is associated with ideals, with a vision of things. But it can also be “We are forbidden to do hosted services” and therefore to offer the model to compete with a Meta or another model provider. With these notions of ethical, there is a bit of a shift, and I think it’s still linked to the evolution of society: we can’t ignore them because the world is changing and the contributors, the people who contribute and who will use the software are also changing. Even though it’s not pure open source, it’s something that needs to be considered, in my opinion.

Gonéri : In 95% of cases, these licenses are indefensible in front of a jury, already.

Walid : What interests me in this is not whether they are defensible or not, but what interests me is to understand the real motivations of the people who do this, knowing that they certainly know for a fact that their licenses are not free.

Gonéri : As soon as someone has free time and wants to create software and puts their license in place, I don’t see how it’s a problem. It can be shareware, it can be a proprietary license that’s a bit original like that. For me, it’s still that the person uses his time as he wishes. We don’t have to judge what he does with it. On the other hand, you shouldn’t tell him that it’s a free license. That’s a lie.

Walid : I don’t think people say it’s a free license. I watch because I’m trying to understand the profile of the people who do this to try to see if there are trends. I’m interested.

Gonéri : It makes me want to do my bachelor’s degree.

Open Forums

Walid : That’s it, we’ve made a first panorama. There will certainly be a lot more to say. But we’re going to keep that for future episodes, either with specialists in certain fields, or with projects that use or have been looking for each other and end up using one model rather than another. It’s definitely a streak that’s going to go on for quite a long time, I think. I’m very happy that the three of us did this episode. I will let each of you say a few final words before we conclude.

Raphaël : It was a pleasure to participate in this podcast. I was super happy to see Gonéri’s face again, because it’s been a while since I’ve seen you. Your hair is a little gray, which means that a lot has happened since then.

Indeed, even in the field of open source, we have seen a lot of evolution on business models and licenses, with the trends we mentioned, and then the evolution of the different community models, after Service, after Open Core, etc.

I think that the licenses and business models that are associated, because I don’t differentiate between the two, are still important to look at. Because it’s true that around me, people who say “I don’t care about the license, your open source isn’t very important. As long as the code is on GitHub, I fork the project, then I’ll make a Merge Request, etc. Be careful, because there are still rights and duties and it’s a shame not to understand a little what these constraints are.

There’s another thing that makes me happy after 20, 25 years in the field: the licenses that were created at the time, and the foundations that were created as well, are still there. For some, they are very present. They have helped structure what is the IT landscape today in general and not just open source. This proves that these are things that work, that work, that are stable. Today, open source has become mainstream, it is everywhere. Today, we no longer ask the question of “do we need open source?”, it’s rather “how?”. We have also seen in these business models that there are quite a few companies, foundations, projects that have been looking for themselves and that have been able to change over time. It means that nothing is set in stone and that it can always evolve. That’s why you have to stay up to date with what’s going on and follow a little, especially with the QSOS method, which are the points that can be subject to change. And as we have seen, when there is a need, there are other types of licenses that will start to emerge.

Afterwards, we can have a debate, is it open source or not open source? I don’t care. In any case, we can see that there are new needs that are emerging and that there is a need to cover them. It’s a field that is still very dynamic, and it makes me happy because it’s not dusty: we’re not in rearguard action. We see that it’s in society with all that has been said about ethical licenses, that kind of thing. Tomorrow, we are not immune to the emergence of other types of licenses and even new types of business models. That’s what’s exciting: even after decades and decades, it’s a field that remains completely abundant with communities, human beings who want to co-create, because the idea is there: to create together and always go a little further in what we’re going to be able to invent. It doesn’t make me regret taking such a deep interest in all this, because it’s very satisfying.

Thank you very much Walid for inviting me and for being able to open up about all this, in addition to meeting you both. Here, we feel like we’re back in time. It was nice.

Walid : Thank you very much. Goneri?

Gonéri : Same. Thank you for the invitation. There is one model that has not been talked about much, and that is the one supported by large companies. I’m thinking of AngulairJS or Kubernetes. I think it’s called Borg or Grok at Google or it was called that. It’s this model where a huge player who has a need produces internally and he creates this product, but he doesn’t necessarily want to sell it. He’s just going to make it free and hold it.

Yes, I found it interesting. The subject is vast. I was afraid that we would get lost: I think we got a little lost, despite everything. But, I think that despite everything it was an interesting discussion. Thank you. It was nice to see your faces.

Conclusion

Walid : I do remember the side “it’s an ecosystem that lives and is not sclerotic”. And it seems very important to me because generations pass, because models evolve and everything. And it’s quite exciting, especially given our advanced ages, to have seen all these models and to continue to see them. For those who are interested, who want to know more, you can listen to the episode with Benjamin Jean.

Be well. Feel free to leave me comments. You can reach us on Mastodon, you can leave comments on the WordPress website, you can send an email or on LinkedIn. Rotate it if you’re interested because I’m very curious to have the feedback to see a little bit of the topics we skimmed over and it will also give me ideas of people to interview behind it. Although, to be honest, between the Capitole du Libre and the Open Source Experience show, I think there’s enough to do just about everything in 2024.

See you soon, be well and long live free software!

This episode was recorded on December 8, 2023. Transcription by Walid Nouh

Sources for further reading

• Pierre-Yves Lapersonne – Open Source Licenses: Between Parochial Wars and Radicalism
• The business of Open Source podcast by Emily Omier
• Radio Devops Podcast: License Change for Terraform (at 42:32)
• Dan Lorenc’s post on LinkedIn about the reasons for the Terraform license change
• Article by Sébastien Dinot on the evolution of the governance of open source projects (2020)
• Evolution of the governance of free software projects – Sébastien Dinot – Capitole du libre 2022

License

This podcast is published under the double license Art Libre 1.3 or later – CC BY-SA 2.0 or later.