237 research outputs found
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
Survey of Technologies for Web Application Development
Web-based application developers face a dizzying array of platforms,
languages, frameworks and technical artifacts to choose from. We survey,
classify, and compare technologies supporting Web application development. The
classification is based on (1) foundational technologies; (2)integration with
other information sources; and (3) dynamic content generation. We further
survey and classify software engineering techniques and tools that have been
adopted from traditional programming into Web programming. We conclude that,
although the infrastructure problems of the Web have largely been solved, the
cacophony of technologies for Web-based applications reflects the lack of a
solid model tailored for this domain.Comment: 43 page
Multilanguage Semantic Interoperability in Distributed Applications
JOSI is a software framework that tries to simplify the development of such kinds of applications both by providing the possibility of working on models for representing such semantic information and by offering some implementations of such models that can be easily used by software developers without any knowledge about semantic models and languages. This software library allows the representation of domain models through Java interfaces and annotations and then to use such a representation for automatically generating an implementation of domain models in different programming languages (currently Java and C++). Moreover, JOSI supports the interoperability with other applications both by automatically mapping the domain model representations into ontologies and by providing an automatic translation of each object obtained from the domain model representations in an OWL string representation
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
Detection of Java EE EJB Antipattern Instances using Framework-Specific Models
Adding flexibility to a process or technology often comes with a price. This holds true in the case of the amendments made to Java EE platform to upgrade to version 5. Java EE 5 allows Enterprise Java Bean (EJB) developers the ability to configure EJBs via Java 5 annotations, through XML deployment descriptors, or through a combination of both. While this adds flexibility to the EJB configuration process, it also comes with the price of an EJB project's stakeholder not being able to ascertain the current configuration of an EJB
project until runtime, due to the multiple sources of configuration and the complex overriding rules. Furthermore, to detect errors in configuration or perform
antipattern instance detection it is clearly beneficial to have a representation of an EJB project that accurately represents the current configuration of the system.
This thesis first presents an EJB Framework Specific Modeling Language (FSML) that formalizes the EJB domain's specific components in the form of a cardinality-based feature model. By having such a model and using and extending the existing FSML infrastructure, one retrieves a Framework Specific Model (FSM) through reverse engineering that represents all the information from the various sources of EJB configuration. By analyzing this FSM, we can create another model that represents the resolved configuration of an EJB project. We employ model filtration to highlight specific sources of configuration. We then use open-source and custom EJB
projects to evaluate the EJB FSML and the resolved model.
Models admit antipattern instance detection. This thesis presents two methods for running antipattern instance detection on an EJB project using existing EJB antipatterns in literature: 1) queries in Java that execute against the resolved configuration model; and 2) queries written in .QL, an object-oriented query language, against the EJB project's source code. We compare these two techniques qualitatively and propose a
new approach based on this comparison that entails modeling the antipatterns and their symptoms within an FSML model declaratively
Enabling technologies for a web-based urban street construction permit system
Thesis (M.Eng.)--Massachusetts Institute of Technology, Dept. of Civil and Environmental Engineering, 2001.Includes bibliographical references (leaves 87-88).This thesis is focused on the enabling technologies for a web-based urban street construction permit system. The web-based application system can automatically verify the various constraints, issue the permit if the constraints are met, notify the relevant persons of the issuance of the permit, update the pavement status for the affected street and prepare the billing report for further processing with the existing billing system. The web-based permit system is divided into two sub-systems: External System and Internal System. The external system is used by contractor/utility companies for permit application, and the internal system is used solely by authorized internal users for maintenance of the system or permit application on behalf of contractor/utility companies when there is such a necessity. These two sub-systems share the same underlying database system. In order to develop this web-based permit system, the following J2EE technologies have been used: Enterprise JavaBeans, JavaServer Pages, Servlet and JDBC API. Other J2EE technologies such as Transaction, JNDI and XML are also discussed where appropriate. The following development environments to support these technologies are also presented in this thesis: Red Hat Linux 7.0, Java 2 Platform, Tomcat Server 3.2.1, Database MySQL 2.1.4, and JDBC Driver 2.0.4 for MySQL. As an example, Arlington permit system was used to demonstrate the design of an Entity- Relationship model, and an Enterprise JavaBeans application.by Changxin Qi.M.Eng
Model Driven Software Engineering for Web Applications
Model driven software engineering (MDSE) is becoming a widely accepted approach for developing complex applications and it is on its way to be one of the most promising paradigms in software engineering. MDSE advocates the use of models as the key artifacts in all phases of the development process, from analysis to design, implementation and testing. The most promising approach to model driven engineering is the Model Driven Architecture (MDA) defined by the Object Management Group (OMG). Applications are modeled at a platform independent level and are transformed to (possibly several) platform specific implementations. Model driven Web engineering (MDWE) is the application of model driven engineering to the domain of Web application development where it might be particularly helpful because of the continuous evolution of Web technologies and platforms.
However, most current approaches for MDWE provide only a partial application of the MDA pattern. Further, metamodels and transformations are not always made explicit and metamodels are often too general or do not contain sufficient information for the automatic code generation. Thus, the main goal of this work is the complete application of the MDA pattern to the Web application domain from analysis to the generated implementation, with transformations playing an important role at every stage of the development process. Explicit metamodels are defined for the platform independent analysis and design and for the platform specific implementation of dynamic Web applications. Explicit transformations allow the automatic generation of executable code for a broad range of technologies. For pursuing this goal, the following approach was chosen.
A metamodel is defined for the platform independent analysis and for the design of the content, navigation, process and presentation concerns of Web applications as a conservative extension of the UML (Unified Modeling Language) metamodel, together with a cor-responding UML profile as notation. OCL constraints ensure the well-formedness of models and are checked by transformations. Transformations implement the systematic evolution of analysis and design models. A generic platform for Web applications built on an open-source Web platform and a generic runtime environment is proposed that represents a family of platforms supporting the combination of a broad range of technologies. The transformation to the platform specific models for this generic platform is decomposed along the concerns of Web applications to cope in a fine-grained way with technology changes. For each of the concerns a metamodel for the corresponding technology is defined together with the corresponding transformations from the platform independent design models. The resulting models are serialized to code by means of serialization transformations
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
A Survey on the open source tools for modelling and implementing enterprise application integration solutions
Enterprise Application Integration aims to providemethodologies and tools to integrate the many heterogeneous applications of typical companies’ software ecosystems. The reuse of these applications within the ecosystem contributes to reducing software development costs and deployment time. Studies have shown that the cost of integration is usually 5–20 times the cost of developing new functionalities. Many companies rely on Enterprise Service Buses (ESBs) to develop their integration solutions. The first generation of ESBs focused on providing many connectors and general-purpose integration languages whose focus is on communications, not on the integration problem being solved. The second generation of ESBs provides domain-specific languages inspired by enterprise integration patterns, which makes it clear that this generation is tailored to focus on the integration problem. In this chapter we provide a survey of Camel, Spring Integration, and Mule, which are the most successful open source second generation ESBs in the market. We report on them within a homogeneous framework that provides a clear overview of the three technologies
- …