Compare graphical hardware programming platforms

Home » ALL » REVIEWS » Compare graphical hardware programming platforms

This article is published with the authority of the creator. — Wenjie

Foreword

I’ve used most graphical hardware programming platforms, probably more products than most product managers in this field.

That’s not something to brag about, it just means I’ve wasted more time than anyone else on a myriad of programming platforms, and it means I’ve been slow to come across a really good product.

Unfortunately, as a rule, this is what computer education is all about. Learners spend many hours learning nothing but the bad ideas of the system designers.

Fortunately, John Maloney brought light to the field and ended my life of bouncing around from platform to platform.

Graphical Programming

Graphical programming has almost completely conquered the field of programming for kids, so much so that when we talk about programming for kids, we’re basically talking about graphical programming.

There are truly great people in this field: Seymour Papert, Cynthia Solomon, Alan Kay, Mitchel Resnick, Natalie Rusk, John Maloney…

There are truly great books: Mindstorms, Kindergarten for Life, and A Computer for Children of All Ages…

There are also really great projects: Etoys, Scratch, Snap!

It’s a mystery why the average product in the mainstream is so low…

The pioneers in this field have a clear epistemology and vision, and the brilliant insights in this field go far beyond “putting together blocks reduces grammatical errors”. But unfortunately, most of these powerful ideas are not understood by today’s educators and system designers. Live programming is one of the sources of Scratch’s power, which requires a powerful virtual machine (VM), and simply translating blocks to code is far from improving understanding. I discuss this topic in more detail in the CodeLab Chronicle.

The field of graphical hardware programming requires really powerful VMs (and the graphical IDEs that work with them) to support a constructivist style of teaching. But the field currently has little awareness of the role of VMs and is stuck with a focus on building blocks.

Graphical hardware programming

The joy of hardware programming is that we can make ideas, through the code and the hardware materials that run it, act in the real world. In this way, our ideas take on a physical body.

Today, when STEM/STEAM/Maker/Physical Computing is discussed in education, it is more or less related to hardware programming.

The last project that deserves to be criticized is Microsoft’s MakeCode. In addition, most systems don’t even have a clear design concept, they just copy A from B and B from C, usually together with bad ideas, and are not worthy of a refutation. So far, the only project that has really done well is MicroBlocks.

This article will discuss what makes MicroBlocks better than other platforms. Here I will focus only on those system features that enhance the user. Specifically, I will focus on the following features:

1. Comprehensibility

2. Openness

3. Low barriers, high ceilings, and wide fences

4. Support for constructivist teaching styles

I put comprehensibility first, which helps us think and create better. One of the most important aspects of being a Maker is to make sense of the world through the process of creation.

Welcome to criticize

Criticism from readers is very welcome.

The goal of this article is to provide a “review and selection guide” of sorts that will hopefully provide a reasoned basis for serious users to choose a programming platform. It is also hoped that this material will stand up to the criticism of experienced users, educators, hardware engineers, and hackers.

This article is likely to contain factual errors, which may arise for the following reasons:

I am not familiar enough with the platforms reviewed and have missed functional features

As platforms are constantly being updated, there are many improvements happening (such as my previous point that “Python concurrent code translated from blocks can be misleading to beginners”, which Makeblock has done brilliantly).

If there are any factual errors in my review, or if some platforms have already made relevant improvements, readers are welcome to correct me at [email protected], and I will change this article to bring it closer to the truth if the arguments are sufficient. This list is currently only v1.0 and will be continuously updated.

If you would like more graphical hardware programming platforms to be included in the comparison, please let me know.

PS: I know I have a strong emotional preference for MicroBlocks (although I think this preference is based on reason), and in writing this article I tried to restrain this emotional tendency in the hope that it would not cause me to be biased against other platforms (trying to be neutral is necessary if you want this article to be convincing). For example, I tried to connect to micro:bit on my computer (macOS 12.3.1 M1) to run hello world, and it didn’t work on either Mind+ or Kittenbot, but I didn’t immediately give them low scores on the relevant review items because of that. It is possible that my computer system is so niche (most people use Windows) that it was not taken seriously enough to test. I went to the user communities of these platforms to read user feedback and found that they didn’t encounter the problems I did. I also had my friends test it on windows and they all gave me good feedback, and I still gave Mind+ and Kittenbot high marks in terms of ease of use.

