I’ve been kindly invited to give a keynote to openSUSE Summit in Orlando and I just got off the stage after delivering it. The slides and my notes are below. The video I took during the keynote is on YouTube (and embedded).
openSuse keynote: The lessons of Open Source for the Open Cloud
Thank you Suse community for having me here today. It’s my turn to wake you up today, so let’s start. I want to start by telling you that we have accomplished a mission
The mission to build a wholly/holy free operating system for servers and desktops is accomplished. I believe the Free/Libre Software and Open Source (FLOSS) movement has conquered the datacenters, replacing proprietary systems everywhere. This is good, right?
While we were busy winning over the proprietary Unix, proprietary databases etc things changed. We’re in the middle of a radical change of how we think of computing. Cloud and mobile computing have emerged as radically new things. And for the first time ever, Open Source implementations are not lagging behind, quite the opposite. Open source software is opening new paths, not just building on top of a fully laid out Unix or the standard C libraries. Open Source is where a lot new things are happening regarding cloud and mobile computing.
While I believe in mobile computing the Open Source principles are fairly easy to adapt, cloud computing poses a whole new set of questions for the movement.
We’re missing a paradigm to interpret and define open-ness in cloud computing.
In the minutes we’ll be looking at lessons learned during +25 years of Open Source and how those can be adapted to define the Open Cloud and at what we can do to see this idea materialise.
First of all I’d like to recognize where we stand, in terms of achievements of the past 25 years. I think we’ve done great so far.
When I started working on Open Source and Linux the system was 5 years old, GNU tools had been around for 10 years. To convince customers to buy our Linux distributions I had to start from scratch.. Well, Linux is made by smart people around the world, loosely coordinated by a Finnish dude wearing sandals. Unbelievable, right? Their objections are probably familiar to you too right? you may have been in one of these sales meetings.
If I passed that first step, I had to show that our small team of 10 people could support them… and that opened a whole new set of problems… You can imagine how fast our little startup could close a deal 🙂 Today’s meeting are more normal, Dilbert style.
Look around today how things have changed.
Today nobody asks ‘Does it work?’ but they ask ‘how fast can you get it here and solve my problems’. And to start a new venture, developing free software is one of the mainstream options.
We won! GNU and Linux have taken over the proprietary systems they were designed to take over. Open Source has even opened complete new ways to do things, think of Big Data and NoSQL … all ideas empowered, enabled even, by the freedom to tinker that comes with free/libre software. It’s the freedom to make, the freedom to innovate.
Our way of developing software has won, too. You know that dude with long hair and long beard from Boston that started a movement, loosely coordinating hundreds of developers around the world? Turns out, he started something very big, much bigger than an operating system “like Unix but better”. His idea to ask the best brains in the world to help produce the best software possible and share the results together, is good for companies too. They get new products much faster, better performing, they get marketing, support you name it…
Business schools have studied how we make software, companies have learned that what we have been doing since the 90s. Now a whole new line of research focusing on how firms around the world pool in resources to develop new products faster and share the benefits. They call this ‘Open Innovation’, we call it ‘The Open Source Way’.
When you started working on open source, were you expecting that your work would spur such radical change? To be honest, I’m still surprised but I was hoping for it, I’m a dreamer 🙂
Let me give you an example of how ‘Open Innovation’ the open source way worked for OpenStack, the project I work for. The project started two years ago, NASA and Rackspace were trying to solve the same problem: they needed an operating system that run on top of an entire datacenter. Virtualization is not enough once you reach the ‘HUGE’ scale. Once your virtual servers start to be thousands, thens of thousands you start loosing track of what runs where and you have all sorts of other problems. NASA and Rackspace found each other by chance and decided to pool their resources. Rackspace had a very good object storage system (now known as SWIFT), NASA had a promising prototype of a virtual computing engine (known as NOVA). Deal done. Time 6 months and look at the spectacular growth in number of active developers per month: that’s comparable with the Linux kernel (not in quantity, but in slope). The amount of companies joining it, the partners in the newly established OpenStack Foundation.
I believe we, the free software and open source movement should be very proud of what we’ve accomplished so far. We, as a movement, should take a moment to sit back and appreciate what we’ve achieved in the past 25 years. Our principles, our way of doing things, has made OpenStack possible.
VIDEO THING: On my three, you’re going to yell “Welcome OpenStack” and I’ll record it on camera, ok?
Celebrate the achievements of our movement and let’s move on: we need a way to define openness for the next generation of computing.
The principles that gave us GNU and Linux were designed in a time when Unix was the dominant paradigm for computing: terminals and later client/server. One processor, one operating system. A world made of ‘computing products’.
In the late 80s and 90s, when Stallman started the GNU project and Torvalds started Linux the there was a world made of computing ‘products’. Today we’ve added computing ‘services’ to the mix.
Cloud Computing blurs the lines of what is a ‘user’ and what is a distribution and copies of software. Porting the Free Software definition from a product to a service is not simple but we can try.
How to define the Open Cloud
Let’s have a look at the free software definition, simple and elegant. Software is free/libre when it comes with:
- 0 freedom to run for any purpose
- 1 freedom to study how it works
- 2 freedom to make copies to help you and your friends (and charge for the act of making one)
- 3 freedom to distribute modified copies
We have now understood all of this, for computing products. It makes sense: software comes on a CDrom, a USB stick, downloaded,…whatever, you take something and you run it on your machine.
Now look at services you consume over a network: do you Run the software? If you consume a platform as a service, do you need to study the details below or just the APIs it exposes? The APIs are free to study, usually. Make copies? You don’t need to really to: if you need more capacity you buy more of the service. Do you really want to modify services? Maybe you want to be able to add features, ok … but does it make sense to use a service if you need features it lacks?
Don’t get me wrong: these freedoms are crucial, necessary even, but not enough. Computing services are radically different, the use cases are so much different. For example:
Data for example is out of the picture in the Free Software Definition. Let’s be concrete and take an example: San Diego Super Computing Center stores petabytes of data every year for its users (astronomers, physicists, etc). They need a storage and archival system that deals with that scale. Their users don’t … let me say better: can’t deal with that scale. The physicist running an experiment can have a few machines and disks to analyze a few terabytes locally but when it comes to handling large quantities of data, and backups, the single lab would have huge costs to run its own storage/backup system. So SDSC came up with an OpenStack Swift cluster where users can drop files at will. Now if those users want to stop using SDSC services and move somewhere else, in theory they can. They run OpenStack Swift, they have the 4 freedoms, the can replicate the cluster somewhere else or have someone else run the cluster for them. But their petabytes of data will be very hard to move across clusters. These guys know the format in which the data is stored into, so you can argue it would just be a matter of time…
That’s why I maintain that the four freedoms are important but data in the cloud changes everything and Scale changes everything. Keeping this in mind, we can start defining the Open Cloud.
We can take from the basic principles that guided Stallman in his definition of free/libre software. The 4 freedoms were designed to help developers help each others to innovate faster and help users get better tools for their tasks. Those are good things, they brought us to were we stand today as we saw before.
We can write principles for the Open Cloud that map the same ideals: respect the users of the service, enable innovation (or don’t reinvent the wheel).
How do you respect the users? Leaving them free to come and go in and out of your computing services. Nothing more or less than the freedom to run the software for any purpose, study, make copies and modify them. How can you come and go from a cloud service to another?
So here is the first thing that’s important to define an open cloud. We’ve got data on one side, and we’ve got functionalities to transform and manipulate that data, in the cloud as services.
The format of the data must be an open standard. Interfaces/APIs are another crucial piece of an open cloud, these must also be an open standard.
The other thing is that you need to enable Open Innovation, create vibrant communities and business friendly ecosystem.
The issue is that a uniform definition of Open Standard doesn’t exist but I like the one maintained by the FSFE. An Open Standard refers to a format or protocol that is:
- subject to full public assessment and use without constraints in a manner equally available to all parties;
- without any components or extensions that have dependencies on formats or protocols that do not meet the definition of an Open Standard themselves;
- free from legal or technical clauses that limit its utilisation by any party or in any business model;
- managed and further developed independently of any single vendor in a process open to the equal participation of competitors and third parties;
- available in multiple complete implementations by competing vendors, or as a complete implementation equally available to all parties.
And that’s how you respect your users. How do you enable innovation? Creating vibrant communities and large, business friendly, ecosystems.
It’s important for an open cloud to focus on both aspects: guarantee user’s independence from a particular implementation of a service and a vast business ecosystem that implements its open standards.
The issue is complex and definitely needs more thoughts. Stallman had it very simple: he needed to build a new operating system, like Unix but better. There was a model to follow, standards to implement like POSIX and C. GNU and Linux and much more software distributed as Free Software was imitating and improving upon existing software, at least initially. The guiding principles were easy to understand and communicate. His principles spread fast crossing the border of software.
Open Source is not behind the proprietary leader, we have a good chance to build the largest clouds based on our principles of respect and innovation. The race just started. Amazon Web Services was launched in 2006, it’s only 6 years old. Eucalyptus was first released in 2008, OpenStack in 2010 like cloud.com. Open Source implementations have a very good chance at taking the lead in cloud computing.
That’s what we’re trying to do at OpenStack Foundation. You can join it as an Individual Member.
We may not have a moral authority that will keep the definition for Open Cloud, like the FSF and the OSI have done for the world of computing products. It’s up to us to keep an eye on the companies we work for, helping them to understand that staying close to the principles that made Open Source ubiquitous is good for them, also in the world of computing services.
We’ve made it: we changed computing once. Now we just have to do it again. Thank you