Embedded.com Tech Focus Newsletter (8-6-12): Embedded software quality-new challenges, new tools - Embedded.com

Embedded.com Tech Focus Newsletter (8-6-12): Embedded software quality–new challenges, new tools


Embedded Newsletter for 08-06-2012

» Click here to view online I » Forward to a friend I » Sign up for an EE Times Newsletter

Share this Newsletter:

facebook linkedin twitter digg

August 6, 2012

Tech Focus: Embedded software quality – new challenges, new tools


On testing

Geospatial visualization helps manage million-line-plus embedded code bases

Verifying embedded software functionality: Why it's necessary

Tracing requirements through to object-code verification

Editor's Note

Bernard Cole Bernard Cole
Site Editor

In “On testing,” Jack Ganssle comes back to a favorite topic: better tools for achieving software code quality, including software testing and a wide range of tools for firmware metrics, design metrics and metrics for developers. Here are some recent design articles, white papers and webinars on some of the tools and strategies he discusses:

Tracing requirements through object code verification

The basics of embedded software testing
HW/SW co-verification basics

But breaking new ground on tools for embedded developers are my Editor's Top Picks:

Verifying embedded software functionality : Why it's necessary “, by Abhik Roychoudhury, in which he evaluates new techniques such as dynamic slicing, metric based fault localization and directed testing techniques for assessing software functionality.

Geospatial visualization helps manage million-line-plus code bases ,” by GrammaTech's Michael McDougall, John Von Seggern, Paul Anderson, David Cok and Ben Fleis. It uses code visualization for evaluating software dependency relationships with techniques developed originally for geospatial visualization. To learn more about this exciting new approach here are three additional technical papers that I recommend:

Visualization of Practices and Metrics
Software Visual Analytics of Program Structure and Metrics
Evospaces: Multi-dimensional navigation spaces for software evolution

Despite the range of tools, Jack remains pessimistic: “The quality movement – which unfortunately seems to have bypassed software engineering – showed us the importance of taking measurements to understand, first, how we're doing, and second, to see the first derivative of the former,” he writes. “Until software engineers embrace measurements, quality will be an ad hoc notion achieved sporadically.”

Design How-Tos

Geospatial visualization helps manage million-line-plus embedded code bases

This article describes an approach to visualizing large software dependency relationships using scalable and intuitive techniques developed originally for geospatial visualization.

Verifying embedded software functionality: Why it's necessary

In this six part series Abhik Roychoudhury, author of Embedded Systems and software validation,, explains why it is important for embedded developers to learn about new techniques for assessing software functionality. Part 1: what must be done and how to achieve it

Tracing requirements through to object-code verification

Verifying object code can mean the difference between success and failure, quality and crap. But skipping the step because a standard doesn't require it or because it theoretically eats into profits is a surprisingly common practice. The author postulates that this practice is not only shortsighted but no longer valid.

Combining Model-Driven and Model-Based Design in industrial and machine control

Two popular approaches to high level embedded design, model-based development using Simulink and model based design using UML/SysML can be used effectively in a wide range of robotic and machine control systems.

The basics of embedded software testing: Part 1

This two part article covers the basics of testing and test case development and points out details unique to embedded systems work along the way. Part1: Basics of embedded software testing.

Why automated software testing fails and pitfalls to avoid–Part I

This excerpt from Chapter 4 of the book, “Implementing Automated Software Testing”, analyzes the issue of why so many AST efforts fail and how to avoid some of the pitfalls. Misperceptions surrounding AST are also clarified. Part I begins with approaching AST in a realistic manner.

Transitioning from code-based to model-driven software testing: Part 1

In a three part tutorial Moshe Cohen of Telelogic describes the new UML 2.0 Testing profile and how it can be used to extend traditional code-centric Test Case development into modeling Test Architectures and Test case behaviors, faster and with fewer resources.

How to use new unit testing tools & techniques to improve software quality

Long used mainly in high integrity environments, new unit test tools can now also streamline and improve the quality and reliability of mainstream, less critical environments, even those involving undocumented legacy code.

