Storing and retrieving locational data

A simple concept for storing and retrieving geographic data has been developed. It has been implemented in FORTRAN and BASIC and each package was developed for machine independence. The FORTRAN package is used for highway location studies and interpolating ground heights for highway design.     

一种基于软构件描述文本信息抽取的检索方法

通过对目前应用广泛的软构件检索技术的研究,提出了一种基于软构件描述文本信息抽取的检索方法。该方法利用中文分词技术和向量空间模型中"词频与倒文档频度"算法抽取关键词,通过《知网》语义相似度,计算用户需求与可重用软构件的匹配度,实现了对软构件的语义检索,能实现模糊查询,具有一定的张弛能力。     

AGORA: a search engine for software components

Using JavaBeans and CORBA agents in conjunction with Web search technologies, this prototype search engine (Agora), automatically generates and indexes a worldwide database of software products, classified by component model. Users of Agora can search for components in this database by describing specific properties of a component's interface. The system combines Web search engines with an introspection process. Introspection, primarily associated with JavaBeans, describes the capability of components to provide information about their own interfaces. The Common Object Request Broker Architecture offers a similar capability, although this data is maintained external to the CORBA server in an interface repository     

基于上下文相关的构件求精方法

为了有效地复用构件,首先提出了上下文有关的求精文法,并为此对上下文和上下文相关概念进行了重定义;接着将该文法引入到体系结构求精中,并从结构、行为、属性方面对构件求精进行了分析,然后为基于上下文有关的构件求精方法建立了模型,阐述了构件求精的过程;最后通过实例进一步说明了该求精方法。     

Knowledge-based repository scheme for storing and retrieving business components: a theoretical design and an empirical analysis

Component-based development (CDB) promises to reduce complexity and cost of software development and maintenance through reuse. For CBD to be successful, a vibrant market for commercial business components is essential. One of the key requirements of an active market for business components is an effective scheme for classifying and describing them at various levels of detail, as well as a corresponding repository for storing and retrieving these components. Such a scheme needs to support various constituents such as business users, managers, and application assemblers. The scheme and repository should help users and managers to select components that match their requirements and aid application assemblers in identifying components most compatible with their deployment environment (such as the platform) and system inputs (such as data types). Drawing from the concepts of group technology and software reuse paradigm, this paper proposes a scheme for classifying and describing business components and the design of a knowledge-based repository for their storage and retrieval. The proposed scheme is implemented in a prototype repository. The effectiveness of the prototype and the underlying classification and coding scheme is assessed empirically through controlled experiments. Results support the assertion that the scheme is effective in enhancing the users' and analysts' ability to find the needed business components.     

Using iterative refinement to find reusable software

Component libraries are the dominant paradigm for software reuse, but they suffer from a lack of tools that support the problem-solving process of locating relevant components. Most retrieval tools assume that retrieval is a simple matter of matching well-formed queries to a repository. But forming queries can be difficult. A designer's understanding of the problem evolves while searching for a component, and large repositories often use an esoteric vocabulary. CodeFinder is a retrieval system that combines retrieval by reformulation (which supports incremental query construction) and spreading activation (which retrieves items related to the query) to help users find information. I designed it to investigate the hypothesis that this design makes for a more effective retrieval system. My study confirmed that it was more helpful to users seeking relevant information with ill-defined tasks and vocabulary mismatches than other query systems. The study supports the hypothesis that combining techniques effectively satisfies the kind of information needs typically encountered in software design     

QoS-aware software components

The next generation of complex software systems will be highly distributed, component-based, and service-oriented. They will need to operate in unattended mode, possibly in hostile environments, and they'll be composed of many "replaceable" components discoverable at runtime. Moreover, they will have to run on a multitude of unknown and heterogeneous hardware and network platforms. Three major requirements for such systems are performance, availability, and security. Performance requirements imply that these systems must be adaptable and self-configurable to changes in workload intensity. Availability and security requirements suggest that these systems also must adapt and reconfigure themselves to withstand attacks and failures. This paper focuses specifically on QoS requirements for performance and describes the framework for QoS-aware distributed applications.     

A SystemC refinement methodology for embedded software

This article presents a design environment that provides an interface for user-written SystemC modules that model application software to make calls to a real-time operating system (RTOS) kernel and cosimulate with user-written SystemC hardware modules. The environment also facilitates successive refinement through three abstraction layers for hardware-software codesign suitable for embedded-system design.     

Analysis and refinement of software test data adequacy properties

Test data adequacy criteria are standards that can be applied to decide if enough testing has been performed. Previous research in software testing has suggested 11 fundamental properties which reasonable criteria should satisfy if the criteria make use of the structure of the program being tested. It is shown that there are several dependencies among the 11 properties making them questionable as a set of fundamental properties, and that the statements of the properties can be generalized so that they can be appropriately analyzed with respect to criteria that do not necessarily make use of the program's structure. An analysis that shows the relationships among the properties with respect to different classes of criteria which utilize the program structure and the specification in different ways is discussed. It is shown how the properties differ under the two models in order to maintain consistency that the dependencies are largely a result of five very weak existential properties, and that by modifying three of the properties, these weaknesses can be eliminated. The result is a reduced set of seven properties, each of which is strong from a mathematical perspective     

Testing software components for integration: a survey of issues and techniques

