Panos Alevropoulos, FSF volunteer and administrator of ESP Wiki, spoke at LibrePlanet 2022, March 20th. His presentation is entitled “The state of software patents in 2022”. This is the transcript of that talk. You can find the recorded video here.

Another LibrePlanet 2022 presentation on software patents was “ANS coding replacing Huffman and AC–from introduction to patent issues” by Jarek Duda.

Note: This transcript is not a faithful reproduction of Panos’ talk, but an edited version of his presentation. Many parts were rephrased to correct any inaccuracies and provide a more comfortable reading experience.


Stephen: I’m Stephen, the room monitor for this talk, titled “The state of software patents in 2022” and will be presented by Panos Alevropoulos. Panos, among other things, is a volunteer member of the FSF Licensing & Compliance Lab, End Software Patents Wiki admin, and verified by Creative Commons. Panos, welcome, and please proceed.

Panos: Thank you Stephen for the introduction. I am Panos Alevropoulos, I studied law at the Aristotle University of Thessaloniki in Greece, I am a former intern at the Free Software Foundation, and I worked primarily on the End Software Patents campaign, to which I contribute as a volunteer today. So, my topic for today is “The state of software patents in 2022”. It’s going to be an overview of software patents in 2022 along with some historical elements, and we will explain why software patents are basically a bad thing. I mean, you can tell from the title of the campaign, but, to be more specific about what we are going to talk about today, here are the contents of my presentation:

  1. Introduction to software patents
  2. Why software patents are a threat
  3. The situation in the United States and Europe
  4. Non-solutions against software patents
  5. How to really End Software Patents
  6. Ways to achieve our goal

Introduction to software patents

To explain everything clearly, let’s just start from the basics. This is going to be a legal presentation, but please bear with me. I will attempt to explain everything in simple terms and the goal is to just make everything clear and make people discuss software patents, because they are really important and they are sort of neglected compared to copyright.

First off, what is a patent? A patent is a legal tool that gives its owner the legal right to exclude others from making, using, or selling an invention for a limited period of time in exchange for publishing an enabling disclosure of the invention. Now, when I say for a “limited time”, we are talking about at least 20 years, and for software that is a lot. An “enabling disclosure” means that I have to file a patent application, then the patent office will accept my application and will grant the patent, so the public will have a document that is publicly available and explains all the technical details and how my invention works. The international requirement for inventions is that they should be new, involve an inventive step and be capable of industrial application. These are only general criteria that should apply to patents throughout the world with some slight differences.

To understand patents, it’s also important to understand copyright. This way we can distinguish between the two. So, what is a copyright? A copyright is an author’s exclusive right to copy and distribute a creative work, usually for a limited time. The creative work may be in a literary, artistic, educational, or musical form (including software). It applies to the original expression of an idea in the form of a creative work, but not the idea itself. So, the free software licenses are really copyright licenses; they restrict the copyright terms and make everything more publicly available. But they don’t really work against software patents, so it’s essential to understand the difference between the two.

Right, so now that the difference between copyright and patents is clear, what is a software patent? Well, like the name suggests, it’s just a patent for software. But, it’s really not that simple, because it’s not evident that inventions should include software too… and that’s what we’re going to discuss today.

Here’s a table that shows an overview of the difference between copyright and patents.

CopyrightPatent
Creative work
(expression of an idea)
Invention
(methods and
processes)
Applies automaticallyMust be granted by a
patent office
Governs right to use,
copy, distribute
Establishes a
market monopoly
Duration: life of the
author + 50 or 70 years
Duration: at least
20 years

The main difference is that patents establish a market monopoly and they last for 20 years. 20 years might not sound that long compared to the duration of copyright (life of the author + 50 or 70 years), but they are in fact extremely long if one takes into account the restrictive nature of patents. Just imagine what 20 years mean for software: A software patent that was granted in 2002 would only expire in 2022. So many software technologies were invented during this time period, and they were all restricted by such a patent. This illustrates why patents in software are so restrictive.

Why software patents are a threat

So, let’s be more clear here. Why are software patents exactly a threat? Why do they present a danger for programmers and perhaps society itself? I have some arguments here that I will present to you one by one.