Comparing Platforms

In this article, I have selected some graphical hardware programming platforms that I have used myself and have had some influence on (or at least used as one of the selling points).

1. Wise Programming

2. Maker IDE

3. kittenbot

4. MakeCode

5. MicroBlocks

6. Mind+

7. Mixly

8. Scratch(MIT)

Comparison of graphical hardware programming platforms

Comprehensibility		Makeblock	Maker	KittenBot	MakeCode	MicroBlocks	Mind+	Mixly	Scratch(MIT)
	Supports both immersion and interactive	❌	❌	❌	❌	✔	❌	❌	❌
	Live programming	3 stars (Online mode only)	2 stars	3 stars (Stage mode only)	2 stars	5 stars	3 stars ( Real-time mode only )	1 star	3 stars
	Live debug	3 stars	2 stars	2 stars	3 stars	5 stars	3 stars	1 star	3 stars
	Comprehensibility of complex building blocks (under the hood)	3 stars	2 stars	2 stars	3 stars	5 stars	2 stars	2 stars	2 stars
	Data Visualization	❌	❌	❌	✔	✔	❌	❌	❌
	Transferring blocks back from the board to the programming environment	❌	❌	❌	❌	✔	❌	❌	❌
	Understanding system state at runtime	❌	❌	❌	❌	✔	❌	❌	❌
	Understanding the system underpinnings in a user environment	❌	❌	❌	❌	✔ (Open advanced mode)	❌	❌	❌
Low Barrier	Unboxing availability	5 stars(web support, plugin dependent)	3 stars(web support, plugin dependent 300+MB)	5 stars(web support, plugin dependent)	5 stars(pure web page)	5 stars(pure web page)	5 stars(web support, plugin dependent)	5 stars(web support)	3 stars(Supports web pages, depends on plug-ins)
	Cross Platform	5 stars	5 stars	5 stars	5 stars	5 stars	5 stars	5 stars	4 stars (Linux not supported, community plugin required)
	Easy to use	5 stars	5 stars	4 stars	5 stars	5 stars	5 stars	4 stars	5 stars
	Building Block Richness	3 stars	2 stars	3 stars	4 stars	5 stars	3 stars	4 stars	2 stars
	Extensibility	3 stars	2 stars	3 stars	4 stars	5 stars	3 stars	4 stars	2 stars
	Multitasking capabilities	4 stars	3 stars	3 stars	4 stars	5 stars	3 stars	3 stars	3 stars
	Support offline operation	✔	✔	✔	✔	✔	✔	✔	❌
	Offline mode support for broadcasting (messages)	✔	❌	❌	❌	✔	❌	❌	❌
Wide fences	Number of supported boards	4 stars	3 stars	3 stars	3 stars	5 stars	3 stars	3 stars	2 stars
	Number of sensors/actuators supported	4 stars	3 stars	3 stars	3 stars	5 stars	3 stars	3 stars	2 stars
	Freedom for users to introduce new hardware	3 stars	2 stars	3 stars	4 stars	5 stars	3 stars	4 stars	2 stars
	Support “Program Once Run Multiple Boards”	❌	❌	❌	❌	✔	❌	❌	❌

Note: In the next version (v2.0), I will explain the meaning of each comparison item in detail.

Conclusion

The current field of graphical hardware programming has not advanced much from when I wrote a comparison of two hardware programming styles a few years ago, and the entire field is trying to get the platform to support both immersive and interactive programming, albeit in different ways (online/offline, live mode/upload mode, stage mode/code mode…). But only John Maloney’s MicroBlocks has managed to seamlessly blend the two, thus allowing the platform to better support Maker exploration and creation. The way to get this coveted feature is not to go down the old road of “translating blocks into code” or having blocks simply call code. “You can’t solve problems by thinking like you’re asking them. The right approach requires a powerful virtual machine. This is, of course, extremely difficult, and if you read John Maloney’s experience, you will see that he has been thinking and exploring this direction for decades.

I would like to quote from a user on Hacker News about MicroBlocks, which is very representative of professional engineers:

Excellent summary. The “oh wow this feels different” aspect of MicroBlocks comes after you try it. It makes programming microcontrollers as interactive and hands-on as building electrical circuits from discrete components. Your changes are immediate. And the live data graphing from sensors feels like a graphic voltmeter or oscilloscope. For physical computing, it’s simply the best learning tool I’ve ever encountered (note I’m an EE major, not CS). All those “real” programming languages now fall short in my view. I’m hooked. – kgiori

