Common Lisp, Development, LISP, Quantum Computing, Quantum Programming, Technology

Project Goals for Open-Blackfire

There’s no denying, I went a little bit over the top with the closed-source, proprietary version of the Blackfire Framework under my now-defunct start-up, Black Brane Systems. For the new, open-source version, Open-Blackfire, I intend to focus the implementation on the features that will make it most useful for the Common Lisp and Quantum Computing communities, along the shortest path of development to these features.

The core modules of the Blackfire Framework boil down to:

  • The Wittek Machine: quantum virtualization
  • Protocol “Phi”: higher-order quantum type system
  • Blackfire Quantum Assembly: Vendor-agnostic quantum computer machine language

The initial priorities for Open-Blackfire are for Protocol “Phi” and the Blackfire Quantum Assembly language for vendor-agnostic quantum computer programming. The Wittek Machine architecture, which uses a hyperlattice data-structure to represent quantum states and operations under the Quantum Logic formalism, will be a serious pain to reimplement, so I’m saving that migraine as an optimization down the road once the core functionality is exposed.

To start with, Open-Blackfire will rely heavily on CLOS and the MOP in its architecture, and use Complex-valued matrix encodings to represent Quantum States and Operations, which as the standard in the literature will be easily checked for correctness. This will be extensible to use alternate and eventually interchangeable internal encodings, which will allow streamlined Quantum Validation built into Open-Blackfire’s test suite.

The above paragraph feels distinctly hand-wavey, ignoring the complications between various interpretations of Quantum Mechanics and the impact that has on the practical aspects of Quantum Computing. I will be keeping these complications at the forefront of my mind and factoring them into the new codebase from the beginning, and my hope is that I can do it in a way this time that is clear in the codebase for those who care, and a non-issue for those who don’t.

And lastly, as a large-scale open-source project, I will need to rely on the Common Lisp and Quantum Computing communities to see this project through, so if this technology will be of use to you and you are able to help make it a reality, please consider sponsoring me on GitHub Sponsors:

Common Lisp, Development, LISP, Quantum Computing, Quantum Programming, Technology

Announcing Open-Blackfire and Open-Quicksilver

With the death of my start-up, I’ll be switching my focus back to open-source software and open-science, starting with developing new, open-source versions of the Blackfire framework and Quicksilver Quantum Lisp programming language. I will also be resuming work on Learn Lisp The Hard Way and Learn Quantum The Hard Way.

You can follow these projects at:

My goal is to work full-time on open-source software, open-science, and educational material for Common Lisp and Quantum Programming, but I can’t do it without your support. Please consider sponsoring development of Open-Blackfire, Open-Quicksilver, LLTHW, and LQTHW through my GitHub Sponsors profile:

Common Lisp, Development, LISP

Learn Lisp The Hard Way, now brought to you by LispTO

It is with great pleasure that I announce that Learn Lisp The Hard Way is now an official, collaborative project of the Toronto Lisp User Group; and we are now accepting donations specifically for this project through PayPal. I will still be participating in the exact same capacity, but hopefully this change will help LLTHW become the definitive introduction to Common Lisp significantly faster. In particular I would like to welcome Leo “Inaimathi” Zovic as a co-author—the author of cl-notebook, cl-css, formlets, and many other excellent Lisp libraries—although other members of LispTO have expressed interest as well.

I would also like to ask the Lisp Community at large to consider contributing original text and source code examples, for the book itself, the interactive tutorial powered by David Vázquez Púa’s JSCL, and the drop-down CL language reference. Ideally, for the language reference, I would like to partner up with Robert Strandh’s project, CL-reference, to create a definitive, public domain reference to the Common Lisp standard. You can visit the new repository at: http://github.com/LispTO/llthw and submit a pull request if you would like to contribute.

Please be advised, that it is our intention to bring this title to print in addition to providing the complete book text online for free in perpetuity, so all contributors to the book text should be prepared to sign a contract and royalty schedule when the first edition is complete—towards this end I have updated the license of the book text to a Creative Commons Attribution-NoDerivatives 4.0 International License. However, there are a lot of other ways to contribute to the site and project in general, so if you don’t want to sign anything and still want to participate, you have a lot of options—the rest of the project remains MIT Licensed.

For those of you in the Lisp community that have already shown support for this project and contributed as peer reviewers and editors, be sure to create an issue on the repo and say if you would like to be identified as a contributor to this project. Your feedback has already made a big difference, and I hope to see you all on github!

Common Lisp, Development, LISP, Quantum Computing, Quantum Programming, Technology

Quantum Computing and Lisp

Quantum Computing is a fascinating field, but currently a contentious one. The only examples we have of real-world, hardware quantum computers are the line of adiabatic quantum computers from D-Wave Systems—and many voices in the scientific community still protest its identification as such simply because it is not a full-fledged gate-model quantum computer complete with persistent quantum data storage and QRAM. However, by the strictest definition, any machine which exploits quantum mechanical phenomena for the purpose of computation is a quantum computer, and the D-Wave One and Two meet this definition.

