How Google Uses and Contributes to Open Source

By

-

September 8, 2016

Engineer Marc Merlin has been working at Google since 2001 but has been involved with Linux since 1993, in its very early days. Since then, open source adoption has dramatically increased, but a new challenge is emerging: Not many companies care about the license side of open source, Merlin stated in his talk “How Google Uses and Contributes to Open Source” at LinuxCon and ContainerCon North America.

“There are companies and people who just take the software and say, “I didn’t have to pay for it. I can do anything I want. The license file is a big blob of text. I’m not going to read that,” Merlin said.

“If you get software that you didn’t have to pay for and you get a license with it that gives you a few things that you should be doing, then you should be respecting the license,” Merlin said.

Respect the license

In some cases, companies aren’t aware that their products contain open source code, or they’re not informed about how to comply with open source licenses. Although some companies are well informed about the licenses, they choose not to care for many reasons: They move to the next product, they are too small to be sued, or they are in a country where they can do whatever they want.

Regardless of the reasons companies don’t comply, license compliance is a complicated, but extremely important, issue. Google didn’t always get it right when it came to open source management, Merlin said, but their practices provide lessons that can benefit any company that needs to improve their open source compliance.

Evolution of open source at Google

Merlin said that he has moved many times within Google, because he gets bored. What he ends up doing is helping teams make sure that they do the right thing when it comes to using and contributing to open source.

Back in its early days, around 1998, Google was a small company. It was using open source just like any other small company. While Google was abiding by licences, they were not giving back much due to several reasons. “Some of it was just run fast and make sure that we have money next month to pay everyone’s salary,” said Merlin. Another fact was that Google was using very old versions of Linux. They had it frozen and whatever changes they were making were irrelevant to the current version of Linux, which was far ahead of what they were using.

In 2004, Chris DiBona joined Google to run the Open Source Program Office. “The whole point of the office is to help the company do the right thing, help engineers with their questions, and to make sure everyone plays by the rules,” said Merlin.

How you develop affects contributions

Google was working on so many different projects back then that it was — and still is — iterating fast.

“When you go fast, you just patch the source and move on to the next problem because things are on fire. It was difficult to get the patches part of it and contribute them,” said Merlin. There was no Git back then; those were CVS days, which made it even harder to keep track of source code.

In addition to using really old code, another problem was that most of what Google was working on internally was not designed to be open source at that time. There are very large internal libraries on which other projects depend. That made it hard to open source new things because you can’t just take one piece of it and open source it.

Go open source from the beginning

Google changed that by writing a lot of things from the ground up as open source or to be open source ready. That was a good lesson that they learned, and that’s a problem many companies face when they want to open source their stuff but can’t because the code was not designed to be open source from the beginning.

Even if Google can’t open source certain code, they found a way to bring that work to the public. “We wrote papers talking about the magic algorithm that we used. We can’t give you the code for the reason I just explained, but we’re giving you the way they work so you can rewrite them,” said Merlin. Google has published hundreds of such papers and people are using it to create projects based on those ideas.

Due to all these efforts, Google is today among the top 10 contributors to the Linux kernel. Google has hired many kernel developers and open source leaders, such as Andrew Morton, Theodore T’so, and Jeremy Allison who don’t do any work for Google; they work directly on Linux or their own projects. In addition, Google also has a team of kernel developers who write code for Google’s own needs.

Open source projects

Chrome and Android may be the biggest open source projects at Google, but there are several more open source projects. Google also encourages people to contribute to open source on their own time. Although many employer agreements define ownership of code written by their employees when it is in the same line of business, even on their own time, Google has a process where employees can get for ownership of code they wrote on their own time and hardware.

Merlin said that Google has set up a process whereby the company can disclaim that code and give it back to that employee, or Google can just approve and release that without having to go through the company. Google is also encouraging employees to use their Google email so that their contributions are more visible.

Google has internal bonus programs for employees to encourage them when they do something good, and people thought the company should do something similar for open source.

“We now have an internal program where we can nominate open source projects that may be one or two people — not a huge group — and could benefit from having a bit of extra hardware or extra money,” Merlin said.

Open source licenses

Licenses play a critical role when companies like Google choose to contribute to projects. Just because a project is open source doesn’t mean Google employees can freely contribute to it.

