A replicated and refined empirical study of the use of friends in C++ software

The friend mechanism is widely used in C++ software even though the potential benefits of its use are disputed and little is known about when, where and why it is employed in practice. Furthermore, there is limited empirical analysis of its impact in object-oriented software, with only one study (Counsell and Newson, 2000) reported at journal level.This paper aims to add to the empirical evidence of friendship’s impact by replicating Counsell and Newson (2000)’s original study. The study’s design is refined to improve the construct validity of the evaluation and a larger cohort of systems is used to improve the generalisability of the results. The findings suggest that classes involved in friendship are coupling hotspots and that there is no link between inheritance and friendship, contrary to the findings presented in Counsell and Newson (2000). The findings also suggest that the use of friends in a class is independent of the number of hidden members in a class.     

C++的一种并发扩充方案*

该文给出了一种对C++进行并发扩充的方案.它基于这样的并发面向对象模型：系统由一组自治的并发对象构成,对象可以有一个体,一旦对象被创建,对象体就开始执行;对象间采用同步消息传递,允许对象内部的并发;对象的并发控制分散在各方法的激励条件中.文章还给出了一种转换策略,把扩充的C++描述转换成C++描述,使之能被现有的C++编译器识别.转换中利用了某些多任务操作系统(如Windows 95)所提供的多线程和同步设施.     

MCNP Output Data Analysis with ROOT (MODAR)

MCNP Output Data Analysis with ROOT (MODAR) is a tool based on CERN's ROOT software. MODAR has been designed to handle time-energy data issued by MCNP simulations of neutron inspection devices using the associated particle technique. MODAR exploits ROOT's Graphical User Interface and functionalities to visualize and process MCNP simulation results in a fast and user-friendly way. MODAR allows to take into account the detection system time resolution (which is not possible with MCNP) as well as detectors energy response function and counting statistics in a straightforward way.

Program summary

Program title: MODARCatalogue identifier: AEGA_v1_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEGA_v1_0.htmlProgram obtainable from: CPC Program Library, Queen's University, Belfast, N. IrelandLicensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.htmlNo. of lines in distributed program, including test data, etc.: 155 373No. of bytes in distributed program, including test data, etc.: 14 815 461Distribution format: tar.gzProgramming language: C++Computer: Most Unix workstations and PCOperating system: Most Unix systems, Linux and windows, provided the ROOT package has been installed. Examples where tested under Suse Linux and Windows XP.RAM: Depends on the size of the MCNP output file. The example presented in the article, which involves three two-dimensional 139×740 bins histograms, allocates about 60 MB. These data are running under ROOT and include consumption by ROOT itself.Classification: 17.6External routines: ROOT version 5.24.00 (http://root.cern.ch/drupal/)Nature of problem: The output of an MCNP simulation is an ASCII file. The data processing is usually performed by copying and pasting the relevant parts of the ASCII file into Microsoft Excel. Such an approach is satisfactory when the quantity of data is small but is not efficient when the size of the simulated data is large, for example when time-energy correlations are studied in detail such as in problems involving the associated particle technique. In addition, since the finite time resolution of the simulated detector cannot be modeled with MCNP, systems in which time-energy correlation is crucial cannot be described in a satisfactory way. Finally, realistic particle energy deposit in detectors is calculated with MCNP in a two-step process involving type-5 then type-8 tallies. In the first step, the photon flux energy spectrum associated to a time region is selected and serves as a source energy distribution for the second step. Thus, several files must be manipulated before getting the result, which can be time consuming if one needs to study several time regions or different detectors performances. In the same way, modeling counting statistics obtained in a limited acquisition time requires several steps and can also be time consuming.Solution method: In order to overcome the previous limitations, the MODAR C++ code has been written to make use of CERN's ROOT data analysis software. MCNP output data are read from the MCNP output file with dedicated routines. Two-dimensional histograms are filled and can be handled efficiently within the ROOT framework. To keep a user friendly analysis tool, all processing and data display can be done by means of ROOT Graphical User Interface. Specific routines have been written to include detectors finite time resolution and energy response function as well as counting statistics in a straightforward way.Additional comments: The possibility of adding tallies has also been incorporated in MODAR in order to describe systems in which the signal from several detectors can be summed. Moreover, MODAR can be adapted to handle other problems involving two-dimensional data.Running time: The CPU time needed to smear a two-dimensional histogram depends on the size of the histogram. In the presented example, the time-energy smearing of one of the 139×740 two-dimensional histograms takes 3 minutes with a DELL computer equipped with INTEL Core 2.     