1. Blocking innovation: First of all, software patents are blocking innovation. Patents can be very scary. When I’m writing a program, I certainly don’t have any patents in mind and I can’t imagine that in the future I might be sued for something that I wrote myself. That concern only comes to mind if I’m copying code from someone else. But here’s what happens with patents: I can be sued even if everything was my idea, simply because someone else in the world had the same idea, and they patented that idea. The funny thing is that, most likely, I have no idea that such patent could exist for two reasons: One, because patents are not easily found. I would have to search for patents all over the world, just to find something that is close to my idea. The second reason is that some software patents are very obvious and that’s a real problem, because they shouldn’t have been patented in the first place.

2. Leading to extraordinary costs: Another problem is that software patents are really expensive as a concept, like all patents. The problem with software is that most people, when they write programs, they do it at home. It’s very cheap to write a program, there are literally almost zero production costs. So, you can’t expect from someone who writes programs for fun to actually have the resources to face legal battles. To give an example, let’s just say that I’m a programmer and I’m trying to create a business out of my program, and, out of nowhere, Microsoft sues me because I infringed one of the thousands software patents they own. It goes without saying that I almost certainly can’t afford litigation costs to fight Microsoft in court. This situation demonstrates why the patent system is unjust in the software sector.

3. Harming freedom of expression: If you think about it, the restrictive nature of software patents effectively harms developers’ freedom to write code. It doesn’t matter if you are a free software developer or someone who writes proprietary programs; anyone who owns a software patent can at any time file a lawsuit against you for patent infringement.

4. Software progress doesn’t need patents: Patent advocates argue that patents provide financial incentive, so the same should apply to software, right? Well, free software advocates have long argued that patents really haven’t contributed anything. There is no noticeable change between the pace of software progress before and after patents.

5. Software is math: Now, this is just a legal reason against software patents, but it’s actually very important when discussing patent eligibility. Simply put, in almost all countries, mathematics cannot be patented because they are considered to be a concept of nature. Software also falls into this category. Software code is a series of mathematical formulas, so it’s algorithmic in nature. So, really, it all comes down to the fact that software is math, and it’s not patentable subject matter.

6. Software should be free: Finally, we, the free software community, strongly support that users should have the freedom to run, copy, modify, and distribute software. Patents are fundamentally against this philosophy. This might not be relevant to proprietary programs, but it demonstrates how patents affect free software beyond copyright.

With that out of the way, I hope you understand the core reasons to abolish software patents. The difference of the End Software Patents campaign compared to other similar initiatives is that the Free Software Foundation believes that only a legislative ban of software patents can be effective. There are really no other solutions that are good enough. I will be discussing this in more detail towards the end of my presentation.

The situation in the United States and Europe

Just to give an overview of what’s going in the world, I have chosen to present some details about the United States and Europe. Of course, there are other very important jurisdictions, like China, Japan, India, and basically every other country that accepts patents, but here’s the thing: Both the American and the European patent systems are actually very influential to the world, so other countries are very likely borrow some trends and concepts that derive from these two systems.

Let’s start with the situation in the United States. First of all, it’s important to understand that software patents are not regulated via some sort of legislation, so the American patent system relies on case law. Although rare, it’s the US Supreme Court decisions that have the most impact on whether software patent applications are going to be granted or not. The most important decisions related to software patents are presented here:

DecisionImpact
Diamond v. Diehr (1981)Great, allowed software patents
Bilski v. Kappos (2010)Low, against software patents
Alice v. CLS Bank (2014)Great, against software patents, but not enough!

The most recent decision was Alice. The ruling brought a narrower interpretation on software patent eligibility, which is a good thing, but it was not enough. Sure, there was great progress since Alice and many patent applications on software were invalidated, but it never meant that it’s impossible to be granted a software patent. The Alice decisions made it harder for applications, but it didn’t change the fact that software patents are still issued.

Just to give an example, yesterday on LibrePlanet, Jarek Duda had a very interesting talk in which he described his personal experience. Jarek explained that, despite being the original author of a compression algorithm that was created years ago, other people who were not involved in that process have lately tried to register that very work. Their persistence was successful. Just two months ago, Microsoft was granted a patent on that algorithm.

