Make Cool Stuff in Half the Time

Stand Up for Open Innovation

Pre-Order a Tessel2

The Tessel platform is revolutionary. If you haven’t heard, the Tessel is a programmer-friendly hardware development board. Because of its innovative modular design and JavaScript runtime, it’s much simpler to use for complicated projects than any Arduino or Embedded Linux board. Since it was conceived, designed, and built by web developers, the Tessel platform values agility, flexibility, simplicity, ease of use, and scalability. For hobbyists, this means that you can prototype hardware products in hours instead of weeks, without an EECS background. For students: go from zero to sixty with lots of online support. Entrepreneurs: you can finally do hardware MVPs. Oh, and literally everything about the Tessel is open source and (non-viral) libre. So seriously: go pre-order a Tessel2. It will be here before you know it.

What is the Tessel?

The Tessel is technically the microcontroller heart of the Tessel platform. It’s a credit-card sized computer that has on-board Wi-Fi, a set of module ports, and a “bank” of general purpose in / out pins (GPIO for those in the know). It runs JavaScript and is npm and node.js/io.js compatible. It is programmed over USB from the command-line, so it is not tied to any one text editor or IDE. It’s fantastic for creating “Internet of Things” (IoT) devices, but a quadcopter has been made with it. It’s the future of hobbyist electronics hacking. And since it’s open and libre, you have the opportunity to modify it freely, make your own en-masse, and see what’s happening “under the hood.”

The Tessel comes in two flavors: the T1 and the T2. The T1 is currently available and is well suited for low power applications such as sensor data collection and storage. The T1 is low power because it is programmed by Colony, a custom JavaScript -> Lua bytecode -> deploy framework. Because Technical Machine is 8 people and building a full JavaScript runtime is Hard and Time Consuming, it’s a bit slow and not 100% node compatible, although most everything works (Obscure JS like `new UInt8Array` is unsupported.) It has 4 module ports (A B C D) for Tessel 10-pin modules. Its Wi-Fi works pretty well, especially considering that it doesn’t have a large antenna.

If the T1 is a moped, the T2 is a porsche. It’s a full embedded linux board with enterprise-grade Wi-Fi. The platform runs io.js on top of OpenWRT. It is fast enough to do (admittedly light-weight) realtime data processing and streaming. Since it’s a linux board, it has USB port support so you can connect a mouse to it or even flash other Tessels. Similarly to the beaglebone, it has a GPIO-focused coprocessor that brings greater flexibility to the 10 pin module ports (the GPIO bank is gone). It also has an ethernet port, and since it runs OpenWRT, you can turn it into a router. It only has 2 10-pin module ports, but many of the more complicated modules (Camera, Bluetooth Low Energy off the top of my head) are being replaced with USB based solutions.

The T2 uses significantly more power than the T1 because it has great Wi-Fi and runs linux. io.js has all of v8's hydrogen and lithium JIT compilation. You can even use generators or higher level abstractions such as Rx.js / Bacon.js Observables. And since it’s just linux, you can always drop down and write Rust, C or even Assembly (don’t do this) if you have a particularly optimizable bit of code that you want to remove from JavaScript-land.

What are the advantages of the Tessel platform?

Higher level abstractions. Internet as a first-class citizen. Faster iteration cycles. Each of these alone would be reason enough to check the Tessel out. Together, they magically combine and reinforce each other, opening portals to worlds previously unseen (but perhaps not undreamt) by hackers and makers.

Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams, because that is a universal interface.

The Technical Humans at Technical Machine have done a wonderful job of applying the UNIX philosophy to hardware development. Modern hardware development is a marriage between software, firmware, and hardware. Everything about the Tessel, from the command line interface that programs it to the mix n’ match, plug and play nature of its modules, to the fact that it runs JavaScript, breathes this philosophy.

On the software side, the Tessel platform uses a command line tool to program individual Tessels. When you install the runtime, you get access to the `tessel` command, which does everything Tessel-specific for your project. `tessel run` deploys a project to a locally connected Tessel for development and debugging purposes. `tessel push` deploys a project for good, so that power-cycling is essentially a server restart. `tessel init` is similar to `npm init` but includes hardware specific flags into your package.json (the file that describes your project in a human and machine readable format).

Since Tessel piggybacks io.js and npm, writing code is familiar to anyone who has used a dynamic language with a package manager in the last ten years. npm makes “module” (library or package) installation and management as painless as possible, for reasons others have beaten to death in their flight from gem and pip. io.js is a fork of node.js, and node.js is the UNIX philosophy reified into a world of programmers fleeing from Java and C, while not going far enough to find Clojure. node is simple and easy to use, once you’ve actually learned JavaScript. If you’ve never used `.call` or `.apply`, or curried a function, and `this` still trips you up, you have some practice to do but it won’t be painful. Since JavaScript is built around an event-loop and queue, it’s straightforward to build highly-concurrent reactive systems with node.js, despite the fact that it’s (currently) single-threaded.