“There are open source licenses that are problematic,” said Merlin. “There are some licenses that are not probably not legal licenses at all, at least in some countries.” In such cases, employees are asked not to work on that as employees. “If they insist on working on that project, we give them the right. We disclaim all their work and say ‘that’s not Google work, this is you as a person’. And then they do what they want with that project.”

There are cases where projects don’t have any licenses. “Sometimes we have to contact the project owners and tell them that their project doesn’t have a license. We’d like to contribute to it, but until you do, we can’t.” That helps those projects fix licenses and allows Google employees to contribute to such projects.

Patch submission is a tricky area, too. If the code is on GitHub, then that’s easy, but patch submission through email needs extra work. “We like to know what’s the project. What license that project is, we have a quick look at it and we’ll just tell them if it’s OK or not OK to contribute to that project,” said Merlin.

Other ways Google gives back

Code contribution is not the only way Google is giving back. The company sponsors many open source and Linux-related events. It also sponsors organizations like Free Software Foundation and Software Freedom Conservancy and projects like OpenSSL.

At the same time, Google also gives back by creating platforms when needed; Code@Google is a good example. When Google saw that SourceForge was becoming questionable, they set up code.google.com to give a platform to developers until GitHub popped up and became the new de facto platform for open source development.

Now virtually all of Google’s open source code is on GitHub, except for Android. “The Android distribution is so big and it gets released in big chunks. So, when it gets released, everyone wants to sync that,” Merlin said. “It’s so huge that if we put it on GitHub, it would completely kill GitHub. We use our own mirrors for that, to help out.”

Google also runs programs that expose students to open source, they also try to encourage more women to get into the field.

Then, there is Google Summer of Code for students. “Instead of going to work for McDonald’s in the summer to make money, which would be a waste of their brain power, we basically take submissions for them to work on open source projects,” said Merlin. “They get a mentor. If they do well, they get a stipend to pay for their time and allow them to work and pay their college bills, whatever that summer job money was going to be for.”

Dealing with licenses

Companies have to be extremely careful when using open source. Different projects use different licenses, and you need to be in compliance with them. To ensure that people don’t make mistakes, “we have an internal policy that you cannot use any open source at Google, unless it goes in a separate, third party hierarchy, and each of them has directories with the license of each project,” Merlin said. So, when you include your library, you know what license it is and you can easily check that. You can’t use open source if you do not follow that process. You cannot take code and paste it.”

Things become complicated when you have projects that you ship. In the case of open source, you need to list the projects that you use and their licenses. In the case of BSD and MIT, you need to list the name and the copyright of the person you got that project from. That can be a bit annoying, he said, as “you actually have to go and find every project, scan their license, find their name or the copyright line, and credit them. Otherwise, we’re not compliant with the BSD or MIT license.”

Google has to be extremely careful when they buy a company. They may not have their code in compliance. Merlin said sometimes Google actually passes on companies because they’re totally not compliant, and to bring them into compliance is not going to be possible.

What license does Google prefer?

Google uses Apache 2 by default. “The main reason is that it offers a patent license to the user. If you get code from us, under Apache 2, that means you get a grant to any patent that applies to the code that you just got from us,” said Merlin. That’s not true of GPLv2, though GPLv3 now does add a patent grant. However, GPLv3 has added a clause that prevents device manufacturers from restructuring reflashing devices, which is not an ideal solution for some companies.

Merlin mentioned that they can’t contribute to WTFPL licenses, and sometimes projects don’t change the license but are willing to dual license and although it’s not ideal it’s good enough for contribution. But, he also warned that dual licenses also can be trouble and suggested avoiding them. “Once you receive a patch, it’s unclear under which license that patch is received or if it’s under both licenses.”

Talking about even freer licenses, Merlin said that while CC Zero is a proper license, it requires you to give up all your rights to the code to which you just contributed.

What about CLAs?

Contributor License Agreements (CLAs) themselves don’t mean anything; they are just legal agreements. There can be very bad legal agreements that you should never sign, or it may be completely safe. The problem is that you have to review CLAs on a case-by-case basis.

Google uses the Apache foundation ICLA, without modifying it or putting anything special in it. CLAs ensure that companies like Google “can re-license your code under a different open source (license) if we need to. Sometimes we need to merge with other projects and that’s what the CLA allows us to do,” said Merlin.

Google employees are not allowed to sign a CLA for another company before it has been reviewed. Merlin said that most projects would be better off using Apache CLA. He shared an example of a project that he once contributed to and then the project decided to re-license it and they had to contact every single person who ever contributed a patch. Those people had to print a form, sign it, and fax it back within 10 days. It was a huge amount of wasted effort for them. Apache CLA takes care of it and makes your project future proof.