Okay, so like we mentioned, software patents are not regulated. But this doesn’t mean that Alice cannot be overruled by legislation. In fact, law can always override previous court decisions, and in this case it can go both ways: It can explicitly say that software cannot be patented, and that would be great, that’s exactly what we want. On the other hand, it is certainly possible that the Congress can be influenced by lobby groups to establish software as patentable subject matter. This would be terrible, because it would eliminate any possibility of narrow interpretation in the application process.

Let’s head over to Europe now. How do patents work in Europe? Basically, each country has its own patent law. However, since 1973, a multilateral treaty called the European Patent Convention (EPC) provided a supranational European autonomous legal system according to which European patents are granted.

The EPC has a very specific provision on software patents, namely Article 52(2c)(3). This article specifies what should not be regarded as invention, and “programs for computers” are included in it. That sounds very good, it looks like software can’t be patented, right? Well, in reality, no, because there is another detail here: computer programs can be excluded from patentable subject matter only if they are considered to be “as such“. This wording is very vague and it’s not 100% clear what it means. The general meaning is that if computer programs are considered to have a further technical effect, then they should, in fact, regarded as patentable subject matter. This “further technical effect” is open to interpretation, but the European Patent Office (EPO) has traditionally been particularly lax about it. This means that if the EPO is not reluctant to grant a software patent, it will always interpret Article 52(2c) broadly, as if the exclusion of computer programs never existed.

With that in mind, let’s take a look at some interesting recent developments. In 2013, the Unified Patent Court Agreement (UPC Agreement) was signed by most European Union (EU) member states. This treaty proposes a different system to the current European one. Here’s a table that provides an overview:

European patentUnified Patent Court &
Unitary Patent
Contracting states
(not just EU member states)
Only EU member states
Unified patent applicationUnified patent application
Group of national patentsUnitary patent
Infringement cases handled
separately by national courts
Infringement cases handled
by the Unified Patent Court
Patent validity opposition handled
by the European Patent Office
Patent validity opposition handled
by the European Patent Office

The way patent law works right now is that everything is a bit fragmented, so to say. If I want to file a patent application, I can file it to the EPO, but, if I am granted that patent, I won’t actually have a single patent, because a patent is actually a national instrument. So, the EPO grants a European patent, which is really a bundle of national patents. I will have a patent in Germany, Greece, Italy, and so on. This has a severe legal implication: If I believe someone infringed my patent rights, I would have to seek litigation in different countries, which can be very expensive. The worst scenario is that the different national courts will have opposite decisions on the same legal case. For example, the German court can decide that there was patent infringement, but the Polish court can decide that there was no patent infringement.

All of that is going to change now thanks to the Unified Patent Court and the Unitary Patent. From now on, in the EU, apart from the unified patent application provided by the EPO that existed already, the resulting patent is going to be Unitary and litigation will be handled by an independent Unified Patent Court, not just by national courts.

The Unified Patent Court and the Unitary Patent were actually two separate proposals, but are directly linked together. There was a lot of discussion and legal battles around them. In fact, although they were signed about 10 years ago, it took many years to become a reality, because they had to be approved by national governments first. The Unified Patent Court is currently still being set up.

So, why is this all relevant to software patents? Well, it’s extremely relevant, because what saved us from software patents in Europe was the fragmented process of enforcing patent rights throughout different countries, which was very expensive for patent holders. A supranational patent system such as the UPC Agreement is going to be much more effective. The process for enforcing software patents will be easier and faster. This is the first reason.

The second reason is that there is a very high probability that the Unified Patent Court will have a pro software patent bias. Let’s not forget that these initiatives are fueled by people who have a vested interest in expanding patents’ dominance, and that includes software patents. The Unified Patent Court will be independent of all EU institutions, so it will almost certainly be populated by biased judges, like former patent attorneys. Software patent applications will enjoy great success.

Non-solutions against software patents

We are now at the most crucial part of the presentation. How do we deal with all the problems that software patents cause? The free software community has discussed this issue for many years, but there are not many effective solutions. I will now present some attempts that have been made against software patents, which I call non-solutions, because they don’t completely solve the problem.