On the hardware side, the Tessel focuses on modules over GPIO. A module is simply a hardware component that you plug into the Tessel. They tend to fall into 3 major categories: Inputs, Outputs, and Communication (which is technically both but distinct enough I give it its own category.) They range from simple (input: accelerometer, output: electronic switches (relays)) to complex (input: camera, output: OLED display, communication: bluetooth low energy). But they all plug in the same way and expose “large objects” (in the smalltalk sense) and event emitters / listeners in JavaScript-land. They’re simple AND easy to use. As long as you don’t plug them in upside down.

This is the profound difference between the Tessel and every other hardware platform out there. The Tessel focuses on properly encapsulating concerns into “large objects” that expose functional reactive interfaces. These large objects communicate over common hardware protocols: I2C, UART, or SPI. Modules often have a processor about as powerful as an Arduino Leonardo built into them. The Tessel can easily consume Arduinos.

Arduino’s “modules” are called “shields” and they are terrible. If you want to use more than 1, you immediately have to start worrying about GPIO conflicts, power concerns, and . If you look at an Arduino stacked with 4 shields, you are literally looking at a Monolith. The Raspberry Pi and Beaglebone communities basically didn’t think this was a problem and followed suit.

The community, and Seeedstudio in particular, have done a great job bolting modular support onto the Arduino platform. Unfortunately, the Arduino’s focus on low-level concerns make this impractical at a software level. “Hello World” consists of making an LED blink. An LED that you bridge port 13 and ground with. For comparison, a real Tessel “Hello World” story involved text messaging sensor data via Twilio (internet as a first class citizen is awesome.)

Writing evented code in C is challenging, and many makers / hackers don’t have enough of a CS background to even ask the right questions to be able to solve these problems. I spent most of my Arduino hacking time building interactive pieces like light shows and robots. These are fundamentally asynchronous, reactive systems, and having language and community support make them straightforward to build with node.js (io.js).

Let me give you a personal example of a time I failed with Arduino. I wanted to showcase a friend’s 4-button radio remote control shield by allowing it to change what light display an Arduino would play on a lamp composed of Cool Neon Total Control Lighting Pixels. I’d written many light shows by that point, and I thought it would be straightforward to have the Arduino switch between them. I was horribly wrong.

After 2 weeks of misery and beating myself up, I ended up with a terrible eventing system and something halfway to a basic OS as well. It worked, I got 4 light shows to run, but it had terrible bugs. I’d like to point out that, after being a professional software developer, I know how I’d go back and do it over again. That’s not the point. The point is that I had already spent over a thousand hours programming (crappy flash, C, and BASIC programs mostly) by the time I hit this roadblock, and without platform support I floundered. There is only so much you can do with an Arduino, but learning to fully utilize linux (Raspberry Pi) is not the next step. It’s like 5 or 6 leaps away.

Arduino’s narrowing the focus to C, GPIO, and building tiny monoliths is great for hacks, artistic one-offs, and making modules. But it’s really hard and it doesn’t scale well.

Similarly, the Tessel has a narrow focus on node.js, modules, and internet connectivity. It’s not meant to be a general purpose computer. You shouldn’t mine bitcoins with it, not even for fun (pick up a parallela.) But it really shines at what it does.

Internet as a First Class Citizen

It’s pretty obvious that a computer that runs a platform built for making servers and rich web applications should value the internet. The internet is really just the UNIX philosophy on a global scale. Being able to easily connect hardware to the internet means that you can connect a tiny computer in your house to IBM’s Watson. With a T2 you can connect to and offload Natural Language Processing. You can send text messages through Twilio when your cat comes home or your dog won’t stop barking. And it’s easy.

Being built on top of OpenWRT also allows you to turn T2's into routing devices or servers. You can build chromecast-like devices (not a chromecast, video stream processing requires dedicated hardware and even the T2 will bottleneck this) that initialize into a Hot-Spot mode and broadcast an Angular2 configuration web-app, instead of forcing your users to download yet-another-single-use-app.

You can setup which Wi-Fi bands your Tessels will talk on, allowing you to avoid flooding a single slice of the spectrum in your home. You can have interactive art pieces that broadcast tiny apps so that those with smart devices can interact with them (part of me cringes at the technological elitism of this, but you can always provide an iPad). Using cutting edge frameworks like, you can make these experiences feel as real as native apps, but be ephemeral, frictionless, and location aware. This is the next evolution of the internet — the physical web. And unlike beacon-based physical-web, this one works without broader internet access.

Faster Iteration Cycles

The holy grail of programming is to be able to see the results of your programming in real-time. Any pauses in your edit cycle slow you down, because checking to see if your code behaves properly is a blocking operation. It’s such a problem that the chromium team wrote Ninja in order avoid spending 10 seconds waiting on incremental builds. ClojureScript users get Figwheel to dynamically reload functions at run-time, because it helps suss out bugs. Code is truly a craft just as much as it is an engineering discipline or a science, and instantanious feedback through fast iteration cycles is crucial to a craftsperson’s ability to perform.

