Modularizing application and database evolution - an aspect-oriented framework for orthogonal persistence

In the maintenance of software applications, database evolution is one common difficulty. In object‐oriented databases, this process comprises schema evolution and instance adaptation. Both tasks usually require significant effort from programmers and database administrators. In this paper, we propose orthogonal persistence and aspect‐oriented programming to support semi‐transparent database evolution. A default mechanism for instance evolution is defined, but the user may provide modularized solutions using the aspect‐oriented paradigm. We present our framework AOF4OOP to test the feasibility of our proposed approach. This prototype allows programmes to transparently access data in other versions of the database schema. We evaluate our framework, comparing it to related approaches using two real applications and measuring the improvement of the productivity of the programmer.info:eu-repo/semantics/publishedVersio

An Intelligent Mobility Prediction Scheme for Location-Based Service over Cellular Communications Network

One of the trickiest challenges introduced by cellular communications networks is mobility prediction for Location Based-Services (LBSs). Hence, an accurate and efficient mobility prediction technique is particularly needed for these networks. The mobility prediction technique incurs overheads on the transmission process. These overheads affect properties of the cellular communications network such as delay, denial of services, manual filtering and bandwidth. The main goal of this research is to enhance a mobility prediction scheme in cellular communications networks through three phases. Firstly, current mobility prediction techniques will be investigated. Secondly, innovation and examination of new mobility prediction techniques will be based on three hypothesises that are suitable for cellular communications network and mobile user (MU) resources with low computation cost and high prediction success rate without using MU resources in the prediction process. Thirdly, a new mobility prediction scheme will be generated that is based on different levels of mobility prediction. In this thesis, a new mobility prediction scheme for LBSs is proposed. It could be considered as a combination of the cell and routing area (RA) prediction levels. For cell level prediction, most of the current location prediction research is focused on generalized location models, where the geographic extent is divided into regular-shape cells. These models are not suitable for certain LBSs where the objectives are to compute and present on-road services. Such techniques are the New Markov-Based Mobility Prediction (NMMP) and Prediction Location Model (PLM) that deal with inner cell structure and different levels of prediction, respectively. The NMMP and PLM techniques suffer from complex computation, accuracy rate regression and insufficient accuracy. In this thesis, Location Prediction based on a Sector Snapshot (LPSS) is introduced, which is based on a Novel Cell Splitting Algorithm (NCPA). This algorithm is implemented in a micro cell in parallel with the new prediction technique. The LPSS technique, compared with two classic prediction techniques and the experimental results, shows the effectiveness and robustness of the new splitting algorithm and prediction technique. In the cell side, the proposed approach reduces the complexity cost and prevents the cell level prediction technique from performing in time slots that are too close. For these reasons, the RA avoids cell-side problems. This research discusses a New Routing Area Displacement Prediction for Location-Based Services (NRADP) which is based on developed Ant Colony Optimization (ACO). The NRADP, compared with Mobility Prediction based on an Ant System (MPAS) and the experimental results, shows the effectiveness, higher prediction rate, reduced search stagnation ratio, and reduced computation cost of the new prediction technique

Aspect-oriented model-driven code generation approach for improving code reusability and maintainability

Software development teams always need methods that can help in producing high-quality software with reduced development effort and delivery time. Model-Driven Engineering (MDE) as well as Aspect-Oriented Software Development (AOSD) techniques help in reducing the delivery time, and also positively contribute to quality of the produced software. Through the use of AOSD techniques in combination with MDE, an integration of excellent abstraction mechanisms of MDE and capabilities of AOSD with regards to modularity and composition of concerns can be perceived, which is expected to enhance the positive effects of both techniques. To this end, different integration approaches have appeared in literature, but aspect-oriented code generation has advantages over the other approaches. Consequently, a number of aspect-oriented code generation approaches have been offered, but all such approaches lack several features mandatory to materialize a workable integration of aspect technologies in the context of MDE. To address these issues, this research was conducted to present an approach for aspect-oriented model-driven code generation, which focuses on elaborating the conceptual relationship between design models and the implementation code, and exploits the same to obtain aspect-oriented code that is more reusable and maintainable. The key outcomes of this research are the elaboration of the conceptual mappings between elements of visual design and constructs of the code, mapping of the visual models to implementation-specific text-based models, and a technique for generation of aspect-oriented code. The applicability of the proposed approach is shown by the use of case studies, whereas the quality of the approach is measured using reusability and maintainability metrics. A comparison of the proposed approach with existing approaches substantiates its efficacy in terms of reusability and maintainability of code, showing an outperformance of other approaches by the proposed approach against 78% of the employed quality metrics