1. Invalidating harmful software patents: This is of course very beneficial. We always want to reject as many software patents as possible. To give an example, there was a presentation last year at LibrePlanet by the GNOME Foundation, which described their experience with a patent troll. “Patent trolls” are companies that acquire patents for the sole purpose of suing other developers. So, the GNOME Foundation was sued because their program Shotwell allegedly infringed a general software patent, which shouldn’t have been granted in the first place. The GNOME Foundation seeked the invalidation of the patent, but the case ended with a settlement.

The Shotwell case was fortunately handled by pro bono lawyers on behalf of the GNOME Foundation. But the free software community cannot always rely on pro bono attorneys for its protection. Right now, the patent system is basically a cat-and-mouse game for companies that have all the resources required to sue each other and do this forever. This means that we have a permanent disadvantage; we will never have the resources to invalidate every single software patent or protect ourselves against lawsuits. For every single software patent we reject, dozens others are granted. This is not sustainable.

2. Defensive patent acquisition / pools: For the same reason, acquiring software patents ourselves and then granting full patent rights also doesn’t work in the long term. I mean, I posed this question to Jarek Duda yesterday, and he simply replied that “sure, I could have acquired a patent myself, but 1. the process for that is too expensive, and 2. people can always patent other variants of my work”. This just shows how ineffective the patent system is. Patent law requires that there should be “no prior art” for a patent to be granted. “Prior art” means any previous known and published work related to the invention, and it doesn’t matter if it was patented or not.

Patent pools are a similar idea, except it’s not one entity but groups of people who form an alliance and acquire patents collectively. The goal of defensive patent pools is to reduce the harm of software patents to all or to a specific group of software developers, like the free software community.

3. Case law against software patents: This is also neither an easy nor effective solution. Positive court decisions on software patents do have a considerable impact, like Alice in the United States for example, but case law is not as definitive as legislation. At the end of the day, it doesn’t matter if there are many or few software patents, because the threat persists. This is why we need a law that bans software patents.

4. Raising examination standards: Okay, if the patent system is so broken, why don’t we try to fix it or at least make it better? Let’s make patent offices work harder, have a better database on prior art, make mistakes less frequent. This would decrease harmful patents and increase quality patents, right? Well, yes, that sounds good, but the problem is still there; people can still sue us for infringing software patents. The Free Software Foundations doesn’t believe in just software patents and doesn’t distinguish between good or bad software patents. The very nature of patents is fundamentally against the free software philosophy, that’s why we reject them altogether.

5. Patent clauses in free software licenses: Some software licenses, like the General Public License, include patent clauses. A patent clause is basically a provision in the license text that requires distributors of the program give recipients to use any necessary patents. The general effect of such clauses is that they revoke any patent rights received through the the license. Patent clauses only apply to patent holders who distribute the program under the license, so they are certainly not universal. They limit the effect of software patents, but don’t deal with them completely.

How to really End Software Patents

We discussed non-solutions, so how do we really End Software Patents? Actually, let me be clear first; I call them non-solutions, but it’s very good that they exist! If there wasn’t any kind of protection against software patents, the situation would be far worse. So, yes, the end goal is to abolish software patents, but we will never say that non-solutions are bad or useless. They are very welcome, but we should always keep in mind that they don’t offer a complete solution.

So, finally, we will discuss ways to accomplish the abolition of patents.

1. Legislative ban on software patents: First of all, the best scenario is to have a law that explicitly says that software patents are illegal. The process to would have to be done individually in every single country. This sounds very hard, but we should work towards this goal.

2. Shield software from litigation: Another solution, proposed by Richard Stallman, is to shield software from litigation. What this means is that we would accept software patents to exist, but we would effectively make them have no real effect. Such a law would accept software as patentable subject matter but would explicitly provide that developing, distributing or running a program on any computer hardware would not in any case constitute patent infringement. This would eradicate all problems stemming from software patents.

3. Increase democratic processes: In general, patent laws and policies have been set without direct input from citizens. If we increase democratic processes and make people aware of the harm of software patents, we will maximize the chances of getting them repealed by legislation.

4. Ban all patents? A lot of people have argued that the whole patent system doesn’t provide any benefit. This sounds radical, but also sensible if we think about all the problems. The Free Software Foundation and the End Software Patents campaign can’t really talk about other patents, because our focus is software and nothing else. But we can’t deny that banning all patents would mean no software patents.

