Roundtable "Potential of OSS for ATM" - Jointly organized by CALIBRE and EUROCONTROL
Previous 7th December 2005, EUROCONTROL-EEC, Bretigny-Sur-Orge, France Next










Short bios



COTS, FLOSS, and Market Freedom
in Safety-Centric Industries

by Franco Gasperoni, Adacore, Inc


Free markets have come a long way since the medieval marketplaces, and one of the farthest along is the combination of Freely Licensed Open Source Software (FLOSS) and Commercial Off-The-Shelf software (COTS). A free and open market provides a common meeting place where customer and supplier interests can intersect and align, and the combination of FLOSS and COTS is unique in providing the best way to get a virtuous cycle up and running, especially for software designed for the long term, where safety is a critical component.

Let's look closer at an example of this free market at work: AdaCore and GNAT. The keystone to this successful combo was actually laid by the terms of the development contract between the US Air force and New York University: the contract stipulated that the software developed under the 3 million dollar engineering contract would be released under a GPL license, and that copyright of the software would be assigned to the Free Software Foundation. The freedom of the software is the backbone of AdaCore's business model: supplying a leveraged service: top notch support piggybacked on a ready-to-use COTS software package.

AdaCore uses a subscription model: revenues come from recurrent annual subscription fees, based on the level of support and the number of users to be supported, rather than the high initial purchase price model of proprietary closed source software. AdaCore's COTS products aren't available without the support -- that simply isn't AdaCore's business. AdaCore's support is the conduit between the users of their COTS product, GNAT Pro, and the actual developers of that software product.

GNAT Pro is a complex software package, a robust and flexible Ada development environment based on GNU GCC compiler technology. From its core compiler to its debugger, libraries and Integrated Development Environment (IDE) all components are entirely based on FLOSS. The Ada language is widely used in safety-critical applications, and AdaCore offers the GNAT Pro High-Integrity Edition, with runtime support amenable to safety certification.

AdaCore develops and maintains the free software, and packages it with documentation into a polished, well-supported COTS software product. AdaCore's products compete with other solutions from proprietary vendors who also offer polished COTS Ada development environments. But there's one difference: AdaCore also competes with anyone else who wants to repackage and sell the core of AdaCore's COTS product. And that's where the free market comes into play.

Software infrastructure investments have a hidden additional cost -- the cost of switching. In addition to the up-front costs of buying a proprietary software package, the customer is at a complete disadvantage when negotiating with his software supplier. Support costs and service levels provided are not based on the value to the client, but rather on what the supplier can demand, knowing full well what the cost would be to the client if he has to switch his COTS software base. Since the proprietary software copyright holder has a monopoly on the use, copy, and modification of his source code, the customer cannot shop around for a better deal, or higher-level support. Customers become locked in to their software suppliers. The market is flawed, and cannot function as a nexus for free exchange.

FLOSS COTS software changes the game, and levels the playing field. Suppliers have to offer greater value to customers in order to keep them. Niche players can thrive in a software ecosystem where their specialization offers premium value to their specific clients. Development, i.e. program modification, is decoupled from support and certification material. The copyright monopoly lock-in is broken, freeing the user and providing choice.

FLOSS and COTS converge, to provide the ultimate free market. Exchanges from customer to developer provide the building blocks to improve and evolve the software itself. A virtuous circle is established.

The driving force behind COTS it to share costs, to spread the investment and risks of software development over more entities that have similar needs. The AdaCore business model can be extended along another dimension: software co-ops. Software co-operatives group several companies to share resources and know-how, in order to develop and support software over the long term. Working together, they can reduce costs for developing certification material or safety or security, and more generally, improve software quality for the co-op members. Co-ops extend the notion of open source: the software developed in a co-op need not necessarily be open source: a vendor could, for example, put his software under a special license, and make it available to all ATM operations in Europe, to get the co-op started.

This could be directly applicable to ATM software. Let's imagine, for an instant, what would happen if each ATM centre in Europe, when they put a software development bid out, were to stipulate that the licensing rule is that the sources should be available for the ATM centre to use as it pleased. At that point, resources from each centre could be cooperatively pooled to take the best of each development effort, and create the ultimate ATM system.

Today, the difference between OSS and Free Software is philosophical: Open source is about a development methodology, while Free Software is about license freedom. FLOSS copyright terms impact two orthogonal licensing issues: freedom for users, as discussed above, and a free development community. Some companies have tried to curtail developer freedom, like Apple's original APSL version 1 license. But the community will not invest its efforts into projects where their freedom is limited, and to be able to leverage communal development forces, Apple had to back off on the restrictions they could impose, in order to remain competitive in attracting developer community interest.

Four examples of FLOSS freedom:

  1. A third party unconnected with AdaCore took GNAT technology to produce a compiler for a radiation-hardened 32 bit chip. AdaCore has ended up competing with our own technology on this market.
  2. An independent tool vendor uses AdaCore technology to provide static runtime error detection for Ada. They built in-house expertise and support it themselves.
  3. A library with a 32 socket limitation (mainly for historical reasons) was a problem for one customer. They simply made the changes themselves, since they had the source code and the rights to modify it.
  4. A specific tool was needed by EUROCONTROL Brussels. To be cost-effective, this tool had to leverage AdaCore's compiler technology. AdaCore submitted a bid, but didn't get the job. It turned out that EUROCONTROL took a comparable bid from another vendor, just because they could: they weren't locked in.