Improving Reuse of Distributed Transaction Software with Transaction-Aware Aspects

Implementing crosscutting concerns for transactions is difficult, even using Aspect-Oriented Programming Languages (AOPLs) such as AspectJ. Many of these challenges arise because the context of a transaction-related crosscutting concern consists of loosely-coupled abstractions like dynamically-generated identifiers, timestamps, and tentative value sets of distributed resources. Current AOPLs do not provide joinpoints and pointcuts for weaving advice into high-level abstractions or contexts, like transaction contexts. Other challenges stem from the essential complexity in the nature of the data, operations on the data, or the volume of data, and accidental complexity comes from the way that the problem is being solved, even using common transaction frameworks. This dissertation describes an extension to AspectJ, called TransJ, with which developers can implement transaction-related crosscutting concerns in cohesive and loosely-coupled aspects. It also presents a preliminary experiment that provides evidence of improvement in reusability without sacrificing the performance of applications requiring essential transactions. This empirical study is conducted using the extended-quality model for transactional application to define measurements on the transaction software systems. This quality model defines three goals: the first relates to code quality (in terms of its reusability); the second to software performance; and the third concerns software development efficiency. Results from this study show that TransJ can improve the reusability while maintaining performance of TransJ applications requiring transaction for all eight areas addressed by the hypotheses: better encapsulation and separation of concern; loose Coupling, higher-cohesion and less tangling; improving obliviousness; preserving the software efficiency; improving extensibility; and hasten the development process

Transactions and schema evolution in a persistent object-oriented programming system

Applications are subject of a continuous evolution process with a profound impact on their underlining data model, hence requiring frequent updates in the applications' class structure and database structure as well. This twofold problem, schema evolution and instance adaptation, usually known as database evolution, is addressed in this thesis. Additionally, we address concurrency and error recovery problems with a novel meta-model and its aspect-oriented implementation. Modern object-oriented databases provide features that help programmers deal with object persistence, as well as all related problems such as database evolution, concurrency and error handling. In most systems there are transparent mechanisms to address these problems, nonetheless the database evolution problem still requires some human intervention, which consumes much of programmers' and database administrators' work effort. Earlier research works have demonstrated that aspect-oriented programming (AOP) techniques enable the development of flexible and pluggable systems. In these earlier works, the schema evolution and the instance adaptation problems were addressed as database management concerns. However, none of this research was focused on orthogonal persistent systems. We argue that AOP techniques are well suited to address these problems in orthogonal persistent systems. Regarding the concurrency and error recovery, earlier research showed that only syntactic obliviousness between the base program and aspects is possible. Our meta-model and framework follow an aspect-oriented approach focused on the object-oriented orthogonal persistent context. The proposed meta-model is characterized by its simplicity in order to achieve efficient and transparent database evolution mechanisms. Our meta-model supports multiple versions of a class structure by applying a class versioning strategy. Thus, enabling bidirectional application compatibility among versions of each class structure. That is to say, the database structure can be updated because earlier applications continue to work, as well as later applications that have only known the updated class structure. The specific characteristics of orthogonal persistent systems, as well as a metadata enrichment strategy within the application's source code, complete the inception of the meta-model and have motivated our research work. To test the feasibility of the approach, a prototype was developed. Our prototype is a framework that mediates the interaction between applications and the database, providing them with orthogonal persistence mechanisms. These mechanisms are introduced into applications as an {\it aspect} in the aspect-oriented sense. Objects do not require the extension of any super class, the implementation of an interface nor contain a particular annotation. Parametric type classes are also correctly handled by our framework. However, classes that belong to the programming environment must not be handled as versionable due to restrictions imposed by the Java Virtual Machine. Regarding concurrency support, the framework provides the applications with a multithreaded environment which supports database transactions and error recovery. The framework keeps applications oblivious to the database evolution problem, as well as persistence. Programmers can update the applications' class structure because the framework will produce a new version for it at the database metadata layer. Using our XML based pointcut/advice constructs, the framework's instance adaptation mechanism is extended, hence keeping the framework also oblivious to this problem. The potential developing gains provided by the prototype were benchmarked. In our case study, the results confirm that mechanisms' transparency has positive repercussions on the programmer's productivity, simplifying the entire evolution process at application and database levels. The meta-model itself also was benchmarked in terms of complexity and agility. Compared with other meta-models, it requires less meta-object modifications in each schema evolution step. Other types of tests were carried out in order to validate prototype and meta-model robustness. In order to perform these tests, we used an OO7 small size database due to its data model complexity. Since the developed prototype offers some features that were not observed in other known systems, performance benchmarks were not possible. However, the developed benchmark is now available to perform future performance comparisons with equivalent systems. In order to test our approach in a real world scenario, we developed a proof-of-concept application. This application was developed without any persistence mechanisms. Using our framework and minor changes applied to the application's source code, we added these mechanisms. Furthermore, we tested the application in a schema evolution scenario. This real world experience using our framework showed that applications remains oblivious to persistence and database evolution. In this case study, our framework proved to be a useful tool for programmers and database administrators. Performance issues and the single Java Virtual Machine concurrent model are the major limitations found in the framework