Merlin also warned about not using AGPL, as no one knows where it stops; it’s just way too broad, he said.

Conclusion

Merlin’s description of Google’s open source story highlighted how meticulous is the process needs to be to get open source right. The best part is that all these changes and motivations came from within the company. Through their efforts, they became one of the top contributors to Linux and created two dominant Linux-based operating systems in the consumer space. That’s a good open source story. Google it!

You won’t want to miss the stellar lineup of keynotes, 185+ sessions and plenty of extracurricular events for networking at LinuxCon + ContainerCon Europe in Berlin. Secure your spot before it’s too late! Register now.

DevOps Done Right: The Operations Dividend

By

Carla Schroder

-

September 8, 2016

Containers and cloud native are great technologies, but what is the larger business context? Why should the pointy-haired bosses care? Joe Beda of Accel Partners described the tremendous business value of DevOps done right in his keynote presentation at LinuxCon North America in August.

Does anyone really know what DevOps is? Some call it “Group therapy for large corporations.” But Beda says that when DevOps is done right it’s a way of structuring your organization for greater efficiency, better coordination between operations and development, and greater speed in rolling out services and improvements.

Beda’s talk began with DevOps gone wrong: “I think we’ve all seen this dysfunctional organization where really it’s one team is from Mars, one team is from Venus, I’m not sure which is which, and they really don’t get along. So you hire some expensive consulting firm and you do some trust fall and ropes courses and everybody’s happy again.”

DevOps done right, on the other hand, accelerates development, deployment, and improvements, and lowers the costs of providing services. It improves the relationships between application developers and how applications are pushed into production and operated. Beda said, “It is no longer acceptable for a development team to not care about how their stuff runs in production. Similarly, it’s no longer acceptable for an operations team to just let something happen and say, “Oh well, put that in a playbook, we’ll deal with it next time.” They have to take their knowledge, their learning, and they have to plow that back into the development cycle so the application becomes more and more operable over time.”

The key is to take the classic engineering approach of breaking large problems into small problems, solving them, and using and re-using them as building blocks to solve the larger problems. Using small independent teams is also key, as larger teams don’t necessarily accomplish more. “Jeff Bezos has the saying that if any meeting is so large that you can’t feed everyone with two pizzas it’s probably too large. That’s the two pizza rule. A lot of folks, and I think it’s a good idea, have also applied that two pizza rule to development teams,” said Beda.

“As you add that extra person you have more relationships that you need to manage, more lines of communication to keep open, and it’s more difficult for that development team to gel and be effective. It really makes sense to keep those teams small, keep those teams independent,” he continued.

DevOps done right has tremendous business value. Beda explained that “This is what I’m calling the Operations Dividend. If we make operations that much easier, that much less work, and we make those teams that much more efficient you’re going to have excess capacity, and it’s up to you to decide what you want to do with that capacity.” See the complete keynote video below.

https://www.youtube.com/watch?v=nMLyr8q5AWE?list=PLbzoR-pLrL6qBYLdrGWFHbsolIdJIjLnN

You won’t want to miss the stellar lineup of keynotes, 185+ sessions and plenty of extracurricular events for networking at LinuxCon + ContainerCon Europe, Oct. 4-6 in Berlin. Secure your spot before it’s too late! Register now.

LibreOffice Suite Now Competes Directly with Google Docs

By

Sam Dean

-

September 8, 2016

On the heels of announcing new versions 5.2 and 5.1.5 of the free, LibreOffice suite of productivity applications, The Document Foundation has provided statistics indicating that LibreOffice is gaining traction with Linux users, developers, administrators, and enterprises. In fact, the new version 5.1.5 of the suite is specifically tuned for enterprise users.

The Document Foundation’s Annual Report notes that the LibreOffice project now has more than 1,000 contributors with 300 making commits in 2015. Moreover, new releases of the suite include enhanced focus on compatibility and standards. The suite’s import/export filters have improved exponentially, and — in a move that will appeal to many admins and cloud-minded users — the suite has been steadily adding direct integration with platforms and services including Google Drive, SharePoint, and Alfresco. You can now open files directly from — and save files to — these services via menu choices under the File menu in LibreOffice applications.

