219,515 research outputs found
Generative Software Engineering
Researching evermore abstract and powerful ways of composing programs is the meat of software engineering for half a century. Important early steps were subroutines (to encapsulate actions) and records (to encapsulate data). A large step forward came with the introduction of the object-oriented concepts (classes, subclasses and virtual methods) where classes can encapsulate both data and behaviors in a very powerful, but still flexible, way. For a long time, these concepts dominated the scene, but eventually the need for additional concepts became apparent. In this chapter, we focus on model driven engineering MDE, which complement and leverage other mechanism such generic constructs, aspect oriented programming AOP, component based software development CBSE, generative programming, domain specific languages
A Comparative Study of Agile Components, Aspect-Oriented and Mashup Software development methods
This paper compares Agile Methods, Component-Based Software Engineering (CBSE), Aspect-Oriented Software Development (AOSD) and Mashups as the four most advanced software development methods. These different approaches depend almost totally on their application domain but their usability can be equally applied across domains. The purpose of this comparative analysis is to give a succinct and clear review of these four methodologies. Their definitions, characteristics, advantages and disadvantages are considered and a conceptual mind-map is generated that sets out a foundation to assist in the formulation and design of a possible new integrated software development approach. This includes supportive techniques to benefit from the examined methods' potential advantages for cross-fertilization. It is a basis upon which new thinking may be initiated and further research stimulated in the software engineering subject field
Integrating CBSE, SoC, MDA, and AOP in a Software Development Method
Component-Based Software Engineering, Separation of Concerns, Model-Driven Architecture, and Aspect-Oriented Programming are four active research areas that have been around for several years now. In this paper, we present how these four paradigms can be put together in the context of a new software development method and we show how they can complement each other at different stages in the development life-cycle of enterprise, middleware-mediated applications. Different software development methods, such as Fondue, Catalysis, KobrA, and the Rational Unified Process, are also analyzed, pointing out their differences and limitations. In the end, requirements for a dedicated tool infrastructure that would support the new development approach are discussed
Recommended from our members
Supporting engineering design using knowledge based systems technology with a case study in electricity distribution network design
This thesis was submitted for the degree of Doctor of Philosophy and awarded by Brunel University.This thesis explores the architectural requirements of engineering design support systems based on knowledge based systems technology. The exploration is based on an understanding of the nature of designing as a professional activity and on the extent to which designers' competence can be modelled. Attention is focused on certain salient aspects of designers' competent behaviour. The theoretical study leads to the specification of requirements to be satisfied by a knowledge based system which will support designers in their professional setting and to the proposal of some knowledge based system components which will meet the requirements identified. The theoretical aspect of the thesis is complemented by a case study based on a designer of high voltage electricity distribution networks. The case study illustrates the theoretical component of the thesis and the methodological basis for the work. The practical realizability of the components of the knowledge based systems architecture proposed are demonstrated using the results of the analysis of the knowledge elicited in the case study without prejudicing the general applicability of the ideas. An object-oriented knowledge engineering software development environment is used to demonstrate how some components of the design situation represented can be implemented.Financial support provided by Brunel University
Early aspects: aspect-oriented requirements engineering and architecture design
This paper reports on the third Early Aspects: Aspect-Oriented Requirements Engineering and Architecture Design Workshop, which has been held in Lancaster, UK, on March 21, 2004. The workshop included a presentation session and working sessions in which the particular topics on early aspects were discussed. The primary goal of the workshop was to focus on challenges to defining methodical software development processes for aspects from early on in the software life cycle and explore the potential of proposed methods and techniques to scale up to industrial applications
An ontology of agile aspect oriented software development
Both agile methods and aspect oriented programming (AOP) have emerged in recent years as new paradigms in software development. Both promise to free the process of building software systems from some of the constraints of more traditional approaches. As a software engineering approach on the one hand, and a software development tool on the other, there is the potential for them to be used in conjunction. However, thus far, there has been little interplay between the two. Nevertheless, there is some evidence that there may be untapped synergies that may be exploited, if the appropriate approach is taken to integrating AOP with agile methods. This paper takes an ontological approach to supporting this integration, proposing ontology enabled development based on an analysis of existing ontologies of aspect oriented programming, a proposed ontology of agile methods, and a derived ontology of agile aspect oriented development
Quality-aware model-driven service engineering
Service engineering and service-oriented architecture as an integration and platform technology is a recent approach to software systems integration. Quality aspects
ranging from interoperability to maintainability to performance are of central importance for the integration of heterogeneous, distributed service-based systems. Architecture models can substantially influence quality attributes of the implemented software systems. Besides the benefits of explicit architectures on maintainability and reuse, architectural constraints such as styles, reference architectures and architectural patterns can influence observable software properties such as performance. Empirical performance evaluation is a process of measuring and evaluating the performance of implemented software. We present an approach for addressing the quality of services and service-based systems at the model-level in the context of model-driven service engineering. The focus on architecture-level models is a consequence of the black-box
character of services
Towards a re-engineering method for web services architectures
Recent developments in Web technologies – in particular
through the Web services framework – have greatly enhanced the flexible and interoperable implementation of service-oriented software architectures. Many older Web-based and other distributed software systems will be re-engineered to a Web services-oriented platform. Using an advanced
e-learning system as our case study, we investigate central aspects of a re-engineering approach for the Web services platform. Since our aim is to provide components of the legacy system also as services in the new platform, re-engineering to suit the new development paradigm is as important as re-engineering to suit the new architectural requirements
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
- …