For us in the Lisp community, Quantum Computing is even more important; one of the most surprising secrets of the D-Wave line of adiabatic quantum computers is that their low-level operating system is programmed in Common Lisp. Specifically, D-Wave uses SBCL. This choice is not accidental or arbitrary—Common Lisp is uniquely suited to the task of quantum computer programming.

Continue reading

Common Lisp, Development, LISP

LET-OVER-LAMBDA fixed for SBCL 1.2.2

Thanks go out to Orivej Desh—he pointed out what I overlooked, and the LET-OVER-LAMBDA package now works with full functionality restored in SBCL 1.2.2. I have preserved the :safe-sbcl feature used for testing the version of SBCL, so that descending into comma-expr of sb-impl::comma is only enabled for SBCL 1.2.2+.

The updated code should be available in the August release of Quicklisp. If you have a fork or clone, please be certain to pull the latest changes from the master branch.

Common Lisp, Development, LISP

LET-OVER-LAMBDA broken in SBCL 1.2.2

As expected, the Quicklisp distribution of LET-OVER-LAMBDA is broken by the changes to the backquote reader macro in SBCL 1.2.2; although I expect this change breaks a good portion of Paul Graham’s macro code examples from On Lisp, as well.

A quick-fix suggested on Reddit is to use a “pseudo-flatten” for SBCL that also descends into sb-impl::comma-expr of sb-impl::comma. I will be testing this fix today, and hopefully pushing an updated version for the August release of Quicklisp.

Stay tuned.

UPDATE: modified LOL:FLATTEN to descend into comma-expr of sb-impl::comma objects, but no joy. I have currently disabled DEFMACRO! based code in LET-OVER-LAMBDA until I can find a better solution, and tested this against both v1.2.2 and v1.2.0-1 of SBCL (so if nothing else, it will at least build without errors).

If anyone knows of a better solution, feel free to leave a comment here or on the GitHub Issue thread.

Common Lisp, Development, LISP

Hacking Lisp in the Cloud, Pt. 3

Cloud9 -- New website and 3rd gen browser-based IDEToday Cloud9 announced the release of their new IDE to all customers. They also released their new website. The hiccups in the beta were all pretty minor, and were resolved quickly after reporting the bugs. Now, everyone can enjoy all the awesome new features.

The Cloud9 IDE supports more than 40 programming languages, Common Lisp included. As I mentioned in my previous post about the Beta, there are all sorts of new features that support a cleaner Lisp development cycle over the previous version—including auto-completion, file outline of top-level definition forms, custom runners, split-screen views, and more, all built on top of an Ubuntu workspace with sudo privileges. They’ve also streamlined the interface, collaboration tools, terminal, and over-all performance of the IDE.

Continue reading

Common Lisp, Development, LISP

SLIME for Emacs Live

Emacs Live is a frakkin’ epic compilation of customizations and packages, streamlined for the ultimate hacking experience. As I mentioned in my last post, Adventures in Clojure, it’s under development by the same team as the Clojure bridge to SuperCollider, Overtone. The one downside? It was designed for hacking Clojure, so it doesn’t include SLIME and Common Lisp support out of the box, and of course, it completely replaces your ~/.emacs.d/ directory and ~/.emacs config file, so you lose your existing SLIME setup (and all your other customizations) when you install Emacs Live. Don’t panic, the Emacs Live installer is smart enough to move your existing ~/.emacs.d/ folder and ~/.emacs config file to a safe place.

Emacs Live does, however, offer a pretty neat interface for creating Live Packs, boxed collections of Emacs packages and customizations, that can all be loaded together as a single package via ~/.emacs-live.el, stored outside the managed ~/emacs.d/ directory so that they can be maintained across updates. This made it only slightly less trivial than normal to get SLIME set up and running in Emacs Live.

Continue reading

Common Lisp, Development, LISP

Hacking Lisp in the Cloud, Part 2

This morning I got access to the new Cloud9 IDE beta—and I have to say… WOW. It’s slicker, it’s faster, it’s more stable, auto-complete recognizes Lisp definition forms from your open workspace files such as defun and defmacro, and most importantly, it only takes seconds to get your workspace set up with RLWRAP, SBCL and Quicklisp.

The new Cloud9 IDE is running on an Ubuntu backend workspace. Cloud9 has had terminal access to your project workspace for quite some time now, but I’ve found the terminal experience to be significantly smoother in the new beta. It stays connected now, no longer timing-out on you when switching tabs or stepping away from the computer for a minute. Users can also use sudo for root access, and as a result install any debian package from apt (amongst many other things, of course). Emacs 24 is already installed by default. I suspect that SSH tunneling to a remote SWANK server from the Cloud9 workspace is also now possible.

Continue reading