Integration with these platforms and services, of course, means that LibreOffice is now much more competitive with Google Docs. Additionally, as security concerns remain on everyone’s radar, The Document Foundation is working closely with the Transglobal Secure Collaboration Program (TSCP), a public-private partnership formed to secure electronic communication for organizations including defense contractors and government entities. The TSCP has specifications and frameworks that preserve more secure shared documents online. LibreOffice 5.2 complies with these document classification specifications.

In LibreOffice 5.2, documents can be classified into categories (e.g., “Confidential”) according to TSCP standards. Additionally, multiple digital signatures and descriptions are now supported, along with import and export of signatures from OOXML files.

The Ubuntu Connection

LibreOffice is, of course, familiar to many Linux users, especially Ubuntu users. After all, the suite has been the default office suite of the Ubuntu OS for years, and it runs fluidly on Ubuntu tablets as well. And, Ubuntu is among the most popular platforms on which to build OpenStack deployments. On the Ubuntu front, The Document Foundation has also recently announced that Canonical, Ubuntu’s parent, has joined its Advisory Board.

The Document Foundation recently clarified that LibreOffice is now on a six-month cycle for major releases, to keep it in step with other open source projects, including OpenStack and Ubuntu. Canonical’s participation on The Documents Foundation’s Advisory Board will help inform and enforce this release schedule.

Of course, LibreOffice, like Google Docs, takes criticism on some fronts for not being fully compatible with Microsoft Office formats and standards. In fact, you can find lively debates on this topic online. The new releases, though, are much more compatible with them. For example, changes to the formula engine within LibreOffice’s Calc spreadsheet app remove restrictions on table structure references in cells. The upshot of this is that the spreadsheet application has better interoperability with other applications, especially Microsoft Excel.

In what could be a very critical next step in encouraging more adoption of LibreOffice, The Document Foundation is developing mobile versions of the LibreOffice applications for Android and Apple iOS devices. These will extend well beyond the limited, document “viewer” applications that you can get now. The full-featured mobile versions will likely integrate directly with popular cloud services, giving users full access to documents and content on the go.

In significant ways, LibreOffice is emerging as a viable competitor to both Microsoft’s productivity application suite and Google Docs. It’s also gaining traction in some notable global organizations. For example, a huge branch of the Italian government has switched from Microsoft Office to LibreOffice, and the UK government has made similar moves.

Keynote: The Operations Dividend – Joe Beda

By

The Linux Foundation

-

September 8, 2016

https://www.youtube.com/watch?v=nMLyr8q5AWE?list=PLbzoR-pLrL6qBYLdrGWFHbsolIdJIjLnN

Containers and Cloud Native are great technology, but what is the larger business context? Why should the pointy haired bosses care? In this talk, based on 10 years at Google, Joe makes a case for redefining roles to increase product velocity.

IBM Launches New Linux, Power8, OpenPower Systems

By

ZDNet

-

September 8, 2016

IBM on Thursday rolled out its latest Power8 processor, which is designed to move data faster, and new servers with OpenPower features. For IBM, the OpenPower Foundation community is critical for its Power8 processor. A bevy of companies are in OpenPower, a group that aims to be a counterweight to x86-based servers.

With the new systems, IBM is hoping to target more artificial intelligence, analytics, and deep learning workloads.

Kali Linux 2016.2 Delivers New Security Testing Options

By

eWeek

-

September 8, 2016

A year ago, Kali Linux moved to a rolling release cycle in an effort to provide a continuous stream of application updates. Kali Linux is a popular open-source Linux distribution for security professionals, loaded with a growing list of tools for information gathering, vulnerability analysis, web application analysis, database assessment, password attacks, wireless attacks and reverse engineering. Despite Kali Linux’s rolling release cycle, it still puts out milestone releases as a roll-up omnibus of changes made over a period of time. The Kali 2016.2 milestone was released Aug. 31.

The Orange Pi: Linux on Quad Core for Under $20

By

-

September 8, 2016

The Orange Pi series of machines lets you run a small Linux machine dedicated to a specific task for a very attractive price — less than $20 for setup. Some ideas for using an Orange Pi include adding network connectivity to an older printer, transcoding a USB webcam and sending it over the network, or just connecting some hardware to the 40 pins and being able to interface to chips faster than a microcontroller could.

