Recently I read Chuck Moore's paper on Problem Oriented Languages and it inspired me to take a fresh minimalist approach to how I view my engineering design tools.
As an electronic engineer, I use on a daily basis, various computer tools to help me design electronic products. These include:
2D/3D Mechanical CAD
3D printer Applications
Most of these packages have their roots in the early 1980's - if not earlier, and over the intervening decades have grown to meet the available growth in computing power. Unfortunately, this has resulted in significant bloatware, and so really, these tools are not much better than they were 30 years ago.
So this got me thinking to what are the common features of these packages, and could they be rewritten for minimum bloat, so that they can run with acceptable performance on low specification machines?
So after some investigation I found a few open-source EDA (electronic design automation) tools, including KiCAD and gEDA.
At the heart of all these tools is a graphics drawing library, with line, polygon and primitive graphic drawing functions. These objects are represented in memory by their vertice co-ordinates and other parameters - such as colour, layer etc. Objects, once defined in memory may then be assigned to a group - allowing them to be manipulated as a single object - eg a pcb layour footprint of an IC package. Finally there is a routine to manipulate the position of these objects giving the means to move these objects around the screen.
What may appear to be a very sophisticated package, has as it's basis, three simple programs, and these programs could be shared across all the tools I have listed above.
Whilst a pcb layout package is often thought of as a simple 2D design tool, pcbs are built as a series of stacked layers, and so the package has the ability to create these various layers and manipulate them as a stack. Similarly a 2D drawing package, can be extended into 3D, by extruding 2D shapes along the z-axis. What is a 3D printed part, other than a whole series of 2D slices, stacked layer upon layer?
If you examine the way in which ICs are designed, they are also a series of 2D features, built into multiple layers of silicon and metalisation, and created by selective exposure of photo-resist by the use of photographic masks. In the same way that we design pcbs with layers of copper, ICs are designed with tools that lay down transistor structures in the silicon and connect them with metal interconnect layers.
This is a large oversimplification, but the point I am making is that the tools have very similar foundations, and as such could be written in a way that purposefully makes use of this common codebase. Once you have established a common graphical object representation and manipulation structure, the user interface and the file interchange format could also be standardised. In this way, possibly about 75% of the tool is common code, with an application layer built on top. The application layer would customise the tool for a specific task, such as schematic capture, pcb layout or 3D modelling, and as such would export the design data in an industry standard format - such as netlist, Gerber or G-code.
So a complete tool box of design tools could be written with a common open-source core, and standard open source file exchange formats.
The common core could be written to be fast and efficient, even on small resource limited systems such as the Raspberry Pi - so that for minimum outlay, youngsters could have their own open-source CAD workstation.
Harking back, in the very early 1990s, I did schematic capture and pcb layout design on an 25MHz i486 platfom - a Pi-2 should be approximately 100 times faster than that! (based on figures from Roy Longbottom's PC Benchmark Site).
With open source CAD tools running on a low cost platform - this would open up engineering CAD to a much wider population. Including those that arguably need it most - such as developing countries - who so far have been denied access to modern CAD tools on the grounds of cost - but who's economies would benefit so much from access to modern manufacturing methods such as community 3D printing and low cost pcb manufacture.
Conversely, the graphics core software could be ported to run (as OpenCL) on the ultra-quick GPU of a modern gaming platform - and allow blistering performance when rendering models in 3D.
This post may have described some Utopian outcome, but all the building blocks for good integrated open source CAD tools are in place. It just needs a group of collaborative software developers to make it happen.