Ways to achieve our goal

We have presented our end goal, which is to End Software Patents. Now, we can talk about the steps required to achieve it.

1. Spread the word, write articles, be active! Software patents are an important issue and we need to make our voice heard. It should stop being a neglected topic.

2. Educate (use tools such as ESP Wiki): We need to educate people to make them understand what software patents are and why they pose a threat. We can use tools such as ESP Wiki, which is an international database for campaign material against software patents.

3. Donate to organizations (FSF, EFF, SFC, SFLC): Campaigning needs financial resources, so we need all the help we can get.

4. Fuel local efforts to influence policies: Please don’t be afraid to talk about software patents to local politicians. An organized effort against software patents should be created in all countries.

5. Contribute to ESP Wiki (very much needed! I will conclude my talk with an open call for help to the ESP Wiki. We invite people to contribute to it with any information they can find on software patents. A complete database against software patents will make international coordination more effective.

Thank you!

That was it, I hope you enjoyed my talk. I know it’s a hard topic to grasp, but I hope I didn’t speak too much legalese. I tried to include as much information as I could and explain it in simple terms. If you have any issues, I would be happy to answer them.

Questions

Stephen: Thank you Panos, there was a question that came up in the chat: “What’s the problem with the software license revoking patents? Why was it a non-solution?”

Panos: The problem is that patent clauses in free software licenses have a limited effect. They basically concern only distributors of the program who have patent rights. The patent clause will just guarantee that these rights won’t be exercised at all. It’s a non-solution, because it doesn’t involve banning software patents. It’s good to have them, and the General Public License has one, but it’s not enough. We need to have laws that abolish software patents.

Stephen: Someone says that there wasn’t much legalese, so thank you for that. It was easy to follow. Another question: “Outside of software, are software patents, as ‘enabling disclosures’, basically source code for material inventions?”

Panos: Outside of software… I’m not sure what that means, because we’re talking about software patents… (laughs). But when we say “enabling disclosure”, no, we are actually not talking about source code. If you take a look at some patents, they explain in detail the technical processes and methods that are used to create the end result, the invention. The thing is that it’s very broad, and the explanation that is included in the document can be used against so many programs, which is a real threat.

Stephen: “In what area help is needed on the wiki? Proposing legislation? Use cases? Or the existing laws or lawsuits?”

Panos: Actually, we need everything! Please just browse the wiki, we have multiple links. We have some links for communicating, so we are still organizing. We need teams that will document everything, so that we can have a comprehensive database on software patents. For example, some content on the wiki needs to be updated, but it would be also useful to document some patents to illustrate the problem better.

Stephen: Okay, thank you. A follow-up question: “So, does the free software license patent clause make the software user immune from patent litigation? That sounds pretty useful on its own, I think.”

Panos: Does it make the user immune… I will be honest, I haven’t actually encountered any real life examples, so I would need to research this further, but I’m pretty sure immunity is not a real thing. Patent clauses can provide some sort of protection, though, for sure. Of course, ESP Wiki is there for exactly this reason; to answer this kind of questions.

Stephen: Little tiny bit of time left here, here’s a good one: “Can we make a patent on making software patents, then enforce it to kill all other software patents? ;)”

Panos: That would be great, actually… (both laugh). If we could do that, it would be the ideal world. I see you Ian.

Stephen: I think we’re all out of time. If you have access to the chat, I may have missed a couple things you may want to follow up on, but thank you again for a very comprehensive look at this, and appreciate it very much.

Panos: Thank you very much! Do I have some time? There’s just one question that came up now.

Stephen: I think we might be out of time… actually, no. Okay, go ahead.

Panos: Okay. There’s a question here that says “Will the European Court of Justice (ECJ) in the EU have a say about software patents?” I think the question is related to the new scheme, with the Unified Patent Court. I think the answer is no. There is actually no direct involvement of the ECJ, and what will actually happen is that the Unified Patent Court will only be able to present questions to the ECJ. So, there’s some involvement, but I don’t think it can overrule the decisions of the Unified Patent Court. We will have to see how this will turn out in practice.

Stephen: Okay. Thanks again!

Panos: Thank you very much!

Stephen: Goodbye!

Panos: Goodbye!