The Orange Pi One is a credit card sized quad-core ARM machine that sells for about $13, including shipping (Figure 1). You will have to buy a 5-volt wall plug and bring your own micro SD card, but the total cost should still be under $20. Many people are familiar with the popular Raspberry Pi offerings that have brought the cost of ARM machines to below $50. Now, the entry price for a Linux machine with Ethernet and HDMI has dropped to under $20.

A range of Orange Pi machines gives you the option to include WiFi, put some flash storage on board, and pick how much RAM you want, depending on how much you need to spend for the task at hand. In this article, I’ll look at the Orange Pi One, which has a quad core A7 ARM CPU, 512MB of RAM, 100Mbit Ethernet, two USB ports (one On The Go), HDMI output, and a micro SD card slot to boot from. There is also a camera interface on the back of the board and a row of 40 pins (apparently compatible with Raspberry Pi B+) for hardware tinkering. You’ll also find a range of distribution choices for the Orange Pi One, including Fedora, Debian, Ubuntu, Raspian, OpenSUSE, Arch, and Android.

Hardware IO

The Debian 8.1 image I used had Linux kernel version 3.4.39. Without doing anything with modules, I noticed two TWI interfaces at /dev/i2c-0 and /dev/i2c-1 and a SPI at /dev/spidev0.0. There was no GPIO interface in /sys/class by default. It seems there is some sort of mix up in the version strings for the gpio-sunxi kernel module, but after doing modprobe -f gpio-sunxi, I could see a filesystem tree at /sys/class/gpio_sw.

The pin out information shows two 5-volt outputs next to a ground at the end of a single row of pins. The pin next to the 5 volts at the end is a 3.3 volt pin. A little probing with a multimeter revealed a setup with 5 volt outputs on the Orange Pi One on the inner side (not the edge of the board) at the end farthest away from the network connector.

To test GPIO, I hooked up an LED with resistor in series to the ground and the GPIO pin next to the ground. It seems the GPIO pin should be GPIO 14 — or pin 8 using physical numbering. I found this pin to be PA13, and I could turn the LED on and off using the following commands. This supplied power to the GPIO when set to 1, and with the other end of the small circuit attached to ground allowed the LED to glow.

root@OrangePI:~ # echo 1 > /sys/class/gpio_sw/PA13/data
root@OrangePI:~ # echo 0 > /sys/class/gpio_sw/PA13/data

Performance

Because the Orange Pi One uses a micro SD card to boot from storage, performance will depend on the quality of the card you use. I used a cheap card I had lying around; with it, extracting openssl-1.0.1e.tar.gz took about 0.6 seconds. Compiling openSSL took a little more than 6 minutes. The OpenSSL speed benchmark is a single core test, which you should keep in mind if a machine has 4 or 8 cores and another only has one core. It is interesting how well the Orange Pi One keeps up with the Raspberry Pi 2 in the digest and cipher tests (Figures 2 and 3).

Unfortunately, I couldn’t get Octane to run on the Orange Pi One. Both iceweasel version 38.8.0esr-1~deb8u1 and firefox-esr version 45.3.0esr-1~deb8u1 closed part way through the test. I suspect this is due to the machine running low on RAM and electing to kill the browser process.

To test 2D graphics performance, I used version 1.0.1 of the Cairo Performance Demos. The gears test runs three turning gears; chart runs four line graphs; the fish test is a simulated fish tank with many fish swimming around; and gradient is a filled curved edged path that moves around the screen. For comparison, I used a desktop machine running an Intel 2600K CPU with an Nvidia GTX 570 card that drives two screens — one at 2560×1440 and the other at 1080p.

`Test`	`Radxa at 1080`	`Beagle Bone Black at 720`	`Mars LVDS at 768`	`Desktop -- two screens`	`Rasp Pi 2 at 1080`	`CuBox i4Pro at 1080`	`Orange Pi One at 1080`
`gears`	`29`	`26`	`18`	`140`	`21.5`	`15.25`	`19`
`chart`	`3`	`2`	`2`	`16`	`1.7`	`3.1`	`2.4`
`fish`	`3`	`4`	`0.3`	`188`	`1.6`	`2`	`2.2`
`gradient`	`12`	`10`	`17`	`117`	`9.6`	`9.7`	`10.49`

The memory bandwidth benchmark copies an array of data using different methods and reports how quickly such a copy can be performed for a given size array. Because the test requires me to allocate two arrays in memory of the nominated size, I chose 64MB as the array size in order to fully fit the entire test into the RAM on the Orange Pi One.

