244 research outputs found
Attribute based component design: Supporting model driven development in CbSE
In analysing the evolution of Software Engineering, the scale of the components has increased, the requirements for different domains become complex and a variety of different component frameworks and their associated models have emerged. Many modern component frameworks provide enterprise level facilities and services, such as instance management, and component container support, that allow developers to apply if needed to manage scale and complexity. Although the services provided by these frameworks are common, they have different models and implementation. Accordingly, the main problem is, when developing a component based application using a component framework, the design of the components becomes tightly integrated with the framework implementation and the framework model is embedded in the component functionality, and hence reduces reusability. Another problem arose is, the designers must have in-depth knowledge of the implementation of a component framework to be able to model, design and implement the components and take advantages of the services provided. To address these problems, this research proposes the Attribute based Component Design (AbCD) approach which allows developers to model software using logical and abstract components at the specification level. The components encapsulate the provided functionality, as well as the required services, runtime requirements and interaction models using a set of attributes. These attributes are systemically derived by grouping common features and services from light weight component frameworks and heavy weight component frameworks that are available in the literature. The AbCD approach consists of the AbCD Meta-model, which is an extension of the บML meta-model, and the Component Design Guidelines (CDG) that includes core Component based Software Engineering principles to assist the modelling process for designers. To support the AbCD approach, an implementation has been developed as a set of plug-ins, called the AbCD tool suite, for Eclipse IDE. An evaluation of the AbCD approach is conducted by using the tool suite with two case studies. The first case study focuses on abstraction achieved by the AbCD approach and the second focuses on reusability of the components. The evaluation shows that the artefacts produced using the approach provide an alternative architectural view to the design and help to re-factor the design based on aspects. At the same time the evaluation process identified possible improvements in the AbCD meta-model and the tool suite constructed. This research provides a non-invasive approach for designing component based software using model driven development
Recommended from our members
Towards an aspect weaving BPEL engine
This position paper proposes the use of dynamic aspects and
the visitor design pattern to obtain a highly configurable and
extensible BPEL engine. Using these two techniques, the
core of this infrastructural software can be customised to
meet new requirements and add features such as debugging,
execution monitoring, or changing to another Web Service
selection policy. Additionally, it can easily be extended to
cope with customer-specific BPEL extensions. We propose
the use of dynamic aspects not only on the engine itself
but also on the workflow in order to tackle the problems of
Web Service hot deployment and hot fixes to long running
processes. In this way, composing aWeb Service "on-the-fly"
means weaving its choreography interface into the workflow
Services in pervasive computing environments : from design to delivery
The work presented in this thesis is based on the assumption that modern computer technologies are already potentially pervasive: CPUs are embedded in any sort of device; RAM and storage memory of a modern PDA is comparable to those of a ten years ago Unix workstation; Wi-Fi, GPRS, UMTS are leveraging the development of the wireless Internet. Nevertheless, computing is not pervasive because we do not have a clear conceptual model of the pervasive computer and we have not tools, methodologies, and middleware to write and to seamlessly deliver at once services over a multitude of heterogeneous devices and different delivery contexts. Our thesis addresses these issues starting from the analysis of forces in a pervasive computing environment: user mobility, user profile, user position, and device profile. The conceptual model, or metaphor, we use to drive our work is to consider the environment as surrounded by a multitude of services and objects and devices as the communicating gates between the real world and the virtual dimension of pervasive computing around us. Our thesis is thus built upon three main “pillars”. The first pillar is a domain-object-driven methodology which allows developer to abstract from low level details of the final delivery platform, and provides the user with the ability to access services in a multi-channel way. The rationale is that domain objects are self-contained pieces of software able to represent data and to compute functions and procedures. Our approach fills the gap between users and domain objects building an appropriate user interface which is both adapted to the domain object and to the end user device. As example, we present how to design, implement and deliver an electronic mail application over various platforms. The second pillar of this thesis analyzes in more details the forces that make direct object manipulation inadequate in a pervasive context. These forces are the user profile, the device profile, the context of use, and the combinatorial explosion of domain objects. From the analysis of the electronic mail application presented as example, we notice that according to the end user device, or according to particular circumstances during the access to the service (for instance if the user access the service by the interactive TV while he is having his breakfast) some functionalities are not compulsory and do not fit an adequate task sequence. So we decided to make task models explicit in the design of a service and to integrate the capability to automatically generate user interfaces for domain objects with the formal definition of task models adapted to the final delivery context. Finally, the third pillar of our thesis is about the lifecycle of services in a pervasive computing environment. Our solutions are based upon an existing framework, the Jini connection technology, and enrich this framework with new services and architectures for the deployment and discovery of services, for the user session management, and for the management of offline agents
Challenges for the comprehensive management of cloud services in a PaaS framework
The 4CaaSt project aims at developing a PaaS framework that enables flexible definition, marketing, deployment and management of Cloud-based services and applications. The major innovations proposed by 4CaaSt are the blueprint and its lifecycle management, a one stop shop for Cloud services and a PaaS level resource management featuring elasticity. 4CaaSt also provides a portfolio of ready to use Cloud native services and Cloud-aware immigrant technologies
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
Properties for Component Model: The definition Perspective
The presence of a large number of component models to date should be able to offer software developers a wide variety of component models -- which they can easily choose from -- for their software development projects. However, the opposite situation is currently observed, where the presence of many component models has caused difficulties in making the selection. Lack of properties or characteristics that can be used as a basis to perform objective comparison between the existing models is believed to have caused the difficulties. In this paper, a list of component model properties is derived by thoroughly examining the available component model definitions. Results from a comparative analysis performed on six component models using the properties show that the properties enable a more objective comparison between the existing component models to be performed
Advances in component-oriented programming
WCOP 2006 is the eleventh event in a series of highly successful
workshops, which took place in conjunction with every ECOOP
since 1996. Component oriented programming (COP) has been
described as the natural extension of object-oriented
programming to the realm of independently extensible
systems. Several important approaches have emerged over the
recent years, including component technology standards, such as
CORBA/CCM, COM/COM+, J2EE/EJB, and .NET, but also the increasing
appreciation of software architecture for component-based
systems, and the consequent effects on organizational processes
and structures as well as the software development business as a
whole.
COP aims at producing software components for a component market
and for late composition. Composers are third parties, possibly
the end users, who are not able or willing to change components.
This requires standards to allow independently created
components to interoperate, and specifications that put the
composer into the position to decide what can be composed under
which conditions. On these grounds, WCOP\u2796 led to the following
definition: "A component is a unit of composition with
contractually specified interfaces and explicit context
dependencies only. Components can be deployed independently and
are subject to composition by third parties."
After WCOP\u2796 focused on the fundamental terminology of COP, the
subsequent workshops expanded into the many related facets of
component software. WCOP 2006 emphasizes reasons for using
components beyond reuse. While considering software components
as a technical means to increase software reuse, other reasons
for investing into component technology tend to be overseen. For
example, components play an important role in frameworks and
product-lines to enable configurability (even if no component is
reused). Another role of components beyond reuse is to increase
the predictability of the properties of a system. The use of
components as contractually specified building blocks restricts
the degrees of freedom during software development compared to
classic line-by-line programming. This restriction is beneficial
for the predictability of system properties. For an engineering
approach to software design, it is important to understand the
implications of design decisions on a system\u27s properties.
Therefore, approaches to evaluate and predict properties of
systems by analyzing its components and its architecture are of
high interest.
To strengthen the relation between architectural descriptions of
systems and components, a comprehensible mapping to
component-oriented middleware platforms is important.
Model-driven development with its use of generators can
provide a suitable link between architectural views and
technical component execution platforms.
WCOP 2006 accepted 13 papers, which are organised according to
the program below. The organisers are looking forward to an
inspiring and thought provoking workshop. The organisers thank
Jens Happe and Michael Kuperberg for preparing
the proceedings volume
- …