A component-oriented framework for experimental computer graphics

This paper provides a report about a framework that uses a variety of standards. Readers interested in 3D computer graphics or component-oriented technology in C++ will find a report about the integration of various standards by relying on yet another standard for component-oriented software engineering. The highly successful Java standard called Open Services Gateway initiative (OSGi) is employed in a C++ implementation called Open Service Platform.The application of this standard, which is primarily focused on network-centric software and embedded systems, in the field of real-time 3D computer graphics, provides novel insights into the usability of the OSGi standard.     

Making C++ objects persistent: The hidden pointers

C++ objects of types that have virtual functions or virtual base classes contain volatile (‘memory’) pointers. We call such pointers ‘hidden pointers’ because they were not specified by the user. If such C++ objects are made persistent, then these pointers become invalid across program invocations. We encountered this problem in our implementation of O++, which is a database language based on C++. O++ extends C++ with the ability to create and access persistent objects. In this paper, we describe the hidden pointers problem in detail and present several solutions to it. Our solutions are elegant in that they do not require modifying the C++ compiler or the semantics of C++. We also discuss another problem that arises because C++ allows base class pointers to point to derived class objects. C++ has emerged as the de facto standard language for software development, and database systems based on C++ have attracted much attention. We hope that the details and techniques presented will be useful to database researchers and to implementors of object-oriented database systems based on C++.     

The impact of programming paradigms on the efficiency of an individual-based simulation model

We look in detail at an individual-based simulation of the spread of barley yellow dwarf virus. The need for a very large number of individual plants and aphids along with multiple runs using different model parameters mean that it is important to keep memory and processor requirements within reasonable bounds. We present implementations of the model in both imperative and object-oriented programming languages, particularly noting aspects relating to ease of implementation and runtime performance. Finally, we attempt to quantify the cost of some of the decisions made in terms of their memory and processor time requirements.     

面向对象度量—MOOD算法集及其应用分析

面向对象软件的主要特性包括抽象性、封装性、继承性和多态性等。本文在分析这些特性的基础上,介绍了一种能对这些特性进行全面度量的算法集,并对这种算法集在实际应用中可能出现的问题进行了分析,提出了一些新的观点。     

用VC语言实现工控软件的开发及微机配料软件的设计

系统的介绍了Windows操作系统下用Visual C 编制工控软件的实现方法,说明了定时器、人机交互、位图等在工控软件的作用。并介绍了用Visual C 进行微机配料系统软件的设计。     

ROOT — A C++ framework for petabyte data storage, statistical analysis and visualization

A new stable version (“production version”) v5.28.00 of ROOT [1] has been published [2]. It features several major improvements in many areas, most noteworthy data storage performance as well as statistics and graphics features. Some of these improvements have already been predicted in the original publication Antcheva et al. (2009) [3]. This version will be maintained for at least 6 months; new minor revisions (“patch releases”) will be published [4] to solve problems reported with this version.

New version program summary

Program title: ROOTCatalogue identifier: AEFA_v2_0Program summary URL:http://cpc.cs.qub.ac.uk/summaries/AEFA_v2_0.htmlProgram obtainable from: CPC Program Library, Queen?s University, Belfast, N. IrelandLicensing provisions: GNU Lesser Public License v.2.1No. of lines in distributed program, including test data, etc.: 2 934 693No. of bytes in distributed program, including test data, etc.: 1009Distribution format: tar.gzProgramming language: C++Computer: Intel i386, Intel x86-64, Motorola PPC, Sun Sparc, HP PA-RISCOperating system: GNU/Linux, Windows XP/Vista/7, Mac OS X, FreeBSD, OpenBSD, Solaris, HP-UX, AIXHas the code been vectorized or parallelized?: YesRAM: > 55 MbytesClassification: 4, 9, 11.9, 14Catalogue identifier of previous version: AEFA_v1_0Journal reference of previous version: Comput. Phys. Commun. 180 (2009) 2499Does the new version supersede the previous version?: YesNature of problem: Storage, analysis and visualization of scientific dataSolution method: Object store, wide range of analysis algorithms and visualization methodsReasons for new version: Added features and corrections of deficienciesSummary of revisions: The release notes at http://root.cern.ch/root/v528/Version528.news.html give a module-oriented overview of the changes in v5.28.00. Highlights include