Testing this way required a little over 134,217,728 bytes of memory to be allocated by the test. I have included a desktop Core i7 machine for comparison. You can see that the Orange Pi One has a noticeable speed advantage over the Raspberry Pi 2 in all bandwidth tests.

Test	Orange Pi One (MiB/s)	Raspberry Pi 2 (MiB/s)	Intel i7 2600 (MiB/s)
memcpy	426.872	322.477	3031.351
dump	843.550	552.171	6035.288
mcblock	726.389	590.180	8347.899

As a real world raw CPU test, I downloaded the Linux kernel version linux-4.7.2.tar.xz and uncompressed it. The pbzip2 command will compress data using as many CPU cores as the machine has. I supplied the -9 option to select the best compression during the test. The Intel Core i7 took 12 seconds to complete; this was assisted by the entire archive being in the disk cache. The Orange Pi One took 3 minutes and 45 seconds, with the Raspberry Pi 2 needing 3 minutes and 41 seconds. The micro SD card I used for storage on the Raspberry Pi 2 was much better than what I used for the Orange Pi One, although I think this test is purely CPU bound.

Power

During boot, power usage spiked to about 4 watts, then dropped to a steady 3.3 watts at the text console. Starting an X window server at 1080p moved power to around 3.4 watts at idle. All these readings are with a keyboard, hub, and mouse connected. Building OpenSSL with four jobs ramped power up to 5.4 watts. Running a single openssl speed job consumed 3.9 watts, and running glxgears took around 4.1 watts.

Final Words

You are probably unwilling to spend $50 to set up a printer server, but maybe the $20 price tag of the Orange Pi tips the price to convenience ratio in favor of the latter. Performance is surprisingly good for such a low price point. Cairo graphics performance was around the same as for a Raspberry Pi 2. The memory bandwidth test showed the Orange Pi One to be quite a bit faster than the Raspberry Pi 2. The bzip2 compression was neck and neck.

Additionally, playback from YouTube did not seem to be hardware accelerated. Further investigation is needed to see if this situation can be improved and what video formats can be decoded in hardware on the Orange Pi series.

Machine Learning: The Bigger Picture, Part I

By

D Zone

-

September 8, 2016

In the past few decades, computer systems have achieved a whole lot. They have managed to organize and catalog the information produced by our civilization as a whole. They have relieved us from stringent cognitive tasks and increased our productivity significantly. One could say that where the industrial revolution automated labor, the digital revolution has automated cognitive labor. This statement isn’t entirely correct however, if it was we would all be without a job. So what can humans do that machines can’t?

The classic computer system can be seen as a big information switching network that directs information to where it needs to go. A good example of such a system is SAGE, one of the very first and largest computers ever built. The SAGE computer system was built during the cold war for the sole task of integrating all information from radar systems across the United States for defense purposes.

Hybrid Cloud Isn’t Cloudy Enough, Suggests New Forrester Data

By

Tech Republic

-

September 8, 2016

It hasn’t been a good year for the private cloud, and the Forrester Wave for Global Public Cloud Platforms isn’t going to make it any better. With Forresteracknowledging it had previously under-projected the torrid growth of public cloud spending—the new total 23% higher at $236 billion by 2020—the private cloud remains the province of “suckers.”

Indeed, nowhere is this more evident than in looking at Forrester’s scoring for the would-be heirs to the AWS cloud throne. As comes out in the chart and throughout the report, the more enterprise incumbents like IBM focus on a hybrid approach to cloud, the more they fall behind.

Hyperledger’s Executive Director Brian Behlendorf on Strategy, Goals and Growth

By

Bitcoin Magazine

-

September 8, 2016

The Hyperledger Project, a collaborative cross-industry effort to advance blockchain technology led by The Linux Foundation, announced that 17 new organizations have joined to help create an open standard for distributed ledgers for a new generation of transactional applications. The project now has more than 80 members, which represents a growth of 170 percent in the last six months.

“There’s been a tremendous response to our vision for creating an open community for blockchain technology and we’re proud to be celebrating this member milestone,” said Brian Behlendorf, executive director of Hyperledger Project, in an announcement which includes a list of the new companies that have joined the project.

Behlendorf doesn’t think Bitcoin will fade out and be replaced by permissioned blockchains. “Permissioned chains do not solve all the interesting problems out there,” he commented. “I think Bitcoin, Ethereum, and other cryptocurrency and distributed application platforms have a long, bright future.