Why I think you can contribute to quantum computing. Thoughts after FOSDEM 2019
Updated: Aug 9, 2019
On 2nd and 3rd February 2019 I attended FOSDEM in Brussels — it’s the biggest open source conference in Europe. This year, thanks to the hard work of a couple of people (namely Mark Fingerhuth, Tomas Babej and Peter Wittek) we had a quantum computing track, with two days densely packed with high-quality talks and workshops. If you would like to learn more about the event itself, here is a nice summary.
In this blog post, I would like to tell you about my thoughts and observations about the quantum computing community in general and open source QC community in particular. If at this point you think „Oh, but I’m not a part of this community. I’m not even sure what this whole quantum computing is about. There won’t be anything interesting for me in this blog post” — well… you might be surprised!
One thing before we start — OS stands for „open source” and QC for „quantum computing.”
The QC community landscape
This is a topic for a whole other article, so out of necessity I will simplify and generalize. Below is a list of some players/communities I’m aware of:
- Established companies building communities around their platforms: IBM, Rigetti, Xanadu.
- Other big companies that are less active in building communities: Google, Microsoft, D-Wave.
- Smaller organizations trying to build their communities.
- Local groups organizing meetups — in London, NY, Warsaw and many others.
To give you some sense of scale, these are the sizes of some of these communities:
- Rigetti: Slack: 2150 people, Contributors to the code: 57
- IBM: Slack: 3900, Contributors to the code: around 100 (maybe more - hard to say exactly)
- Warsaw QC Group: Facebook group: 412, number of people attending meetups: around 100,
- estimated number of people working professionally in QC is just a couple of thousands (and it’s closer to 2,000 than to 8,000).
There is one important point to be made — this doesn’t take into account communities that are purely academic . Of course, people on universities have been doing QC research for the last 20-30 years, but right now we observe the rise of new, non-academic, communities. Since QC is no longer limited to academia, it’s much easier to get into the field and this is why I focus on these new communities in this blogpost.
QC OS projects
When it comes to major players like Google, IBM, Rigetti, D-Wave or Xanadu, they produce a lot of open source stuff. Of course, not everything — they also have a part of their code closed and that’s fine.
Projects like pyQuil, Qiskit or Strawberry Fields are managed and developed by professionals working at these companies. But since they are open source, anyone can inspect the code, understand it, and contribute. These projects are usually connected to specific platforms/hardware created by a given company (but not always, e.g. Penny Lane ), but there are also supplementary tools, compilers or simulators (some examples here).
But there are also small, independent projects developed by individuals or small teams. Some of them are developed by academics in cooperation with universities, others are private initiatives. They cover a wide range of topics: simulators, algorithms, compilers, games, cryptography, education, communication, and many others.There are a couple of reasons why you might be interested in quantum computing:
1. It’s interesting — QC is such a new way of looking at computing that it’s a fascinating topic on its own. I know it’s subjective, but this novelty is something that attracts a lot of people I talked to.
2. It’s truly interdisciplinary — it blends different aspects of physics, computer science and engineering.
3. The potential applications are mind-boggling — designing new materials, improving machine learning and who knows what more.
4. This is a very young field and a single person can have a huge impact here. You can only discover something once and there is plenty to discover!
Let’s focus on the last point. Given the size of the community — a couple of thousands of people — your actions can really make a difference. It really struck me when I was talking with people from Xanadu when I first met them. After their talk, I had many questions — „Have you tried this algorithm?”, „What about different parameters?”, „How does it work on bigger graphs?”. Their answer was „Great questions. We didn’t have time to do all this, but feel free to do so!”
And most of the time I was talking with researchers doing quantum computing I got the same answer: „No one has checked this yet. Why don’t you try?.”
So looking solely on the research part (and I think this is something the majority of people in the industry are doing, and of course, so does the academia), there is so much to do! If you want to start a research project, but you’re unsure what would be a good project to do, you can write me an e-mail — I have plenty of ideas, but not enough time ;)
But it’s actually not that hard to figure out that you need to do a lot of research in quantum computing. What’s harder to see is that there is plenty of other work to do where different skillsets are needed.
Problems of the community
Some main problems of the QC community in general I see, are:
1. It’s pretty small.
2. It’s homogenous (there is not a whole lot of diversity among people).
3. Quantum computers as a technology are in their infancy and they simply don’t work well enough to do anything useful (yet!).
4. We use pretty hermetic language.
Ad 1. The point of view I’m most familiar with is through the lens of algorithms development. I see that there are not enough researchers working on these topics and not enough people implementing these algorithms and trying to apply them to real-life problems. I’m sure the situation is similar in other domains of QC.
Ad 2. Homogeneity has its pluses — it’s easy to communicate within the community and people have a similar way of thinking. But there are also downsides — the language used inside the group tends to be hermetic, people have limited perspective and since in this case, most people have a similar background, their skills are also not very diverse. This limits our ability to come up with novel solutions.
Ad 3. It might be discouraging to work on something that doesn’t work and won’t work for another couple of years. I mean — the machines we have do work, but it’s hard to say when they will work well enough to have some real-world application.
Ad 4. The language of QC is the language of physicists. Even worse, it’s the language of a subset of physicists — quantum ones. It’s hard to understand for people with other backgrounds and it might be a huge barrier for newcomers.
I’m not a scientist. Is it a place for me?
As I pointed out earlier, the community is rather homogenous and small. Most of the people are scientists/researchers/something like this. What if you’re not? Is there a way for you to contribute?
Of course! You might even have more of an impact, since there are not that many people with your skills.
I would like to give you some ideas about what you can do with various skills. I’m a science/software person so non-software categories might be somewhat neglected, but I tried my best. Some of these are very basic, some might be significant, but as I will explain in the next section, all are important.
No particular skills
- Read the description of a project and try to make it more human-readable
- Let’s say you have just started learning pyQuil. Be an active member of this community! Sign up on Slack, ask questions and more importantly, help the others out!
- Find Wikipedia pages related to QC and check if some pieces of information are not outdated. And believe me — a lot of that is outdated. Plus, you can edit/add Wikipedia in other languages than English, if you know them.
- Many projects could benefit from a simple web demo of its capabilities. A demo that doesn’t need an installation, but shows what given project can do — that’s definitely useful!
- Some projects could use a web server — a server where a user can send a JSON and get some response, just to test out how a given project works.
General software engineering
- Read the documentation and fix any errors/misleading statements you find.
- Try to run a given project, describe any problems you have and give feedback to the creators. Especially in the case of projects with one contributor, it may turn out that the developer has tested it only on Linux, it doesn’t work on Windows and they lose many potential users since no one ever told them.
- Go through tutorials/examples and check if they work well.
- Refactor, make sure a project meets all the good practices of a given language (usually Python), suggest better architecture — most of the projects in this field are not created by professional software engineers. It’s not such a big problem to begin with, but when a project starts to grow, getting help from an experienced software engineer can really make a difference!
- Many issues on GitHub are related to problems with software rather than science, e.g. compatibility with external libraries.
- Be active on QC Stack Exchange — one good answer can help thousands of people!
- Many projects don’t have any visuals in the readme/tutorials/docs, because the creators can’t make them (I’m a good example). But actually, adding some simple drawings could really help people understand the idea behind all the code.
- Create a logo for a project
- Replace existing graphics with something prettier
- Many blog posts (this one included!) could benefit from illustrations.
- Some projects could make use of a simple HTML website/landing page, as an addition to the GitHub page
- Create animations for YT videos for explaining some concepts.
- Less visual, but still valid: Designing proper information architecture (https://www.toptal.com/designers/ia/guide-to-information-architecture)
- There are many local communities that could benefit from your knowledge about organizing and promoting events.
- If you have some experience in community management, become a part of a community (e.g. Slack group, forum), see what problems you can identify, contact the admins and offer your help or advice. It’s much easier to see the problems for an outsider and all the people I’ve been talking to are really happy when they get feedback about their communities.
Let me tell you what it looked like in my case. I talk only about projects I’ve contributed to, not ones I’ve created myself.
When I started learning pyQuil, I stumbled upon some inconsistencies in the documentation. The output of similar programs was printed in different ways without any obvious reason. It was minor, but it bothered me enough to create a pull request fixing it. After that, there were some other fixes in docs and examples. I made also a PR to grove which fixed a bug in QAOA implementation.
I added an example of how to create some useful graphs to the docs of dwave_networkx — one of the many libraries from D-Wave. It wasn’t obvious for me how to do that, I spent several minutes figuring it out and it seemed a natural thing to add to the docs.
And finally, I have made some improvements in the documentation for QMLT and fixed one problem I encountered in the generation of the plots.
Apart from that, I have created some issues, gave feedback to people, made some suggestions for several libraries, some of which I’ve already mentioned.
As you can see, what I’ve done are not a lot of significant contributions — rather a couple of small ones. But, as I will argue in the next section, I believe it matters.
Have you ever heard about Francis Galton? He was a 19th c. scientist and inventor with extremely broad interests. One of his inventions is a device we call the Galton board, which is a great tool for showing how probability distributions work.
You can see it in the photo below. You put a ball at the top and at each stop it has a 50% chance of going left or right. In the end, it drops into one of the bins at the bottom. If you put a big enough number of balls, you will see that they form a Gaussian distribution at the bottom. It means that most of the balls will end up in the middle and only some of them on the left or right end.
But this article is about quantum computing, open software, and community, so why am I talking about the Galton Board? Because it’s a nice model of the mechanisms in play. Let’s say that the bottom of the board is how successful a person is with quantum computing — more to the right is better. A ball is a person. And every peg is some interaction with QC — reading an article, installing a library, going through the tutorial, applying for a job, etc.
Let’s be honest — quantum computing is not the easiest field and even though it’s much easier to start than most people think, it’s also easy to get discouraged. A new person needs to learn a lot of new notation, a different way of thinking, etc. And all of the time they feel uneasy because they don’t get a deep understanding of how it all works. If this person simply stumbles across a bug in the library — they will ask for help, wait a little bit, get help and go further. But if before the bug, they spent two hours installing it, 3 hours going through the tutorials, which were not updated since the last release and the docs written in mathematical jargon — it’s much more likely that this bug will be their last interaction with this code and they won’t even report it. In our Galton Board model, this situation is reflected by going left 4 times in a row (installation, tutorials, docs, code quality).
A single person who tested the installation process, figured out how to make it easier on Windows and actually improved it, would already skew one peg — now it doesn’t have 50/50 probability, perhaps 40/60. Another person who has updated the tutorial would skew another peg. And finally, someone who was able to write a more practical example for the docs would deal with the third one.
My point is — every contribution to the open source projects and community, no matter how small, makes other people more likely to be successful. And as time passes and you gain expertise, you will be able to bias more pegs more strongly, which will make the whole field stronger and more welcoming to newcomers. And in the end, this means we all are a little step closer to the incredible applications that QC might one day offer.
You can play with a Galton Board using this demo
If you ever meet me and tell me that you’ve actually contributed to a QC library/project after reading this article, I will buy you a beer/coffee/some other beverage.
To make it harder for you to make excuses and for me to hold my money, here is a list of open source projects that are looking for contributors and help. I have personally asked the maintainers/developers from each project if they could use some help, no matter how small, and they all said “yes”, so feel free to contribute or contact them to see how they could use your skills :)
The aim of Dawid Kopczyk’s blog is to explain quantum algorithms to data scientists in an understandable and effective way. A lot of programming examples and explanatory graphics included. Link.
QuantumInformation.jl is a Julia library facilitating numerical studies in the field of quantum information theory. The library contains functions for constructing quantum states and operations, performing quantum evolution and measurement, and sampling random quantum objects.
- Contact: firstname.lastname@example.org
Q-Bug is a standalone visualizer for the execution and state of a Quil program.
Qurry — a quantum programming language prototype. It takes principles from functional and probabilistic programming and adds them to quantum programming to create a more abstract, approachable interface to quantum computing in the spirit of Bjarne Stroustrup and “lightweight abstractions,” as they are applied in C++.
There are poster, slides, and code online, which give more information about the project. Github repository has instructions for contributors on the front page.
NISQAI is a software package being built to facilitate machine learning applications on near-term quantum processors. We welcome all contributions from programmers, physicists, machine learning researchers, etc. Our main GitHub repository is here, and our (public) development repository, which has ideas for new contributions, is here.
Please reach out to me, Ryan LaRose, at email@example.com to ask questions or get started with contributions. If this is your first time contributing to an open-source project, or if you’re a programmer but not familiar with quantum, don’t worry! We’re happy to help with any questions from submitting a pull request to measuring in the Y basis.
Avalon is a new programming language for hybrid classical-quantum computers. Avalon is hardware independent but currently all efforts are directed towards supporting discrete-variables quantum computers. Prospective contributors are encouraged to compile the code on operating systems and architectures they have access to, help produce binaries for those platforms and report any bugs they encounter. For those deeply interested, they can contact me and I will be happy to guide them in what other ways they can contribute.
I can be reached at firstname.lastname@example.org.
My own projects
I have myself done some open source projects, if you would like to help with any of them, please let me know at email@example.com.
- My blog.
Projects from Rigetti
Quilc — a world-class optimizing compiler for gate-based programming, based around the syntax of Quil. It powers the compilation of programs for Rigetti’s quantum computers, but can be readily used for most kinds of gate-based architectures.
Rigetti’s QVM is a very flexible and high-performance simulator for gate-based machines. It includes a pure-state simulator, stochastic pure-state simulator, density matrix simulator, simulator for the Feynman path integral formalism, and (in a PR) a stabilizer simulator.
Both are free and libre software written in Common Lisp, with no proprietary components.
And there are also two libraries already mentioned earlier in this article:
pyQuil - a python library for quantum computing.
grove - a collection of quantum algorithms built using the Rigetti Forest platform.
Projects from Xanadu
PennyLane: a cross-platform Python library for quantum machine learning, automatic differentiation, and optimization of hybrid quantum-classical computation. PennyLane is platform agnostic, and allows you to interface hardware devices from IBM and Rigetti with machine learning frameworks such as PyTorch and TensorFlow — allowing hybrid GPU-QPU computations.
Strawberry Fields: a full-stack Python library for designing, simulating, and optimizing continuous variable (CV) quantum optical circuits. Future releases will target Xanadu’s experimental backends, including photonic quantum computing chips.
In terms of contact, the best place to discuss contributing is on the Strawberry Fields Slack channel.
Projects from D-Wave
dwave-ocean-sdk - the meta installer for the Ocean ecosystem.
dimod - Contains objects and functions important for working with binary quadratic models
dwave-hybrid - Hybrid Asynchronous Decomposition Sampler prototype framework.
Qiskit is an open source software framework for building quantum programs, mapping them to different backend devices, and running them on simulators and real hardware for free. It also provides the tools to build quantum algorithms and study noise in quantum computers.
There is plenty more other projects to explore! You can check out QOSF website or join some of the communities to find something that interests you :)
If you would like to read a more detailed analysis of the realm of QC OS projects, it has been done by Quantum Open Source Foundation and is available here
Huge thanks to:
- The authors of the libraries mentioned, for their feedback, support and willingness to cooperate.
- Mark Fingerhuth, Tomas Babej, Peter Wittek and Will Zeng for their contributions to QC OS community.
- Rafał and Ntwali for the feedback on this blogpost
As always, please let me know if:
- you have any feedback
- this post actually helped you to get involved into QC
- you have any thoughts you would like to share
My e-mail: firstname.lastname@example.org
Have a nice day!