FAQ

I have past experience with Scratch and would like to make virtual world characters interact with the real world. Any suggestions?

Microbit More is the best hardware extension I’ve seen for Scratch, much better than the extensions designed by MIT Media Lab and far better than any other company’s extensions.

The author is a student of Alan Kay’s and a Smalltalk user, so he was able to understand Scratch’s design philosophy (Scratch was originally designed in Smalltalk) well enough to design a plug-in that is consistent with it and follows Scratch’s philosophy to the letter. The current CodeLab deployment of Scratch has it integrated and is free for everyone to use, and Microbit More has good out-of-the-box usability for newcomers.

Can’t MicroBlocks translate code? Is this evidence that it is not as good as other systems?

The desire to translate blocks into code is just a plea for the bad design philosophy of “blocks are thin packages of code, code is the essence, blocks are the surface”. I’ve already done a discussion of this at the CodeLab Chronicle.

MicroBlocks can certainly be translated into code if needed (and it does store it in text form, you can use a text editor to view the text code of a saved project), and the system can even show the user the VM instructions and bytecode corresponding to the blocks (compiled in real-time) if needed by advanced users, but John Maloney deliberately hides the implementation details under the hood, which does little to help the user create and understand the CodeLab Chronicle also discusses this.

If your system is unable to program deeply at the graphical level and requires the user to understand the code in order to work in greater depth. That simply means that the system is too graphically weak, which is a design flaw, not a reason to support “translating blocks into code”.

In MicroBlocks, the blocks and their textual representation (code) are two sides of the same coin, and thanks to the excellent overall design, the two have been made so highly consistent that users can do almost everything textual code can do, including writing extension plugins, using only blocks!

MicroBlocks is probably the furthest example of a graphical programming system that has gone since Etoys (a project led by Alan Kay).

How would you rate these platforms in aggregate?

My own mental ranking is:

MicroBlocks > MakeCode > Makeblock >>> …

It’s no surprise that MicroBlocks is riding high, John Maloney pretty much pioneered this direction and has been exploring this area for decades. The Microsoft team has a lot of experience with compilers and has pretty much done the best they can with the established technical framework. What blew me away was Makeblock (wise programming), they overcame a very large number of challenges over the years and the solutions were excellent, and made a great effort to enhance comprehensibility (multitasking, broadcast messages). But unfortunately, MakeCode and Makeblock did not start from a Powerful Idea: Think of blocks as a thin veneer for the underlying system (MicroPython/C++). It was a weak idea (introduced by Blockly), and any effort to optimize on top of it would have made very limited progress.

The only way to keep up with John’s disruptive advances is to build powerful virtual machines (and IDEs).

Point of View Is Worth 80 IQ Points – Alan Kay

If I want to design a system like MicroBlocks, how do I do it?

For aspiring architects who want to design systems like MicroBlocks (I was one myself, and joined MicroBlocks to work with John after seeing the huge gap), here are some suggestions.

Since one of the qualities of computing is that it can always simulate other computable things. So it is indeed possible to build a MicroBlocks-like system (with both imbibing and interactive capabilities) based on MicroPython+Blockly, and since MicroPython already includes a robust virtual machine (VM), it might be a good starting point. The next thing to consider is how the programming interface (IDE, of which building blocks are a part) interacts with the VM, how do you start and stop programs? How can the running state of the program be tracked so that graphical feedback can be displayed (e.g. with an illuminated border showing the running blocks)? How to handle parallel tasks? How to run a single block by clicking on it? How can I interrupt a running program? How to get the program from the hardware? How to get the runtime information from the hardware? How to recover from errors? …

(Message) communication is the key. This is an area that is not easy to figure out alone, not even for John Maloney, who got most of his architecture from Smalltalk/Squeak (Smalltalk has been one of the sources of inspiration for Live programming, the other being Lisp), and MicroBlocks is standing on the shoulders of a giant (Smalltalk) to see further.

If you want to go beyond Smalltalk and learn directly from the architecture of MicroBlocks, The MicroBlocks Virtual Machine and The MicroBlocks IDE may be the materials you need, but a lack of understanding of Smalltalk may make it difficult to see the ideas behind these designs, which may lead to difficulties in understanding