Component‐based development has emerged as a system engineering approach that promises rapid software development with fewer resources. Yet, improved reuse and reduced cost benefits from software components can only be achieved in practice if the components provide reliable services, thereby rendering component analysis and testing a key activity. This paper discusses various issues that can arise in component testing by the component user at the stage of its integration within the target system. The crucial problem is the lack of information for analysis and testing of externally developed components. Several testing techniques for component integration have recently been proposed. These techniques are surveyed here and classified according to a proposed set of relevant attributes. The paper thus provides a comprehensive overview which can be useful as introductory reading for newcomers in this research field, as well as to stimulate further investigation. Copyright © 2006 John Wiley & Sons, Ltd.     

A formal software development approach using refinement calculus

The advantage of COOZ(Complete Object-Oriented Z) is to specify large scale software,but it does not support refinement calculus.Thus its application is comfined for software development.Including refinement calculus into COOZ overcomes its disadvantage during design and implementation.The separation between the design and implementation for structure and notation is removed as well .Then the software can be developed smoothly in the same frame.The combination of COOZ and refinement calculus can build object-oriented frame,in which the specification in COOZ is refined stepwise to code by calculus.In this paper,the development model is established.which is based on COOZ and refinement calculus.Data refinement is harder to deal with in a refinement tool than ordinary algorithmic refinement,since data refinement usually has to be done on a large program component at once.As to the implementation technology of refinement calculus,the data refinement calculator is constructed and an approach for data refinement which is based on data refinement calculus and program window inference is offered.     

Certification of software components

Reuse is becoming one of the key areas in dealing with the cost and quality of software systems. An important issue is the reliability of the components, hence making certification of software components a critical area. The objective of this article is to try to describe methods that can be used to certify and measure the ability of software components to fulfil the reliability requirements placed on them. A usage modelling technique is presented, which can be used to formulate usage models for components. This technique will make it possible not only to certify the components, but also to certify the system containing the components. The usage model describes the usage from a structural point of view, which is complemented with a profile describing the expected usage in figures. The failure statistics from the usage test form the input of a hypothesis certification model, which makes it possible to certify a specific reliability level with a given degree of confidence. The certification model is the basis for deciding whether the component can be accepted, either for storage as a reusable component or for reuse. It is concluded that the proposed method makes it possible to certify software components, both when developing for and with reuse     

Testability of software components

The concept of domain testability of software is defined by applying the concepts of observability and controllability to software. It is shown that a domain-testable program does not exhibit any input-output inconsistencies and supports small test sets in which test outputs are easily understood. Metrics that can be used to assess the level of effort required in order to modify a program so that it is domain-testable are discussed. Assessing testability from program specifications and an experiment which shows that it takes less time to build and test a program developed from a domain-testable specification than a similar program developed from a nondomain-testable specification are also discussed     

Certifying off-the-shelf software components

Software components are often delivered in “black boxes” as executable objects whose licenses forbid decompilation back to source code. Often source code can be licensed, but the cost makes doing so prohibitive. We therefore have developed a methodology for determining the quality of off-the-shelf (OTS) components using a set of black box analyses. This methodology will provide developers with information useful for choosing components and for defending themselves legally against someone else's imperfect OTS components     

Performance-driven software development: an incremental refinement approach for high-quality requirement engineering

Requirements Engineering - By increasing the importance of the performance in industrial and business software systems, efficient approaches to model-based performance engineering are becoming an...     

Encapsulation of legacy software: A technique for reusing legacy software components

The following paper reviews the possibilities of encapsulating existing legacy software for reuse in new distributed architectures. It suggests wrapping as an alternative strategy to reengineering and redevelopment. It then defines the levels of granularity at which software can be encapsulated before going on to describe how to construct a wrapper and how to adapt host programs for wrapping. Some wrapping products are discussed and the state of the art summarized. The advantage of wrapping over conventional reengineering is the low cost and even lower risks involved. This is the driving force in the search for improved wrapping technology. This revised version was published online in June 2006 with corrections to the Cover Date.     

Encapsulation of legacy software: A technique for reusing legacy software components

The following paper reviews the possibilities of encapsulating existing legacy software for reuse in new distributed architectures. It suggests wrapping as an alternative strategy to reengineering and redevelopment. It then defines the levels of granularity at which software can be encapsulated before going on to describe how to construct a wrapper and how to adapt host programs for wrapping. Some wrapping products are discussed and the state of the art summarized. The advantage of wrapping over conventional reengineering is the low cost and even lower risks involved. This is the driving force in the search for improved wrapping technology.     

Identifying and qualifying reusable software components

Identification and qualification of reusable software based on software models and metrics is explored. Software metrics provide a way to automate the extraction of reusable software components from existing systems, reducing the amount of code that experts must analyze. Also, models and metrics permit feedback and improvement to make the extraction process fit a variety of environments. Some case studies are described to validate the experimental approach. They deal with only the identification phase and use a very simple model of a reusable code component, but the results show that automated techniques can reduce the amount of code that a domain expert needs to evaluate to identify reusable parts     

Dynamic linking of software components

Traditionally, dynamic linkers merely combined previously compiled pieces of code. Faster processors are now making outright code generation at load time practical, leading to cross-platform portability at very little extra cost. While the central idea behind dynamic linking is quite straightforward, it can be implemented through a surprising variety of strategies. The author contrasts three simple dynamic linking schemes with two much more elaborate strategies. The latter represent a workload shift from the compiler to the dynamic linker, just as dynamic linking itself represents a shift that moves the functions of a separate linker into the loader. Because the new techniques promise the profound additional benefit of cross-platform portability, they will most likely displace the currently popular linking-loader approach