• • 

  File format Reading of TTrees has been improved dramatically with respect to CPU time (30%) and notably with respect to disk space.

• • 

  Histograms A new TEfficiency class has been provided to handle the calculation of efficiencies and their uncertainties, TH2Poly for polygon-shaped bins (e.g. maps), TKDE for kernel density estimation, and TSVDUnfold for singular value decomposition.

• • 

  Graphics Kerning is now supported in TLatex, PostScript and PDF; a table of contents can be added to PDF files. A new font provides italic symbols. A TPad containing GL can be stored in a binary (i.e. non-vector) image file; add support for full-scene anti-aliasing. Usability enhancements to EVE.

• • 

  Math New interfaces for generating random number according to a given distribution, goodness of fit tests of unbinned data, binning multidimensional data, and several advanced statistical functions were added.

• • 

  RooFit Introduction of HistFactory; major additions to RooStats.

• • 

  TMVA Updated to version 4.1.0, adding e.g. the support for simultaneous classification of multiple output classes for several multivariate methods.

• • 

  PROOF Many new features, adding to PROOF?s usability, plus improvements and fixes.

• • 

  PyROOT Support of Python 3 has been added.

• • 

  Tutorials Several new tutorials were provided for above new features (notably RooStats).

A detailed list of all the changes is available at http://root.cern.ch/root/htmldoc/examples/V5.Additional comments: For an up-to-date author list see: http://root.cern.ch/drupal/content/root-development-team and http://root.cern.ch/drupal/content/former-root-developers.The distribution file for this program is over 30 Mbytes and therefore is not delivered directly when download or E-mail is requested. Instead a html file giving details of how the program can be obtained is sent.Running time: Depending on the data size and complexity of analysis algorithms.References:

• [1] 

  http://root.cern.ch.

• [2] 

  http://root.cern.ch/drupal/content/production-version-528.

• [3] 

  I. Antcheva, M. Ballintijn, B. Bellenot, M. Biskup, R. Brun, N. Buncic, Ph. Canal, D. Casadei, O. Couet, V. Fine, L. Franco, G. Ganis, A. Gheata, D. Gonzalez Maline, M. Goto, J. Iwaszkiewicz, A. Kreshuk, D. Marcos Segura, R. Maunder, L. Moneta, A. Naumann, E. Offermann, V. Onuchin, S. Panacek, F. Rademakers, P. Russo, M. Tadel, ROOT — A C++ framework for petabyte data storage, statistical analysis and visualization, Comput. Phys. Commun. 180 (2009) 2499.

• [4] 

  http://root.cern.ch/drupal/content/root-version-v5-28-00-patch-release-notes.

     

A software complexity model of object-oriented systems

A model for the emerging area of software complexity measurement of OO systems is required for the integration of measures defined by various researchers and to provide a framework for continued investigation. We present a model, based in the literature of OO systems and software complexity for structured systems. The model defines the software complexity of OO systems at the variable, method, object, and system levels. At each level, measures are identified that account for the cohesion and coupling aspects of the system. Users of OO techniques perceptions of complexity provide support for the levels and measures.     

面向对象有限元程序的研究

阐述了采用面向对象的方法和ＶＣ＋＋语言,进行结构问题有限元程序开发的过程。建立了一般线弹性体结构有限元分析类库,并与过程化语言的程序设计方法进行了分析比较,说明面向对象方法改善了有限元程序的维护性和扩充性,为开发工程计算程序提供了一种新途径。     

An Object-Oriented Toolbox for Spectral Element Analysis

