I don’t like doing work more than once; if there is a chance that I will need to perform a task repeatedly, my approach is always to try to automate it. I am not alone in this; most software engineers I know are the same. Repeated tasks like collating information, testing, and integration are tedious and prone to error, and we should always try to automate them.

As a personal example, each day, I collate and analyze our product’s latest usage data. The first couple of days, I did this task manually, copying data from log files into a spreadsheet, then processing it to get the results I needed. It didn’t take long, only about 15 minutes each morning. But looking ahead, I could see that all those 15 mins added together would add up to about two weeks of effort each year. A few hours spent automating this task was well worth my invested time. In the end, I completely automated that task, integrating data collection, analysis, and display. Now I only have to launch a webpage to see the latest live data; 15 minutes has become 15 seconds. This not only saves me 15 minutes every morning but also allows me to check the data throughout the day and spot patterns or problems as they occur.

The software development world has taken this idea even further. Here at Pulsic, our development teams work in an almost fully automated environment. Smart code editors, called Integrated Development Environments or IDEs, autocomplete code, check the syntax, variable types, interfaces, and even the code style as the engineer types, highlighting errors and making suggestions. New code is compiled into an executable program at the touch of a button, a process that also simultaneously runs over 18,000 compile-time unit tests. Developers commit new code to a fully automated build and test system that runs a further 20,000 integration tests on each and every commit, all in under 10 minutes. Changesets that pass all the tests are automatically patched into the mainline code, and failing changesets are sent back to the developer with a detailed report of tests that failed.

This process is well known and widely used in software development and is called continuous integration (CI). The benefits of CI are widely documented, but one benefit that isn’t often mentioned is the saving in resources and the resulting increase in team productivity. In a team of 25 developers, saving each person just 15 minutes each day would free up one whole person’s effort, a resource that can be put to much better use developing new features. In reality, companies adopting CI often find productivity improves by 100%-200%.

Another massive advantage of automation is the benefit of immediate feedback. Problems can be identified and fixed quickly. Ten years ago, it was common for software companies to build and test overnight (or maybe just once a week). The problem with that approach was that when the tests failed, there may have been 30 changes to the codebase in the previous day, any of which might be the cause of the failures. The process of identifying the cause of the problems and untangling the changes could take hours. The fully automated process of continuous integration eliminates that time-consuming process almost entirely. The offending change-set is tested and rejected independently, and the other 29 changes are successfully integrated.

Unfortunately, this level of automation, and the benefits that follow, has not yet been realized in the world of analog IC design. The analog design community needs its equivalent of the continuous integration toolchain.

In recent years analog design tools have improved, circuit designers have faster simulators and better waveform viewers, and layout designers use features like templated layout and auto-abutment. These improvements are like the IDEs that developers use. They have improved the productivity of analog designers but have not delivered the size of improvement seen with the adoption of CI in software development.

The real benefits of automation come when the development process is automated from the source (in this case, circuit schematics) to the end (a verified layout). Today, designers already have many of the pieces of automation they need. Automatic circuit simulators, test benches, and waveform viewers can be integrated to give circuit designers rapid integration and test of designs at the front end. DRC tools and layout extraction engines provide a flow for simulation and verification of back-end layout.

However, there is a significant gap in the current toolchain, which prevents the design community from benefiting from continuous integration. The problem is the creation of a layout description from the circuit schematic. To understand the impact of this imagine developing software without a compiler. You would need engineers to write machine code to implement the C++ written by other engineers. For digital design, place-and-route tools bridge this step in the flow, but at present, no automated tools exist for analog design.

At Pulsic, we are working to close this gap. Our Animate Preview product automatically produces layout previews directly from the circuit schematic. Animate Preview doesn’t (yet) produce final quality layout but can already save designers many days of effort on each design. As in my initial example, these days of saved effort quickly add up and deliver a real boost in analog design productivity. Click here to learn more about Animate Preview.