The Tessel platform is fast to develop for. Writing code is fast, as you’re dealing with high level abstractions in a dynamic language, and you have access to npm. Plugging in modules is fast. Deploying code is fast — it can even be handled automatically by your build system. Basic debugging is fast: just drop `console.log`s while connected over USB. System startup is definitely slow… but not relative to similar systems. Waiting 6 seconds (on a T1) for the system to do a cold boot, initiliaze all your modules, and connect to Wi-Fi is pretty annoying. But the T2 has the potential to be significantly faster after bootup, as the Wi-Fi is an OS level concern. I’m excited to see what happens there.

Also, since this is all just JavaScript, you can unit test your code. Modules are just event-emitters, and can be mocked accordingly. You don’t even need to deploy your code to a Tessel in order to ensure that it works as intended at the unit level. Interestingly, this is a huge advantage of using JavaScript everywhere. And since the T2 runs v8, any pure JS that works on your development machine should run on the T2. C++ module support is going to be interesting, mainly because the T2 is a MIPS board and not x86 or ARM.

When you have fast iteration cycles, the real winners are hackers and students. In his phenomenal book Outliers: The Story of Success, Malcolm Gladwell performs a holistic analysis of the legendary Bill Joy’s success. Gladwell points out that Joy’s choice of the University of Michigan presented him with the (at the time) exceedingly rare opportunity to program on a timesharing system, instead of the standard punch cards. Punch card “programming itself was extraordinarily tedious… if you made even a single error… you had to take the cards back, track down the error, and begin the whole process again.” To quote Joy directly,

Do you know what the difference is between the computing cards and time-sharing? It’s the difference between playing chess by mail and speed chess.

Gladwell points out that Bill Joy was planning to become a biologist. And he probably would have had he not had unlimited access to a timesharing system in 1971.

The difference between fast and slow iteration is the difference between success and failure. It’s the difference between a young person experiencing the magic or the suffering of code. The Tessel platform is fast. As Gladwell states, for Bill Joy, “Programming wasn’t an exercise in frustration anymore. It was fun.”

The Tessel is Fun

Humans learn best by having fun. By being curious and desiring to seek answers. The faster the answers come, the faster the dopamine release cycle kicks in, and the more hooked on learning we become. Hackers are literally addicted to learning and building. Students become hackers when they are infected with the magic of programming. And the Tessel platform’s modularity ensures that there is much to learn, but in bite-sized chunks. Once you’re addicted, you can go up the stack (writing JavaScript interfaces, compiling ClojureScript to JavaScript to Lua Bytecode) or down the stack (build a hardware module from bits, writing firmware) but the insatiable curiousity remains.

Why does it remain? Because the Tessel is simple. When working with a Tessel novice, each answer you provide leads naturally to a dozen new questions. Answers are not so large that they overwhelm and shut down the learner. At a hardware level, you plug in modules. At a software level, the modules are objects with descriptive names and methods. This truly is the UNIX philosophy applied to hardware, and it is beautiful.

Stand Up for Open Innovation

The Tessel is the best hardware development platform currently available. It’s also been open source and libre since its inception. You can see almost every line of Tessel related code ever written on github. And it’s non-viral libre (yes this exists on the spectrum), so you can build entire product suites around the Tessel ecosystem. Citizen Science, Home Automation, Robotics, are all closer at hand than ever before, and the Tessel is a huge part of that.

The Technical Humans are creating immense value and offering it freely. Because they understand how huge this opportunity is, and it’s not one that can or should be dominated by a single monopoly. They understand that, by creating massive value and capturing only a tiny fraction of it for themselves, they can thrive. This is the soul of open source.

Open source is taken for granted in this industry, which is a shame. Large, established companies can support open source as a recruitment technique and as a way to promote security (heh, heartbleed), but smaller, tool focused companies don’t seem to be able to turn open source into a strength. Which is a shame and a failure of our industry.

One of the problems is that smaller companies build riskier products. Even with open source, if the company dies the community will die as well. Large companies with deep pockets don’t like taking risks. Small companies are usually scraping by and are trying to minimize overhead.

The only solution that I can see is to build strong community. But that’s exceedingly difficult with hardware, as you have to sell physical product in order to get people hooked. There’s a huge difference between downloading a free app and dropping $100+ on a revolutionary development board kit.

Ironically, it’s those risk takers who see the potential of the platform, who are willing to wade through the muck, who will be able to maximize the value of investing in the Tessel platform. We can finally do hardware startups again for the first time in 40 years. We can stop building crappy phone apps. And no one seems to care.

Pre-order a Tessel2

If you care about the evolution of this industry, or about hardware at all, or about open source, you should pick up a Tessel2. Hardware is fun again. It’s easy. And it’s going to revolutionize the world around us. You can support closed, proprietary systems that mine your data. Or you can invest in building a more personal, more secure hardware ecosystem. The lowest hanging fruit is truly the internet of things, and it’s converse the phsyical-web, but there are so many possibilities unlocked by the Tessel that I cannot wait to see what happens over the next decade.

Hardware is back. All it took was returning to fundamentals.