A common bottleneck for numericists is the complexity of the implementation programs. The usual procedural programming approach demands time and effort to program, develop, and test new formulations. This article addresses a particularly involved subject area, that of spectral element methods with mortars for large-scale applications. It is shown that the implementation burden can be alleviated by resorting to an object-oriented design approach. A toolbox consisting of a set of object-oriented classes is discussed. In order to solve a particular problem at hand, the user proceeds by creating an application where he/she loosely activates objects of the classes. When an operation exceeds the functionalities of the classes, the user can enrich these classes or create new ones. Practical examples are provided. Issues concerning computational efficiency and concurrent execution are addressed.     

指挥自动化系统的软件开发策略

总结了指挥自动化系统应用软件的新特征,阐述了开发这种软件所面临的新问题,并提出了新的开发思路.     

基于依赖性的面向对象软件不同层面的测试用例生成

由于面向对象软件本身的特点,传统的面向过程的软件测试方法不再适用于面向对象的软件测试。在分析了面向对象软件测试的特征以及面向对象软件中各个不同层面的依赖关系的基础上,提出了针对各个不同层面上的测试用例生成的方法。     

Empirical comparison of three metrics suites for fault prediction in packages of object-oriented systems: A case study of Eclipse

Packages are important high-level organizational units for large object-oriented systems. Package-level metrics characterize the attributes of packages such as size, complexity, and coupling. There is a need for empirical evidence to support the collection of these metrics and using them as early indicators of some important external software quality attributes. In this paper, three suites of package-level metrics (Martin, MOOD and CK) are evaluated and compared empirically in predicting the number of pre-release faults and the number of post-release faults in packages. Eclipse, one of the largest open source systems, is used as a case study. The results indicate that the prediction models that are based on Martin suite are more accurate than those that are based on MOOD and CK suites across releases of Eclipse.     

Programming with C++ concepts

This paper explores the definition, applications, and limitations of concepts and concept maps in C++, with a focus on library composition. We also compare and contrast concepts to adaptation mechanisms in other languages.Efficient, non-intrusive adaptation mechanisms are essential when adapting data structures to a library’s API. Development with reusable components is a widely practiced method of building software. Components vary in form, ranging from source code to non-modifiable binary libraries. The Concepts language features, slated to appear in the next version of C++, have been designed with such compositions in mind, promising an improved ability to create generic, non-intrusive, efficient, and identity-preserving adapters.We report on two cases of data structure adaptation between different libraries, and illustrate best practices and idioms. First, we adapt GUI widgets from several libraries, with differing APIs, for use with a generic layout engine. We further develop this example to describe the run-time concept idiom, extending the applicability of concepts to domains where run-time polymorphism is required. Second, we compose an image processing library and a graph algorithm library, by making use of a transparent adaptation layer, enabling the efficient application of graph algorithms to the image processing domain. We use the adaptation layer to realize a few key algorithms, and report little or no performance degradation.     

Reusability through fine-grain inheritance

Object-oriented languages are often promoted as encouraging the production of flexible, reusable software. Unfortunately, experience suggests that although individual classes may be reusable, large class libraries seem to lack flexibility in the face of circumstances unforeseen by the designer. This paper explores the problems associated with flexibility and reuse in large libraries, and shows how fine-grain inheritance can alleviate some of these problems. A methodology for designing fine-grain inheritance graphs is proposed and a detailed case study is presented.     

深入剖析VC++教与学的关键点

VC++因其使用便利,功能强大,类库及其函数丰富,而成为广泛采用的开发平台。然而,熟练掌握VC++并非易事,大量开发人员的水平仅仅只是停留在表层。文章从逻辑体系和结构体系的高度总结了VC++教与学的关键点,可供相关人员借鉴参考。     

Implementing concurrent C

Concurrent C (C++) is a parallel superset of C (C++). Versions of Concurrent C have now been implemented for a variety of uniprocessors and multiprocessors. We first implemented a uniprocessor version of Concurrent C correctly anticipating that it would be relatively easy to extend the uniprocessor implementation to run on multiprocessors. Concurrent C is translated to C. The generated C code contains calls to the C library implementing the Concurrent C run-time system. This paper describes the ‘hard core’ details of the Concurrent C implementation: the specifics of process states, the data structures used, the library functions, and the C code generated for various Concurrent C constructs. We also give an overview of the Concurrent C facilities and of the uniprocessor, distributed and shared-memory multiprocessor implementations.