Designing and developing software tools for engineers is hard enough. Now take it   commercial and make a viable business out of it. Expand your development team beyond the critical mass of about five people, and the process needs to be formalized, managed and documented. There’s a lot of features being added and bugs being fixed in response to customer requests. It’s getting harder to test and manage product versions and code branches. Time to add a solid suite of scripted tests that can run continuously to ensure that the product is stable. More development, more management, more difficult.

Great, you’ve managed to hire the right people to get the process running smoothly, code is pumping through the system, tests are passing and your customers are reaping the benefits of your always-improving product. What’s that? Somebody wants to run your product on what platform? Add developers, add hardware, add support, add more canned tests that can run across the board. Feed the monster.

For Pointwise, the monster’s appetite has grown steadily over time. The daily grind of development requires us to:

• build and test multiple code branches, both in debug and optimized modes
• build and test on multiple platforms (Windows, Linux, Mac OS X)
• build and test on multiple architectures (32- and 64-bit processors)
• build and test every night, including the generation of summary reports by email
• quickly identify the cause of a test or build failure, or a notable change in performance

Glyph Scripting Enables Automated Testing

Several years ago, when Gridgen was our flagship product and Pointwise was just a glimmer of hope in the eyes of our development staff, all of these hurdles had already been cleared. The Glyph scripting language not only empowered users to customize their meshing operations, but it also allowed us to write an expansive set of tests that were run every night to ensure that all the latest code changes didn’t break something. All of these tests ran on every supported platform every night of the week, and the results were available for review the next morning.

Since Pointwise also has a rich scripting language, it was fairly straightforward to adapt the old nightly build-test-report system, which was based on some shell scripts, some Perl scripts, and some custom reporting tools. However, in the way Pointwise changed the way meshing is done, it also introduced some new requirements for automated builds and tests that the old system just couldn’t handle. For one thing, the old system only reported when a build or a test failed, and didn’t provide any metrics that could, for example, indicate a looming performance issue in the code. What to do? Spend valuable development time and resources to revamp the old system? Bring in contracted development just for this purpose? Ouch, management won’t like that on the bottom line.

Feed the Beast with TeamCity

Luckily for us, there are some commercially available products that address needs just like this. We evaluated a few of these, but none stood out quite as well as TeamCity in terms of its performance, ease of use, support and cost effectiveness. TeamCity not only allowed us to quickly switch from the old build/test system (it took me less than a day to get the evaluation installed and a full build and test suite configured and running), but also expanded the range of capabilities without really doing anything special to our code or the test scripts.

Pointwise uses TeamCity to build released software

TeamCity consists of a Java-based server and agents. The server coordinates the work (build or test) to be done, and the agents do the grunt work. Since it’s Java-based, installation was painless and extremely simple on every platform. In fact, for non-Windows platforms, TeamCity server will even take care of installing and configuring the agents! The best part: it’s free to use up to three agents, and not unbearably expensive beyond that.

TeamCity allows us to:

• build multiple code branches on all the platforms we support
• distribute builds for the same platform across all available build agents
• schedule a build or test at any frequency, or run a build or test on demand with a click of one button
• monitor test results for performance issues over time, using some slick built-in graphic capabilities
  

  TeamCity presents historical test peformance graphically and in tabular form

• Quickly isolate and identify build issues, including the source code change that caused the failure (and yes, the developer who caused it)
• Archive build and test results for as long (or briefly) as we desire
• Easily upgrade and add build agents to the mix

In effect, TeamCity allows us to focus more time and effort on the things that really matter: developing the tools that you need. If you’re developing software systems that could benefit from continuous integration tools across a variety of platforms, we highly recommend a gander at TeamCity!