FLOSS is an unqualified plus for the COTS customer, and helps the customer's of negotiating strength. Although the situation would be very different if free licenses had been the norm from the onset, customers should now lobby their vendors to at least release the source code to themselves, the customer. Optimally, the contract terms would require full FLOSS licensing of the development work. AdaCore is a poster child for the win-win opportunities for vendors and customers that FLOSS licensing offers.

A final note on patents: The discussion above has been based on copyright as the fundamental attribute for economic control of software. If US-type software patents are part of the game, the whole system collapses. At that point, a FLOSS implementation of a given software system could be blocked by the patent holder for the duration of the patent. From a practical point of view in the software field, that duration is eternity.


from 26'00" to 35'00" (9'00")

P. Kappertz: Can I get your software without paying anything?

F. Gasperoni: There are two answers: yes you can, but we don't have to. We could shut down the libre site, and simply provide for our customers only, but they could redistribute it.

The license that we used on our Libre software is made for people who do Free Software development. We call the libre version the GPL version. The license we've used on the Libre version, for a qualified, complete piece of software, is such that it's made for free software development.

It has some legal implications. If you're using it to develop open source components in Ada, then using GNAT Pro is great! Take the example of the trajectory system: you have that software, assuming it was written Ada, what you could do is put out the compiler for all the platforms you wanted to support on a web site, so that developers would not only have the software and the build procedures, but the tools to keep developing the way you did the development.

In order to focus on the free software, there is no reason for us to make it available for people who are not in the free software game. Our license is such that it is that when it is downloaded from the net, it is for free software or open source development.

H. Lueders: Concerning the financial model, how do you deal with variable levels of support requirements? Customer demand may differ from one moment to another, while the subscription model is a flat fee over the period. The fee also depends on the number of configurations or platforms you want supported, whether it is native (Linux, Solaris, ...) or embedded.

F. Gasperoni: Cost is based on the number of developers. The price is not the same for five users as it is for fifty. It goes up or down as your number of developers increases or decreases.

H. Lueders: Does this mean that in addition to the retainer fee there is an additional fee for specific services?

F. Gasperoni: No, the price is very simple. For example, you say: we support 28 configurations, we have 15 developers, and we want GNAT Pro for Solaris, HP/UX and Linux. Then you have a price based on your request. We have a matrix based on the number of users and configurations. Within this fee, there are an unlimited number of questions which may be serviced.

P. Johnson: How do you manage customers, so that they don't try to take advantage of a 'blank check'?

F. Gasperoni: We manage it in the following way. We sell a COTS product, so the customers can say, "How do I use it? What is the best way of using it?" There can be problem reports, we fix it and make it available in the next release.

It's true we have an unbounded number of questions. But there is a great disparity between customers. Some customers ask many questions at the beginning, then they build expertise inside, and they ask fewer questions. It all works out. It's a statistical way of handling it.

To put it in perspective, we're about a ten million dollar company. We have about 55 people working on both continents. So it's both a small organization, and a large organization. Out of the 55 people, about 45 are technical people, engineers, PhDs, people who have developed Ada. Since we're on two continents, we have the same IT needs as a large organization.

J. Feller: You talked about two types of monopolies created by proprietary licensing, one was a monopoly for creating a derivative work, the other for effectively supporting the product. The examples you gave as why AdaCore is not a monopoly, all are examples of companies creating derivative works. And that, for me, has nothing to do with your business model; it has to do with the license that you chose.

Without naming anybody, is there anyone competing with you for your core revenue model, that is to say, is there anyone out there receiving monthly subscriptions to answer questions about GNAT Pro?

F. Gasperoni: On the versions from which they branched off?

J. Feller: No, on your version.

F. Gasperoni: Not that I'm aware of. It could be, but you see, that's the beauty of the story. There are other examples where they customized versions of our software, but think about why. We keep our prices and our infrastructure to be cost-effective. If we were outrageously expensive, there would be loads of people out there.

J. Feller: I'm not so sure there would be.

F. Gasperoni: Why do you think so?

J. Feller: Because in practice that doesn't happen. If you've been sitting on the credentials of "we're the creators of this technology", and no one has stepped up to say, "well yes, but in the intervening decade I've achieved as much competence as they", then it's not a software licensing issue, it's something else going on there. There's a global community, why aren't there any experts outside of AdaCore?

F. Gasperoni: That's a fair statement, but you must realize that it's sort of a chicken-and-egg problem, because if we raised our prices outrageously, I can tell you we'd be out of business quickly, in a variety of ways, of which that one is a possibility.

There is a case in the community: wouldn't it be nice if AdaCore provided support for a single developer for 500 euro, but we know that isn't going to fly. And we said, "Fine, if somebody else wants to take it up, fine, we don't think that business will survive for a long time.

The fact of the matter is that we haven't seen much competition because it's tough to serve a very specific market, and a very technical market, at those types of prices.

Salient points

Franco Gasperoni

"FLOSS is an unqualified plus
for COTS customers"

Abstract Article Slides MP3 file OGG
abstract article slides MP3 OGG

AdaCore logo