Doing C code unit testing on a shoestring: Part 1- The basics and the tools

In a three part article, Ark Khasin describes a new way to use the pre-processor in your standards-compliant C compiler for unit testing for safety specs such as IEC 61508. First up: unit testing requirements and what you will need.

HW/SW co-verification basics: Part 4 – Co-verification metrics

In this four part series, Jason Andrews details the importance of co-verification of both hardware and software in embedded system design and provides details on the various ways to achieve this. Part 4: Co-verification metrics.

Debugger performance matters: The importance of good metrics

A brief tutorial on debugging complex embedded systems designs by Green Hills' Anderson MacKay on the importance of collecting and assessing debug metrics and properly interpreting and implementing the results.

Think static analysis cures all ills? Think again.

Here's how to choose the right code-analysis tools for your project.

Using static code analysis for Agile software development

Since the goal of Agile development is to have working software early, source code analysis enables developers to analyze the quality and security of code from day one of coding ” one of the earliest points in the software development process

Static analysis vs. dynamic testing – No competition!

In software development, static analysis and dynamic testing are two different ways of detecting defects. Unfortunately they are too often thought of as competition for one another, and developers are sometimes encouraged to favor one to the exclusion of the other

Using formal methods for sophisticated static code analysis

In this Product How-To design article, Jay Abraham of Mathworks uses the company's Polyspace code verifier to explain the use formal methods-based static code analysis to ensure high quality and verifiable embedded software.

Agile embedded software development

Developers flee engineering for marketing and management. Why? Big processes are not delivering, and neither is coding chaos. This author says Agile helps address the problems of late projects, high defect levels, and stressed teams.

Automated tools streamline software test and certification

In this Product How-To Jared Fry and Shan Bhattacharya of LDRA describe how the company's tool suite can be used to analyze code to trace requirements, identify and fix standards violations, monitor code coverage, and rapidly and effectively bring reliable products to market.

2012 Embedded Market Survey webinar

UBM Electronics' 17th annual survey of embedded systems designers worldwide shows trends in software and hardware usage. The 2012 Embedded Market Survey also looks at languages, productivity, and the challenges design teams rank as most important. A webinar on Friday April 20 will examine the results from over 1,700 respondents from across the embedded industry, the dataset enables a deep analysis to track key changes in this important electronics industry segment. There will also be the opportunity to ask questions online. To register click here .


LDRA tool suite integrates MISRA AC for verification of auto-generated code

LDRA's MISRA AC provides independent verification of the auto-generated code, a critical factor in stringent certification requirements.

Embedded software: Mathworks adds formal methods

Adding formal design methods to its widely used Simulink model-based design suite, The Mathworks Inc. has introduced the Simulink Design Verifier, which generates tests and proves properties for models from the company's Simulink simulation platform and Stateflow design and simulation tool.

SOFTWARE TOOLS: New suite provides End-to-End Software Verification

LDRA has just launched v8.0 of the software verification tool suite, claiming it is the first fully automated end-to-end solution for software verification support.

GrammaTech CodeSonar and Lattix LDM integration enhances architecture management for complex C/C++ systems

GrammaTech, Inc. and Lattix Inc. have teamed to integrate GrammaTech CodeSonar and Lattix LDM. The new CodeSonar integration with Lattix provides precise and accurate architecture analysis to enable teams to review, refactor and maintain the architecture of complex C/C++ software systems.

Getting FAST about Android software testing

Wind River Helps Overcome Hurdles in Software Testing to Speed Android Device Development


On testing

Testing is important. But it's just one quality gate.

Firmware Metrics

Few of us collect metrics. That's not what engineering is all about.

On design metrics

It's all about people, process, and good data.

Metrics for Developers

Metrics can be used for good or ill, but they work best as a window into the development process. They're not very effective for evaluating people.

Analogies for software development

We have rotten tools. At best they give us only a crude analogy about our code. The future holds more visceral visualizations.


Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.