II-06-02-Duncan-3D-Printing 423-424

3D printing and open source design

James Duncan¹

To imagine how 3D printing works you need to imagine slicing an object into thousands of layers. The print head extrudes material wherever material needs to be, and then moves on to the next layer, eventually building up enough material that a tangible, touchable, physical object is created. The idea is trivially simple, and advances in material science are making the field more accessible every day. Already, in labs around the world, we are printing electronics. Already we are printing plastics. It’s only a matter of time until the two are combined and these machines of the future appear in our homes. Assuming this future happens, we have to ask ourselves, “How does it change things?” One of the most startling impacts it has is the impact on the value-chain of modern life. Since the industrial age the value has been held by the people that own the factories. Their ability to make millions of the same item has provided a cheap, cost-effective supply. The person who provided the factory with the thing to make (the designer), has remained poorly compensated by comparison. One possible outcome of 3D printers in every home is that the designer becomes the holder of the value once again.

Of course, design can be copied, in the same way that software can. It exists as a concept, can be expressed digitally, and is therefore just as susceptible to the same pressures that software, music, movies, and other forms of media are. Will we see a similar open-source design effort? Perhaps, and to achieve that, our open-source designers of the future are going to need some tools of their own. Looking at Open Source software, it’s clear that the tools used by developers around the world are vital to their ability to share and collaborate. For example, the diff tool examines two pieces of source code or text, and describes their differences. This trivial piece of software is a key enabler of open source software. Without it, developers around the world would be reading through thousands of lines of code that another contributor had submitted, searching for the one or two lines in the file that may have changed. In order for to enable open source printable hardware, the emergence of a diff-like tool for 3D structures would be highly beneficial. Of course the differences between structures could be identified in a text-form using the current diff, but to be truly beneficial some mechanism of 3D visualization of differences in two objects would be of great importance.

As important to diff in the open source community, is the patch program. patch takes the output from diff and alters the original file to match the new one. The clever thing about this is that now instead of transferring large files between developers when a bug fix or a feature enhancement was made instead diffs could be applied to files. Something that was useful for the developer for expressing a change became a change—it altered diff beyond merely being a tool humans could understand to being a tool that the computer could understand. The communication and the action were one and the same thing. In order for our theoretical 3D diff to be useful we need it to be an action as well as a message.

Of course, it is possible to use the existing diff and patch tools on current cad models, but the main purpose behind these tools is communication and collaboration. In order to be truly useful a diff needs to be helpful in its own right. If I have a slot and tab arrangement on a physical object, understanding an alteration is much easier if I can see the slot to which my new tab will connect. I need to be able to understand the 3D diff without the benefit of the original file. I need to understand its function without the need to apply the patch.

The final tool that needs to be developed is a compiler. Compilers (the kinds that work with software), already make many decisions for developers—type information, register allocation and folding, optimizations, and so on. These are all things that are taken from the hands of developers and expressed by the compiler. In a world where hardware is as malleable as software there is no need for a hardware designer to be making decisions about whether function should exist in software or hardware. The “matter compilers” of the future will make these decisions for us.