Using LabVIEW in Projects Requiring CMMI® Compliance

As companies face developing higher-quality software in shorter time periods, there has been a growing trend to implement measurable software quality processes such as CMMI and ISO 9001. CMMI certification is becoming a requirement for companies in a number of industries, including military/aerospace. When correctly implemented, CMMI, a guideline that describes a continuous improvement process, can provide useful and measurable software quality and productivity benefits.

This document discusses CMMI and defines how you can use National Instruments LabVIEW within CMMI frameworks.

Introduction to CMMI

The United States Department of Defense established the Software Engineering Institute (SEI) at Carnegie Mellon University to advance the practice of software engineering. In 1987, the SEI, with collaboration from many industry and military companies, created the first version of its Capability Maturity Model for Software (CMM). Later, it developed models for related processes, such as systems engineering and software-supplier sourcing. In 1998, it formed the Capability Maturity Model Integration (CMMI) project to combine and improve the existing process-improvement models. CMMI provides guidance for improving an organization’s processes and its ability to manage product or service development, acquisition, and maintenance. By using CMMI, companies appraise their organizational maturity and establish and implement improvement priorities.

CMMI offers a variety of approaches, called “models", and consequently, an organization must decide which CMMI model best fits its process improvement needs. The CMMI Systems Engineering and Software Engineering (CMMI-SE/SW) model provides disciplines for projects based on NI LabVIEW. Choosing a representation for the CMMI-SE/SW model largely depends on your organization’s requirements. With the continuous representation, you can select which process areas are best suited for continuous improvement and pursue them in any order. The staged representation is designed to provide maximum benefit through a sequence of stages.

In addition to CMMI models, CMMI also defines maturity levels. Each maturity level, from level 1 through level 5, defines the many software development process phases (specification, design and development, verification and validation, maintenance, and more), and each level progressively defines more requirements that your organization must achieve for compliance within that maturity level. For example, level 2 compliance requires that your organization establish basic project management processes to track cost, schedule, and functionality. Level 3 compliance requires that you have a documented, standardized, and integrated software process and that all projects use an approved version of the process for developing and maintaining software.

Reasons for Implementing CMMI

Over-budget projects, missed deadlines, and lower-than-expected quality are all indications that your organization may be in need of process improvements. These process improvements often fit into one of the following areas – project management, configuration management, requirements management, and quality assurance:

Project Management – Signs of poor project management include difficulty quantifying development progress and inconsistent estimates and results between projects or people. When projects surpass deadlines, project management is usually the first place managers investigate; however, often, it is not the only problem.

Configuration Management – Configuration management is defined as project item control (code, configuration files, test plans, requirements, project planning documents including reviews and action items, and process guidelines) from design through retirement. Signs of poor configuration management include previously fixed bugs returning, software changes being overwritten, inconsistencies between two “identical” systems, and the inability to duplicate or modify software in the future. Additional signs include an inability to track and complete action items from reviews or decision meetings.

Requirements Management – Common problems with requirements management include poorly defined requirements, lack of change notification, lack of bidirectional traceability, and an inability to accurately assess change impact.

Quality Assurance – Signs of poor quality assurance processes, including software and system verification and validation, are poor test coverage, inaccurate software fault or bug tracking, and bugs found during the implementation phase rather than in the testing phase.

Problems in these areas typically result from the lack of a software development process. When working on small applications that do not require multiple resources, often, it is easy to handle design, development, and release. For example, you may maintain requirements in your head and build the system directly on the production stand. As you modify requirements, you then make the appropriate changes to the stand. However, as your organization adds more developers to a team, and as applications grow in size and complexity, problems begin occurring due to the lack of a formal development process.

CMMI aims to remove the problems identified above, and therefore reduce costs, decrease development time, and increase finished-product quality.

For more information on CMMI, visit http://www.sei.cmu.edu/cmmi/.

CMMI Implementation with LabVIEW Development

Because many organizations are currently interested in CMMI Level 3 certification, this document focuses on these requirements. It is important to remember that CMMI is a process definition, so you are not required to use specific tools during software development. Rather, it is important that you have a defined process that you follow and track. The sections below describe how to be successful in completing each phase with projects developed in LabVIEW and how LabVIEW provides useful features that help in these phases.

Overall Development Schedule Management

To manage an overall software development process schedule, you may choose to use a something as simple as a spreadsheet file for very small projects or a project management tool with more functionality, such as MS Project. These specialty tools can display Gantt charts depicting start and end times, task interdependencies, resources allocated, and more.

Requirements and Specifications

You should carefully describe and track specific project requirements throughout the development process. Requirements are system functions and behavior statements for users and operators. A specification is a listing of specific, measurable, behavioral system constraints that satisfy system requirements.

For simple projects, you may choose to use a standard word processor or spreadsheet to list and track requirements and specifications. For larger projects containing many dependencies, you may be required to use a dedicated requirements-management tool, such as Telelogic DOORS or IBM Requisite Pro. In addition, tools such as VISTA from VI Engineering also have requirements-tracking abilities specifically for LabVIEW. You can use these tools to track all requirements in a project throughout the development lifecycle, and to show development completion percentage, test coverage, and more. Because these tools are not part of a specific development language, you can use them with a variety of programming environments.

Design

