An architecture for generic extensions

All engineering disciplines rely on standard components to design and build artifacts. The key technical challenge in software engineering is to enable the adoption of such a model to the development of software. The transformation from line-by-line development to component-based development will address many of the industry's persistent productivity and quality problems. Indeed, component-based software development has been a long-standing dream of the software industry, prompting a search for both technical and nontechnical solutions. A successful approach to component-based development requires a comprehensive solution that draws on advances in programming languages, programming paradigms, algorithm analysis, and software design. This paper presents an approach based on the C++ Standard Template Library. More than a traditional library, STL embodies a concrete approach to software design based on a well-defined taxonomy and theory of software components. I present the fundamental contributions of STL to a paradigm of component programming — a component-based software development paradigm in which there is a clear separation between component development and application development. I motivate component programming, give the requirements for components and catalogs, and give an example of component programming applied to the standard Keyword in Context (KWIC) problem. I then summarize the implications of component programming for the software industry and for software engineering education.

A complete traversal of a container C (such as a set) is informally described by the iteration scheme for x in C F(x,C) where F is a function that might possibly modify C by inserting new elements into it. We assume that the order in which the elements are treated is not relevant, as long as the iteration continues until F has been applied to all elements currently in C, including those F has inserted. Standard iteration mechanisms, such as the iterators provided in the C++ Standard Template Library (STL), do not directly support complete traversals. In this paper we present two approaches to complete traversals, both extending the STL framework, one by means of generic algorithms and the other by means of a container adaptor.

In my last column (see ibid., January/February 2001), I talked about a notational device for matrix algebra called tensor diagrams. This time I write some C++ code to symbolically evaluate these quantities. This gives me a chance to play with some as yet untried features in the C++ standard library, such as strings and standard template library (STL) container classes.

Standard iteration mechanisms, even ones of such generality as those in the C++ Standard Template Library (STL), do not allow insertions to be made in a container during a traversal of the container. Since ad hoc ways of handling such iterations are tedious to program and error-prone, programmers should ideally have at their command an efficient generic solution. In earlier work we formally characterized the complete traversal problem and presented generic solutions by means of two generic algorithms and a container adaptor, all defined within the STL framework. Here we develop additional theory for reasoning about complete traversals and address the question of how general the complete traversal problem is by showing that it subsumes well-known graph (or relation) problems such as reachability and transitive closure.

This tutorial gives an overview of the C++ standard template library (STL), including its overall structure, functionality, and capabilities. Particular emphasis is placed on the ways in which STL ...

A functional style of programming has become common in C++, following the introduction of the Standard Template Library (STL) into C++'s standard library. C++ is, however, notably lacking in its support for this style and thus cannot take full advantage of its own standard libraries. C++'s mechanisms for defining functions or objects to pass to STL algorithms are overly verbose. The effective use of modern C++ libraries calls for lambda functions in the language.This paper describes a design and implementation of built-in lambda functions for C++. C++'s compilation model, where activation records are maintained in a stack, and the lack of automatic object lifetime management, make safe lambda functions and closures challenging: if a closure outlives its scope of definition, references stored in a closure dangle. Our design is careful to balance between conciseness of syntax and explicit annotations to guarantee safety.Lambda functions can be declared without annotating their parameter types. C++0x, the forthcoming revision of standard C++, supports constrained templates and modular type checking. We describe how to infer parameter types of lambda functions from the constraints of generic functions in order to support modular type checking in the presence of lambda functions. Our design is currently under consideration for adoption to C++0x.

Generic libraries, such as the C++ Standard Template Library (STL), provide flexible, high-performance algorithms and datatypes, along with functional specifications and guarantees. It is left as a nontrivial task to the library user to choose appropriate algorithms and data types for a particular problem. In the present paper, we describe an automatic analysis to aid library users in selecting types for use in generic programs. The analysis is based on manipulation and comparison of symbolic complexity expressions, constructed using cost-bound functions and abstract interpretation of program behaviour. Our analysis serves to detect and rectify performance bugs by recommending type selections that will improve performance.

