540 research outputs found
Retrieving function components from a reuse library.
Increasing software development productivity is not enough to close the gap between the software demands in industry and software that can be provided in practice. Software reuse is claimed to be the only realistic approach to solve this problem [17]. As the reusable components are growing, we are faced the challenge of modulating, structuring and storing these components into reuse library so as to achieve faster and effective retrieval for reuse. In this thesis we investigate an approach of structuring a function library and an efficient type-based retrieval method based on this structured library. In searching for functions, the trivial difference of the argument order of a function is disregarded. The library structuring is based on component grouping and component linking based on reusability relations among components. A prototype system WISER was also developed as a tool for achieving exact matched retrieval as well as relaxed matched retrieval. WISER also allows users to browse the structured library as an aid in finding potentially reusable components. Paper copy at Leddy Library: Theses & Major Papers - Basement, West Bldg. / Call Number: Thesis1998 .A55. Source: Masters Abstracts International, Volume: 39-02, page: 0524. Adviser: Young G. Park. Thesis (M.Sc.)--University of Windsor (Canada), 1998
The C Object System: Using C as a High-Level Object-Oriented Language
The C Object System (Cos) is a small C library which implements high-level
concepts available in Clos, Objc and other object-oriented programming
languages: uniform object model (class, meta-class and property-metaclass),
generic functions, multi-methods, delegation, properties, exceptions, contracts
and closures. Cos relies on the programmable capabilities of the C programming
language to extend its syntax and to implement the aforementioned concepts as
first-class objects. Cos aims at satisfying several general principles like
simplicity, extensibility, reusability, efficiency and portability which are
rarely met in a single programming language. Its design is tuned to provide
efficient and portable implementation of message multi-dispatch and message
multi-forwarding which are the heart of code extensibility and reusability.
With COS features in hand, software should become as flexible and extensible as
with scripting languages and as efficient and portable as expected with C
programming. Likewise, Cos concepts should significantly simplify adaptive and
aspect-oriented programming as well as distributed and service-oriented
computingComment: 18
Neural network-based retrieval from software reuse repositories
A significant hurdle confronts the software reuser attempting to select candidate components from a software repository - discriminating between those components without resorting to inspection of the implementation(s). We outline an approach to this problem based upon neural networks which avoids requiring the repository administrators to define a conceptual closeness graph for the classification vocabulary
A Systematic Aspect-Oriented Refactoring and Testing Strategy, and its Application to JHotDraw
Aspect oriented programming aims at achieving better modularization for a
system's crosscutting concerns in order to improve its key quality attributes,
such as evolvability and reusability. Consequently, the adoption of
aspect-oriented techniques in existing (legacy) software systems is of interest
to remediate software aging. The refactoring of existing systems to employ
aspect-orientation will be considerably eased by a systematic approach that
will ensure a safe and consistent migration.
In this paper, we propose a refactoring and testing strategy that supports
such an approach and consider issues of behavior conservation and (incremental)
integration of the aspect-oriented solution with the original system. The
strategy is applied to the JHotDraw open source project and illustrated on a
group of selected concerns. Finally, we abstract from the case study and
present a number of generic refactorings which contribute to an incremental
aspect-oriented refactoring process and associate particular types of
crosscutting concerns to the model and features of the employed aspect
language. The contributions of this paper are both in the area of supporting
migration towards aspect-oriented solutions and supporting the development of
aspect languages that are better suited for such migrations.Comment: 25 page
Using neural networks in software repositories
The first topic is an exploration of the use of neural network techniques to improve the effectiveness of retrieval in software repositories. The second topic relates to a series of experiments conducted to evaluate the feasibility of using adaptive neural networks as a means of deriving (or more specifically, learning) measures on software. Taken together, these two efforts illuminate a very promising mechanism supporting software infrastructures - one based upon a flexible and responsive technology
Domain oriented object reuse based on genetic software architectures.
In this thesis, a new systematic approach is introduced for developing software systems from domain-oriented components. The approach is called Domain Oriented Object Reuse (DOOR) which is based on domain analysis and Generic Software Architectures. The term 'Generic Software Architectures' is used to denote a new technique for building domain reference architectures using architecture schemas. The architecture schemas are used to model the components behaviour and dependency. Components dependencies describe components behaviour in terms of their inter-relationships within the same domain scope. DOOR uses the architecture schemas as a mechanism for specifying design conceptions within the modelled domain. Such conceptions provide design decisions and solutions to domain-specific problems which may be applied in the development of new systems. Previous research in the area of domain analysis and component-oriented reuse has established the need for a systematic approach to component-oriented development which emphasises the presentation side of the solution in the technology. DOOR addresses the presentation issue by organising the domain knowledge into levels of abstractions known to DOOR as sub-domains. These levels are organised in a hierarchical taxonomy tree which contains, in addition to sub-domains, a collection of reusable assets associated with each level. The tree determines the scope of reuse for every domain asset and the boundaries for their application. Thus, DOOR also answers the questions of reuse scope and domain boundaries which have also been raised by the reuse community. DOOR's reuse process combines development for reuse and development with reuse together. With this process, which is supported by a set of integrated tools, a number of guidelines have been introduced to assist in modelling the domain assets and assessing their reusability. The tools are also used for automatic assessment of the domain architecture and the design conceptions of its schemas. Furthermore, when a new system is synthesised, components are retrieved, with the assistance of the tools, according to the scope of reuse within which the system is developed. The retrieval procedure uses the components dependencies for tracing and retrieving the relevant components for the required abstraction
Designing Software Architectures As a Composition of Specializations of Knowledge Domains
This paper summarizes our experimental research and software development activities in designing robust, adaptable and reusable software architectures. Several years ago, based on our previous experiences in object-oriented software development, we made the following assumption: ‘A software architecture should be a composition of specializations of knowledge domains’. To verify this assumption we carried out three pilot projects. In addition to the application of some popular domain analysis techniques such as use cases, we identified the invariant compositional structures of the software architectures and the related knowledge domains. Knowledge domains define the boundaries of the adaptability and reusability capabilities of software systems. Next, knowledge domains were mapped to object-oriented concepts. We experienced that some aspects of knowledge could not be directly modeled in terms of object-oriented concepts. In this paper we describe our approach, the pilot projects, the experienced problems and the adopted solutions for realizing the software architectures. We conclude the paper with the lessons that we learned from this experience
- …