Information Systems Development through an Integrated Framework

Information systems are essential entities for several organizations who strive to successfully run their business operations. One of the major problems faced by the organizations is that many of these information systems fail, and thus the organizations do not achieve their required targets in time. Many of the reasons for the information system failures documented in the literature are related to development methodologies or frameworks that are unable to handle both ‘hard’ and ‘soft’ system aspects. In general, the hard issues of the system are considered more significant than the soft issues, however, all the methodologies must be able to deal with all the system and business aspects. This thesis investigates the possibility of developing and evaluating a multimethodology framework that can be used for information systems development in an academic and business environment. The research explores the applicability of such a framework that comprehends both ‘soft’ and ‘hard’ system aspects in order to eliminate information system failures. Different software development approaches are investigated, including the dominant ‘domain-driven design’ (DDD) approach. A new multimethodological framework entitled ‘Systemic Soft Domain Driven Design’ (SSDDDF) has been developed by combining ‘soft system methodology’ as a guiding methodology, ‘unified modelling language’ as a business domain modelling approach, and a domain-driven design implementation pattern. This framework is intended as an improvement of the DDD approach. Soft and hard techniques are integrated through mapping from the ‘consensus primary task model’ of the soft approach to the ‘use cases’ of the hard approach. In addition, ‘soft language’ is introduced as a complement to DDD’s ‘ubiquitous language’, for facilitating the communication between the different stakeholders of a project. The implementation pattern (e.g., Naked Objects) is included for generating code from domain models. The framework has been evaluated as an information systems development approach through different undergraduate and postgraduate projects. Feedback from the developers has been positive and encouraging for further improvements in the future. The SSDDD framework has also been compared to different ISD methodologies and frameworks among of these DDD as an approach to ISD. The results of this comparison show that SSDDDF has advantages over DDD and significant improvements to DDD have been achieved. Finally, the research suggests an agenda for further improvements of the framework, while suggesting the development of different pattern languages

Cooperative Aspect Oriented Programming for Executable Business Processes

AO4BPEL applied Aspect Oriented Programming to executable business processes. Although modularized, AO4BPEL aspects do not have an explicit interface and the implicit one, based on XPath, is often fragile, hence reusing aspects in different processes is quite hard. Cooperative Aspect Oriented Programming aims at making aspects reusable by means of cooperative work between base code and aspects, realized by increasing the explicit a wareness of aspects at the expense of pure obliviousness. This work investigates the use of Cooperative Aspect Oriented Programming with BPEL processes