A Radical New Design Perspective
I recently interviewed Gordon Kruberg, CEO of Gumstix, which was acquired by Altium recently. While Gumstix designs and sells computer hardware products, Altium bought Gumstix for the Geppetto design software. Gordon discusses how the concepts of Geppetto are likely to influence future design methods in the Altium environment.
Nolan Johnson: I’m speaking with Gordon Kruberg, who’s the head of modular hardware for Altium. You came to Altium fairly recently through an acquisition.
Gordon Kruberg: Yes, at the end of April. We founded Gumstix in 2003, originally to build computers—what are now called computers-on-module (COMs). We were the first to do a full implementation with Linux on a tiny circuit board comparable in size to a stick of gum. We took all the hard stuff about building PCs and put it onto one board. The design concept is now pretty common.
At the time, though, people were buying PC 104, and we decided to make it easy for them to take all the hard parts of the design, put them onto a computer-on-module, and automate all comparatively easy pieces, connected to power jacks, connectors, and all the forms of function that belong on the electronic device design. It worked out well for Gumstix, and then a lot of companies may or may not have modeled what we were doing; it may have been a design concept that came, but now it’s a few billion dollars a year industry. We were a tiny piece of that.
Johnson: And yet a vanguard.
Kruberg: At one point, I remember meeting a group of people in the Bay Area who had come with a comparable, because this is a few years ago, and they were selling a computer-on-module that was $9. We had decided that we weren’t going to compete in a race to the bottom for a standard product, but that we would take the other aspect of our business—the electronic design automation—and make that available widely. The high-value product that we had was not this one design COM, but it was the electronic automation and the electrical engineering behind customization that was the high value that we had.
Johnson: That makes it more obvious why you would be an Altium family member now. It’s not the hardware; it’s the software IP.
Kruberg: Exactly. We ended up taking all the work that we had done internally to make it easy for us to turn around the board; we put it online and called it Geppetto. Now, we have the original Gumstix hardware business, which is small, functional, and still tries to be at the vanguard of what’s going on with small hardware designs. We have the Geppetto service that we run, which supports Gumstix customization today. But the reason Altium bought us was so that we could take all the concepts that we’ve had. Think of it as digital continuity and automation of electrical engineering design principles so that it’s easy to design and then easy to realize a product.
And the whole idea all along, even if we look back 15 years ago, was to come up with a way to design something easily, and hit a “go button.” We’ve always called it the “go button.” Hit the “go button” and have an assembly of schematics, and layouts come together and then get expressed in a way that was easy to manufacture, or would automate for our electrical engineers all of the manufacturing processes.
Johnson: And yet the model that you’re working with is different.
Kruberg: It’s radically different. At the design phase, we try to encapsulate etching about the aspect of the design that is going to be important downstream. When we put together what we call a “Geppetto building block,” any one of the building blocks and modules that are on the Geppetto website in the library, each one is characterized by what its function is. Each one belongs to a functional group, and it’s a building block that has a functional characteristic.
Take accelerometers, for example. We have multiple accelerometers, and somebody can choose to put an accelerometer on a board. When they do that, they need to know that whatever the processor is going to support that. We embed in the interim models of all these designs things like what kind of software needs to run on that module. Before the schematic even gets put together, we have an idea of what kind of applications are going to run on the boards that are going to be built out of those building blocks. That allows us to look at digital continuity running from design intent at the beginning, all the way through to programming intent at the end, which is beyond the existing realization concept.
It’s not designing a schematic and the layout, but understanding the schematic, layout, documentation, device tree, or GPIO parameters that need to be put in place. It’s about testing concepts so that when somebody puts an accelerometer onto a board, they know that that board has to be tested in a particular way in order for the final board to be known to work. When we ship a board, we know that it works because we’ve already tested it.
Johnson: This makes the idea of functional properties orders of magnitude more meta. I’m struggling to figure out how to describe this (laughs.)
Kruberg: I recently gave a talk about this to a group where I knew that there were designers and programmers. By a show of hands, I asked one of the PCB designers who works at the schematic level, “Do you include device tree characteristics in with your schematic?” He said, “No,” and the answer is obvious because there is no place in a schematic to put device tree information. Then, I looked at the rest of the group and said, “How many of you are responsible for board bring up?” There were a number of people. “How many of you wish that your schematics included device tree information?” Everyone put up a hand, and a bunch of them laughed, because it’s so obvious to the programmer that this needed to be designed in at that beginning.
That’s part of what Geppetto does, and it’s part of the Geppetto architecture. In many ways, we think of it as building an object model, including a bunch of different objects in an object model of the design. Then, we have methods that we can apply, and those methods have to be things like board support package, which is the boot loader, and the device tree that gets programmed later. But it’s also about what the Gerbers are. And what’s the layout and schematic? People assemble a design, and then we express the layout/schematic. There’s still manual work that needs to be done. For instance, with layouts, we still need somebody to do the routing of different traces to make sure that’s done right. There’s some routing and QA that still needs to be done manually to make sure that Geppetto works. But for the most part, it reduces something that could be weeks of work into a few hours.
Johnson: I imagine the ideal space to be using this for a design team. Maybe they’re working on a larger system issue and need a circuit board for a particular function. They need to put most of their attention into the other stuff around the circuit board—wiring harnesses, mechanical, front panel, maybe an extreme environmental survival issue, etc. Perhaps the team’s perspective becomes, “Let’s throw together the modules, put them together, get the board done, and get onto this hard problem we’re trying to solve.” This “throw it together” mentality seems to be your user interface, I would think, in an almost literal sense.
Kruberg: We have observed that invention in device design now happens by people who write programs; they’re software programmers. Programmers will identify a challenge, solve it, test it out with a Raspberry Pi or Arduino, and say, “This works beautifully. Now, I need to build a device.” And the real intellectual property of these new devices, this whole IoT community, and the core IP of a company are the algorithms that run on a board; that board has to have certain sensors and effectors in particular positions in order for it to work well in a package. In many ways, the company views the software as the IP, and the industrial design as their IP and they don’t want to have to worry about what goes inside that nobody ever sees, as long as it runs the software and it fits the package.
That is our ideal customer, and they’re usually small. They’re working on IoT, creating devices that are increasingly what I could call “edge AI,” which is putting intelligence at the edge of the network. It’s still connected to the network but running algorithms on a reasonably capable processor. For the most part, those are our customers.
Johnson: I would suspect that those customers are nimble and also application-specific.
Kruberg: By definition, they are application-specific. This is for a vertical market hardware solution. If you think of markets for small electronic devices, cellphones sell by the millions. And somebody who is selling a product a million at a time gets value from Geppetto because we can get a prototype to them in a matter of three weeks. But we’re not going to get them the cost-optimized production board that they need to know that they’ve optimized their costs.
On the other hand, a medical device customer that’s producing 1,000 boards per year cares about having a high-quality product available immediately that fits in the right form factor. It does not necessarily make sense for them to spend half a million dollars optimizing for cost or function. They’re not going to try and save 15% of the cost of goods by redesigning.
Johnson: From a design perspective, this is pretty radical. What’s your business model for Geppetto?
Kruberg: Altium acquired Gumstix, a hardware company whose customers customize Gumstix standard products for their own purposes using Geppetto software. In the near future, the Geppetto system will not support Gumstix in building electronics, but will support other hardware companies, many of whom we’re already in discussions with, so that they can use the Geppetto tool to support their own hardware products.
Today, along with Altium’s support, we’re looking to drive the pace of innovation faster by doing for hardware design what happened years ago in software, where there is instant feedback as to whether or not your product works, you can make quick changes, and have a design cycle that is not six months but six days. Build a board, know the moment you conceive it that you can run your software on it, begin prototyping the software while you’re waiting three weeks to get hardware, and then you can put it in a 3D design case, and you have something in three weeks that is a launchable product. We’d like to see a three week or faster system prototype standard across the industry.
Johnson: This is something for designers to be watching for in the Altium product portfolio.
Kruberg: Geppetto will help bridge the gap between designers, hardware components, and manufacturing, which is what Altium is moving toward as a company.
Johnson: You are rather a proof of concept?
Kruberg: Yes. In many ways, Gumstix is the “concept car” that showcases what Geppetto is, and we’re looking to use Geppetto and support as many other hardware product vendors as we can.
Johnson: Geppetto would fit nicely as a method to input into Altium 365. What I’m hearing is that, as a designer, if I want to follow along with you, I should watch what’s happening with 365 and look for the Geppetto functionality as it grows and develops.
Kruberg: And don’t necessarily look for the name Geppetto in it. Altium is dedicated to supporting Altium Designer and Altium 365 in the ecosystem of production design. Think of Geppetto on the side, contributing as Altium users say, “We’d like that Gumstix or Geppetto feature in Altium Designer or available in Altium 365.” Altium will be listening to that. We are still going to be a concept car to see what works in this one corner case of design.
Gumstix does not have remotely the reach that Altium Designer does in terms of capabilities or functions. I characterize it by power domain— the one-watt to 10-watt domain. If somebody wants to build a quad-core tensor processing unit, we’re going to launch a quad-core with eight or 16 cameras on it and do a lot of node processing on the edge. We will have something like that, but Altium Designer is there for somebody who’s doing something far more complicated.
Johnson: Do you have any final thoughts on positioning Geppetto in the Altium ecosystem?
Kruberg: The highlights for me are Altium itself is business as usual on supporting Altium Designer, Altium 365, and the vision that Altium has always had. And Geppetto is a concept car that is relatively small, prototyping software concepts for use in the broader community as they become accepted and desirable. Things like the embedding of device tree information, device information, and documentation at the schematic layer, instead of post-hoc after the application and after the embedded system is built, are way better to consider that up front. It is important to have that distinction between Altium, this aircraft carrier that has its ecosystem, and this little runabout that is prototyping some new technologies that the carrier is going to say, “We need that on board.” Or the flyers are going to say, “We want that on the carrier because it’s going to make us more secure, efficient, etc.”
Johnson: Gordon, thank you. You nailed it.
Kruberg: My pleasure. This is fun. It’s a perfect environment for it too.
