143,867 research outputs found
An Investigation of Modular Dependencies in Aspects, Features and Classes
The essence of software design is to construct well-defined, encapsulated modules that are composed together to build the desired software application. There are several design paradigms in use today, including traditional Object-Oriented Programming (OOP), Feature-Oriented Programming (FOP), Aspect-Oriented Programming (AOP) and Instance-Oriented Programming (IOP). FOP studies the modularity of features in product lines, where a feature is an increment in program functionality. AOP aims to separate and modularize aspects when an aspect is a crosscutting concern. IOP, as an extension to FOP, makes the layers work like object factories. While each is good at solving different types of problems, they are closely related. The composition of modules is complicated because modules have (often hidden) dependencies on other modules. This thesis aims to better understand the way dependencies are managed by each approach. Based on this, we focus on the precedence issue in AOP and FOP, that is, how designers are able to specify the order by which modules are composed together. Different precedence means different semantics, but the current tools can not guarantee the correct precedence is adopted. We first solve the precedence issue separately for AOP and FOP, then based on this, we come up with a unified model to solve the precedence issue by using source code annotations to specify the precedence. We evaluate our technique with use cases
Diligence of Domain Engineering in Accounting Management System
This paper presents on domain feature modeling, domain architecture design and domain implementation in an enterprise. This paper demonstrates the accounting management feature modeling based on the extended (Feature-Oriented Domain Analysis) FODA method and system architecture of accounting management domain, integrates Aspect Object Oriented Programming technology with domain implementation, and designs a whippersnapper AOP framework based on the object proxy pattern to separates crosscutting concerns in the domain implementation phrase. Research result shows this method can effectively seal insulate and abstract variability in requirements of accounting management domain, instruct the designing and implementation of accounting management components, get the requirement of software reuse, resource sharing and collaboration in accounting management domain
Can Programming be Liberated from the Two-Level Style? Multi-Level Programming with DeepJava
Since the introduction of object-oriented programming few programming languages have attempted to provide programmers with more than objects and classes, i.e., more than two levels. Those that did, almost exclusively aimed at describing language properties—i.e., their metaclasses exert linguistic control on language concepts and mechanisms— often in order to make the language extensible. In terms of supporting logical domain classification levels, however, they are still limited to two levels. In this paper we conservatively extend the object-oriented programming paradigm to feature an unbounded number of domain classification levels. We can therefore avoid the introduction of accidental complexity into programs caused by accommodating multiple domain levels within only two programming levels. We present a corresponding language design featuring “deep instantiation ” and demonstrate its features with a running example. Finally, we outline the implementation of our compiler prototype and discuss the potentials of further developing our language design
An Instance-Oriented Approach to Constructing Product Lines from Layers
The Model/View/Controller (MVC) paradigm, and its many variants, is a cornerstone of decoupling within object-oriented design. MVC leads to clear reuse benefits regarding the class hierarchies for the model and view elements. In practice, however, the controllers appear to defy reuse, most likely because they encapsulate specialized business logic. Within an effective product line, however, such specialized logic must be reused. We combine the MVC paradigm with feature-oriented programming (FOP) to produce a novel instance-oriented design pattern for layers that brings reusability back to controllers. We demonstrate the effectiveness of our approach using a product-line example of a solitaire game engine
A Feature-Oriented Software Engineering Approach to Integrate ASSISTments with Learning Management Systems
Object-Oriented Programming (OOP), in the past two decades, has become the most influential and dominant programming paradigm for developing large and complex software systems. With OOP, developers can rely on design patterns that are widely accepted as solutions for recurring problems and used to develop flexible, reusable and modular software. However, recent studies have shown that Objected-Oriented Abstractions are not able to modularize these pattern concerns and tend to lead to programs with poor modularity. Feature-Oriented Programming (FOP) is an extension of OOP that aims to improve the modularity and to support software variability in OOP by refining classes and methods. In this thesis, based upon the work of integrating an online tutor systems, ASSISTments, with other online learning management systems, we evaluate FOP with respect to modularity. This proof-of-concept effort demonstrates how to reduce the effort in designing integration code
A single representation to support assembly and process planning in feature-based design machined parts
The need for a product model that can support the modelling requirements of a broad
range of applications leads to the application of a feature-based model within a computer aided
design environment. An important requirement in feature-based design for manufacture is that a
single feature representation should be capable of concurrently supporting a number of different
applications. Assembly and process planning are seen as two crucial manufacturing applications and
a formal structure for their representation in a feature-based design system is presented. This
research addresses two basic questions relating to the lack of a unified definition for features and the
establishment of a feature-based representation for assembly. Thus the concept of designing with
features is extended by incorporating assembly and process planning information with the geometrical
and topological details of component parts. A prototype system has been implemented using an
object-oriented programming technique which provides a convenient method for adding functionality
to the geometric reasoning process of features and the complex relationships between the parts
that make up the assembly. The feature-based model is embedded in the ACIS object-oriented solid
modeller kernel
Transforming sequences using threaded morphisms.
Sequences are very useful structures in programming languages. Functional programming languages allow the convenient definition of transformations between sequence algebras and other types of data algebra. Sequence homomorphisms are an important class of such transformations. However, not all desired transformations can be expressed as homomorphisms. This paper describes a class of transformation which is a generalisation of homomorphisms: sequence morphisms with threads. This class is shown to contain a number of interesting sub-classes of transformation. The morphisms are described using a simple functional programming language and are applied to the design and implementation of a simple object-oriented programming language feature
Automated extraction of knowledge for model-based diagnostics
The concept of accessing computer aided design (CAD) design databases and extracting a process model automatically is investigated as a possible source for the generation of knowledge bases for model-based reasoning systems. The resulting system, referred to as automated knowledge generation (AKG), uses an object-oriented programming structure and constraint techniques as well as internal database of component descriptions to generate a frame-based structure that describes the model. The procedure has been designed to be general enough to be easily coupled to CAD systems that feature a database capable of providing label and connectivity data from the drawn system. The AKG system is capable of defining knowledge bases in formats required by various model-based reasoning tools
- …