In the design phase, you need to specify a high-level view of what the application does to accomplish the requirements outlined. In this phase, you identify the technologies that you are developing. It is also common to track risk associated with various parts of the development and define plans to mitigate those risks. Typically, you do not develop code during this phase; instead, you create outlines of how the code will work. It is important to remember that CMMI just requires that you follow a design process, but it does not require that you use specific tools. Your process might include hand-drawing a flowchart of how you are developing your application and saving the drawings. You also can use more formal tools, including Universal Modeling Language (UML), to design your application. Regardless of which method you use, LabVIEW provides several tools that help in creating your software outline.

LabVIEW is the ideal starting point for designing user interfaces, as you can quickly create user interface screens and verify that they contain the expected functionality. In addition, because LabVIEW is a graphical development environment and because VIs represent functions of code, LabVIEW is a good tool to provide a high-level view of what a program does. By starting with your main application VI, you can use top-down design to describe its behavior at the highest level. By defining VI connector panes (without yet writing graphical code), your outline shows how data is passed through the application. This graphically represents how your application functions, without investing time in actually putting the functionality together. Because your high-level design is already in LabVIEW, you have skeleton code ready when you move to the development phase. Note that LabVIEW also contains many useful documentation features to help maintain accurate documentation about application design.

National Instruments provides additional helpful tools during the design phase. You can use the LabVIEW State Diagram Toolkit to create a high-level graphical representation of any state-machine application. In addition, because this toolkit is completely integrated with LabVIEW, your representation generates the actual state-machine code (VIs). In addition, as you change your state machine, the toolkit automatically updates the generated code to match the new functionality.

Another toolkit that is often useful during design is the Graphical Object-Oriented Programming (GOOP) toolkit. This toolkit is available FREE at ni.com, or you can purchase an upgraded version from VI Engineering (www.viengineering.com) or Endevo (www.endevo.se). With this toolkit, you can create object classes and define the relationships between them. Because this toolkit uses LabVIEW code, using it is similar to creating unprogrammed VIs as shells, with the main difference being that the toolkit helps you build your class hierarchy and define class dependencies.

Development

Because CMMI is programming-language agnostic, you successfully can use LabVIEW for application development. During development, it is important to have adequate control over your requirements, design documentation, and source code. For this reason, integration with revision-control tools is important in a good software development process. With LabVIEW, you have direct connectivity with some of the best commercially available revision-control tools, including Perforce and Visual SourceSafe. With this integration, you can use just one source code management tool for all of your development, including applications you build in other programming languages.

If you are looking for help in building applications and tracking how complete your development process is, you can use configuration management tools. The VISTA tools from VI Engineering combine configuration management, source-code control, and requirements management to make it easier to comply with CMMI guidelines.

Testing

After your application is complete, CMMI requires that you inspect the software to show that it functions correctly. Often referred to as verification and validation, this process involves testing the code to eliminate as many bugs as possible and show that the software does everything you designed it to do. While CMMI does not specify that you use a particular software testing tool, testing entirely by hand is almost inconceivable; most organizations automate software testing to some degree. LabVIEW is very useful for this – it has long been known as a laboratory and manufacturing test tool, and it is equally strong in software test. The LabVIEW sophisticated programming flexibility, debugging tools, and powerful report-generation capabilities, as well as many other inherent features, make it easy to develop and debug applications.

Furthermore, because you can use LabVIEW to highlight individual execution steps, you can visually inspect the program as it executes. The LabVIEW interactive run-time debugger helps you track application execution and quickly identify reasons why a program is not behaving as expected.

The built-in VI Profiler tool helps evaluate application performance by measuring where the application spends time and allocates memory during execution. Thus, this tool is useful in debugging an application to discover where it may be functioning improperly.

To improve your LabVIEW code quality, National Instruments offers the VI Analyzer Toolkit to inspect developed code and check for conformance to the defined programming standards you choose. This comprehensive test set analyzes everything from the front panel to the block diagram and documentation. You can interactively configure tests to track down a difficult bug, or you can automate the tests so you can build a repeatable code-inspection tool and run it on each software version you check into your source-code control tools.

Ship and Maintain

While not required for CMMI compliance, you might choose to deliver your finished software in a customer-friendly package. The LabVIEW Application Builder provides the technology to build repeatable DLLs and executables. In addition, using the LabVIEW Application Builder, you can create software installers so that the user has a reliable and convenient application-installation experience.

The last phase that CMMI covers is software maintenance. Without a good software development process, it is estimated that 80 percent of the total time spent in software development is spent in maintaining the application. Working on fixes for your application almost never creates new revenue and also appropriates time that you could spend working on new products. Therefore, it is important to minimize the time you spend in this phase. As with all of the other phases, CMMI does not specify tools that you must use, so you can track bug reports from customers by hand and keep written reports to maintain the application and use in making further improvements. However, most companies opt to formally track maintenance issues through a database or dedicated bug-tracking software tool.

Summary

A primary advantage of having a well-defined software development process guided by CMMI is that it reduces the amount of effort and time you put into maintaining your application, which can otherwise consume valuable time and resources. Clearly, you can use LabVIEW within a CMMI-driven development process and take advantage of its features and tools to streamline software development and improve overall software quality.

Reader Comments | Submit a comment »

Nice Job!
Very nice article! It was very usefull. Since it talks about improvemment, i suggest more commentaries about the diffcult and challenges involving the implemmentation of CMMi in LabView enviromment.
- William Robert Heinrich, Funda???#o CPqD. heinrich@cpqd.com.br - Feb 27, 2007