We present DASH, a C++ template library that offers distributed data structures and parallel algorithms and implements a compiler-free PGAS (partitioned global address space) approach. DASH offers many productivity and performance features such as global-view data structures, efficient support for the owner-computes model, flexible multidimensional data distribution schemes and interoperability with STL (standard template library) algorithms. DASH also features a flexible representation of the parallel target machine and allows the exploitation of several hierarchically organized levels of locality through a concept of Teams. We evaluate DASH on a number of benchmark applications and we port a scientific proxy application using the MPI two-sided model to DASH. We find that DASH offers excellent productivity and performance and demonstrate scalability up to 9800 cores.

Since the Standard Template Library (STL), generic libraries in C++ rely on concepts to precisely specify the requirements of generic algorithms (function templates) on their parameters (template arguments). Modifying the definition of a concept even slightly, can have a potentially large impact on the (interfaces of the) entire library. In particular the non-local effects of a change, however, make its impact difficult to determine by hand. In this paper we propose a conceptual change impact analysis (CCIA), which determines the impact of changes of the conceptual specification of a generic library. The analysis is organized in a pipe-and-filter manner, where the first stage finds any kind of impact, the second stage various specific kinds of impact. Both stages describe reachability algorithms, which operate on a conceptual dependence graph. In a case study, we apply CCIA to a new proposal for STL iterator concepts, which is under review by the C++ standardization committee. The analysis shows a number of unexpected incompatibilities and, for certain STL algorithms, a loss of genericity.

A short example of a Windows® application is modified to use the generic containers, iterators, and function adapters of the C++ Standard Template Library. Comparison is made with the containers and iteration mechanism provided by the Microsoft Foundation Classes.

This paper describes a suite of laboratory experiments for a CS2 course. The main thrust of the experiments is to promote an understanding of a container-class library: the Standard Template Library for C++ or the Java Generic Library for Java. All of the experiments are stored on the World Wide Web, and students have considerable latitude on when each experiment must be completed.

This paper describes a suite of laboratory experiments for a CS2 course. The main thrust of the experiments is to promote an understanding of a container-class library: the Standard Template Library for C++ or the Java Generic Library for Java. All of the experiments are stored on the World Wide Web, and students have considerable latitude on when each experiment must be completed.

Traditional static checking centers around finding bugs in programs by isolating cases where the language has been used incorrectly. These language‐based checkers do not understand the semantics of software libraries, and therefore cannot be used to detect errors in the use of libraries. In this paper, we introduce STLlint, a program analysis we have implemented for the C++ Standard Template Library and similar, generic software libraries, and we present the general approach that underlies STLlint. We show that static checking of library semantics differs greatly from checking of language semantics, requiring new representations of program behavior and new algorithms. Major challenges include checking the use of generic algorithms, loop analysis for interfaces, and organizing behavioral specifications for extensibility. Copyright © 2005 John Wiley & Sons, Ltd.

In the west inland of China, construction of large-span bridges become more and used, but in the existing anti-wind specification there is not the explicit values of strong wind characteristic parameters for inland areas influenced by complex mountainous region. Considering the phenomenon that the study on field measurement of turbulence characteristics has not yet been developed and combining the cable-stayed bridge with span 352m in the western gap of valley areas, a data processing system of wind speed observation based on Borland C++ Builder is compiled. The system can quickly and intelligently realize the statistical analysis of wind field monitoring data by the integration with standard template library (STL) which is defined as vector in C++. The paper presents program function, structure and development thoughts. Through the analysis for one-year field measured data, strong wind characteristics such as, the mean wind velocity, direction, turbulence intensity, gust factor and turbulence integral length are obtained. The results of the analysis provide the bases for wind tunnel test, flutter and buffeting analysis and wind load calculation and the results are compared with those of numerical simulation by FLUENT. The reliability and efficiency are confirmed.

Boost provides a collection of free peer-reviewed portable C++ source libraries that work well with, and are in the same spirit as, the C++ Standard Template Library (Stl). The Boost Graph Library (Bgl) [198], which is one of the libraries in the collection, offers an extensive set of generic graph-algorithms.