Aspect Oriented Software Development

paper presents a formal approach to threat-driven modeling and verification of secure software using aspect-oriented Petri nets. Based on the behavior model of intended functions, we identify and build formal models of security threats, which are potential misuses and anomalies of the intended functions that violate security goals. Threat mitigations are further modeled in an aspect-oriented paradigm. Taking Petri nets

Nowadays, there are many software development methods that are used by developers in order to produce high-quality software systems. Aspect-oriented software development as a new software development method tries to obtain the quality of software systems through the modularity of crosscutting concerns in the whole of software development process. However, there are some doubts about using aspect-oriented software development instead of others in operational environments. Some questions that everyone asks are: why is aspect-oriented software development used? Why should we start to change our software development method? Therefore, in this paper to answer these questions, aspect-oriented software development is compared with use case driven development as one of the popular and proper methods for software development. The result of comparison is a set of technical and useful points that express clearly what improvements are obtained by using aspects in the process of software develop...

The transformative global economy posed challenges to businesses in service management. In this computing age, the perceptual and operational edge of a certain business or organization manifested on the kind of technology it offers in the Service Management. Organizations have long recognized the importance of managing key resources such as people and information. Information has now moved to its rightful place as a key resource in the organization and therefore management of the same can be instituted by employing methodology. To keep their brand promise, technology has been used;The number of new entrants to every sectors of economy has grown significantly in recent years, and each firm strives to make their daily operation efficient in which demand for business software or application software getting higher and businesses or organizations opted to build or buy this software. Because of new entrants, it had offered opportunity to software developers to translate business processes into systems. This study investigates waste in the software development by application of Lean principles. Like any conventional projects, software becomes buggy and oftentimes it fails. Software failure is always attributed to the software engineering, not the incompetence of project managers, inadequacy of the people on the project, or lack of clear goal. The researchers' contentions are there wastes in the software development and serve as mechanism and evidence to why software fails. Software failure is not attributed to the software itself, it includes however the acceptance of the clients and end-users. Descriptive secondary data analysis, participant observation and Fishbone Analysis were the methodology used in the study. Wastes include unfinished or partially done work, extra features, relearning, handoffs, delays, task switching, and defects.

This paper describes a process proposal for searching source code, focusing on metadata, in order to assist in the search of elements (specified by the creator in the process of
the query language) in software. This search will provide a fast location of the metadata, allowing the analyst to check the code and use refactoring, and improving readability and reuse them.

Nowadays, there are many software development methods that are used by developers in order to produce high-quality software systems. Aspect-oriented software development as a new software development method tries to obtain the quality of software systems through the modularity of crosscutting concerns in the whole of software development process. However, there are some doubts about using aspect-oriented software development instead of others in operational environments. Some questions that everyone asks are: why is aspect-oriented software development used? Why should we start to change our software development method? Therefore, in this paper to answer these questions, aspect-oriented software development is compared with use case driven development as one of the popular and proper methods for software development. The result of comparison is a set of technical and useful points that express clearly what improvements are obtained by using aspects in the process of software development.

The transformative global economy posed challenges to businesses in service management. In this computing age, the perceptual and operational edge of a certain business or organization manifested on the kind of technology it offers in the Service Management. Organizations have long recognized the importance of managing key resources such as people and information. Information has now moved to its rightful place as a key resource in the organization and therefore management of the same can be instituted by employing methodology. To keep their brand promise, technology has been used;The number of new entrants to every sectors of economy has grown significantly in recent years, and each firm strives to make their daily operation efficient in which demand for business software or application software getting higher and businesses or organizations opted to build or buy this software. Because of new entrants, it had offered opportunity to software developers to translate business processes into systems. This study investigates waste in the software development by application of Lean principles. Like any conventional projects, software becomes buggy and oftentimes it fails. Software failure is always attributed to the software engineering, not the incompetence of project managers, inadequacy of the people on the project, or lack of clear goal. The researchers' contentions are there wastes in the software development and serve as mechanism and evidence to why software fails. Software failure is not attributed to the software itself, it includes however the acceptance of the clients and end-users. Descriptive secondary data analysis, participant observation and Fishbone Analysis were the methodology used in the study. Wastes include unfinished or partially done work, extra features, relearning, handoffs, delays, task switching, and defects.

The object-oriented software suffers from code tangling and code scattering problems leading to weak code reusability and difficult application evolution. New approaches supporting an advanced separation of concerns (ASoC) are proposed to overcome this dilemma. These latter provide a more powerful constructs for software decomposition than the object-oriented paradigm and their comparison is increasingly considered as an important issue.
This paper is dedicated to the comparison and the assessment of two samples of ASoC approaches: aspect-oriented programming (AOP) and subject-oriented programming (SOP).

These days, Social Media which is includes (Facebook, Instagram, Twitter, Linkedin) is an extremely well known social correspondence media. Individuals use Social Media to express their musings, thoughts, sonnets, and distresses on them. In the period of data superhighway, greater part of the young people are not sharing their challenges, issues, irregularity, power-lessness and disappointment with their folks in Kurdistan of Iraq. Be that as it may, they share with their companions on Social Media. Hence, their companions are making remarks, giving havens and affections to them. Because of absence of instruction and encounters on innovation, gatekeepers in Kurdistan don't know about the correspondences and addictions on social Medias. In this manner, there are producing holes in social relationships in the community. In this paper, a review has based and finding the effect of social media on personal and community relationships. Calculation dissects the practices of youngsters' by gathering data from a survey. Guardians and educators conclusions are additionally viewed as about the exercises of understudies on home and foundations. Here, age cutoff points of focused adolescents are somewhere in the range of 16 and 60. From this investigation, powerless connection amongst guardians and their adolescent youngsters have been taken note. The significant issue was that teenagers are investing more energy on social media and guardians need them to the table amid contemplate time and educational time.

The aspect-oriented programming paradigm (AOP) as a way of improving the separation of concerns principle has emerged initially at the programming level using strong languages like AspectJ. Currently, it becomes mature to stretch at premature stages of the software development process namely, the Aspect-Oriented Software Development (AOSD) which is a popular topic of software engineering research that leads to more dependable, reusable and maintainable artifacts. In this paper, we propose a UML profile for modeling crosscutting concerns where the separation of concerns is maintained to the level of code and the weaving is done by an AspectJ compiler.

Reuse is one of the core principles in professional software engineering. Design patterns provide a reusable solution for common design problems. But their implementations are generally not reusable as they are often well tailored to a specific context. We introduce a concept, that facilitates the reuse of their implementations by defining an abstract design pattern definition that can be instantiated with specialized design decisions. This approach is a meta-level Builder constructing design patterns as first-class citizens. It simplifies the application of design patterns by providing a pattern library and still being able to adjust it to the concrete context .

In this study, a new hybrid model integrated adaptive neuro fuzzy inference system with Firefly Optimization algorithm (ANFIS-FFA), is proposed for forecasting monthly rainfall with one-month lead time. The proposed ANFIS-FFA model is compared with standard ANFIS model, achieved using predictor-predictand data from the Pahang river catchment located in the Malaysian Peninsular. To develop the predictive models, a total of fifteen years of data were selected, split into nine years for training and six years for testing the accuracy of the proposed ANFIS-FFA model. To attain optimal models, several input combinations of antecedents’ rainfall data were used as predictor variables with sixteen different model combination considered for rainfall prediction. The performances of ANFIS-FFA models were evaluated using five statistical indices: the coefficient of determination (R2), Nash-Sutcliffe efficiency (NSE), Willmott’s Index (WI), root mean square error (RMSE) and mean absolute error (MAE). The results attained show that, the ANFIS-FFA model performed better than the standard ANFIS model, with high values of R2, NSE and WI and low values of RMSE and MAE. In test phase, the monthly rainfall predictions using ANFIS-FFA yielded R2, NSE and WI of about 0.999, 0.998 and 0.999, respectively, while the RMSE and MAE values were found to be about 0.272 mm and 0.133 mm, respectively. It was also evident that the performances of the ANFIS-FFA and ANFIS models were very much governed by the input data size where the ANFIS-FFA model resulted in an increase in the value of R2, NSE and WI from 0.463, 0.207 and 0.548, using only one antecedent month of data as an input (t-1), to almost 0.999, 0.998 and 0.999, respectively, using five antecedent months of predictor data (t-1, t-2, t-3, t-6, t-12, t-24). We ascertain that the ANFIS-FFA is a prudent modelling approach that could be adopted for the simulation of monthly rainfall in the present study region.

Information systems security continues to be the focus of tremendous amount of research with various security models and frameworks being developed over the years.
Application architecture and source code management are also security issues because with complex applications, it is important that security is designed into the application from the
onset irrespective of the security model being implemented.
Aspect Oriented Programming has been demonstrated to be a viable framework for implementing complex security models in software development.
This paper provides a historical review of security models for software development and presents an illustration of how Aspect Oriented Programming can be applied to implement security these security models by separating security aspects and other non functional requirements from an application while maintaining manageable and more secure source code.

Some security concerns are sensitive to flow of information in a program execution. The dataflow pointcut has been proposed by Masuhara and Kawauchi in order to easily implement such security concerns in aspect-oriented programming (AOP) languages. The pointcut identifies join points based on the origins of values. This paper presents a formal framework for this pointcut based on the λ calculus. Dataflow tags are propagated statically to track data dependencies between expressions. We introduce a static semantics for tag propagation and prove that it is consistent with respect to the dynamic semantics of the propagation. We instrument the static effect-based type system to propagate tags, match and inject advices. This static approach can be used to minimize the cost of dataflow pointcuts by reducing the runtime overhead since much of the dataflow information would be available statically and at the same time it can be used for verification. The proposed semantics for advice weaving is in the spirit of AspectJ where advices are injected before, after, or around the join points that are matched by their respective pointcuts. Inspired from the formal framework, the AspectJ compiler ajc is extended with the dataflow pointcut that tracks data dependencies inside methods.

The aspect-oriented programming paradigm (AOP) as a way of improving the separation of concerns principle has emerged initially at the programming level using strong languages like AspectJ. Currently, it becomes mature to stretch at premature stages of the software development process namely, the Aspect-Oriented Software Development (AOSD) which is a popular topic of software engineering research that leads to more dependable, reusable and maintainable artifacts. In this paper, we propose a UML profile for modeling crosscutting concerns where the separation of concerns is maintained to the level of code and the weaving is done by an AspectJ compiler.

Aspect-oriented modeling and simulation is a new approach which uses the separation of concerns principle to enhance the quality of models and simulation tools. It adopts the separation of concerns (SOC) principle. Thus, crosscutting concerns such as processes synchronization, steady state detection, and graphical animation could be separated from simulation functional modules. The capture of crosscutting concerns in a modular way is carried out to cope with complexity and to achieve the required engineering quality factors such as robustness, modularity, adaptability, and reusability. This paper provides a summary of aspect-oriented paradigm with its usage in simulation by illustrating the main crosscutting concerns that may infect simulation systems. A practical example is given with the use of the Japrosim discrete event simulation library.

Recent approaches toward solving the regression problems which are characterized by dynamic and nonlinear pattern such as machine learning modeling (including artificial intelligence (AI) approaches) have proven to be useful and successful tools for prediction. Approaches that integrate predictive model with optimization algorithm such as hybrid soft computing have resulted in the enhancement of the accuracy and preciseness of models during problem predictions. In this research, the implementation of hybrid evolutionary model based on integrated support vector regression (SVR) with firefly algorithm (FFA) was investigated for water quality indicator prediction. The monthly water quality indicator (WQI) that was used to test the hybrid model over a period of 10 years belongs to the Euphrates River, Iraq. The use of the WQI as an application for this research was stimulated based on the fact that WQI is usually calculated using a manual formulation which takes much time, efforts and occasionally may be associated with errors that were not intended during the subindex calculations. The parameters considered during the formulation of the prediction model were water quality parameters as input and WQI as output. The SVR model was used to verify the accuracy of the inspected SVR–FFA model. Different statistical metrics such as best fit of goodness and absolute error measures were used to evaluate the model. The performance of the hybrid model in recognizing the dynamic and nonlinear pattern characteristics was high and remarkable compared to the pure model. The SVR–FFA model was also demonstrated to be a good and robust soft computing technique toward the prediction of WQI. The proposed model enhanced the absolute error measurements (e.g., root mean square error and mean absolute error) over the SVR-based model by 42 and 58%, respectively.

Nowadays, Aspect-Oriented programming is used for industrial software systems. However, many useful Object-Oriented systems have been developed and are still in use anda manual porting of big projects from Object-Oriented (OO) paradigm to Aspect-Oriented (AO) one, making the most of Design Patterns (DP), may prove a costly and time-consuming process. This paper proposes a practical approach for automatically converting OO code to AO code, specifically for the implementation of DPs. The solution comprises two essential steps: recognition of the DP in OO code and conversion into AO code. Then, two examples of DP Singleton and Composite implementations on the Eclipse IDE with Eclipse Java Development Tools (JDT) are given.

The problem of realizing the Separation Of Concerns (SOC) principle is at the heart of the software crisis where crosscutting concerns tend to produce a messed simulation systems by decreasing their modularity, and reducing their reuse. Aspect-Oriented Programming paradigm is newly technique introduced for software development. It may co-exist with other methodologies, such as object-oriented, in order to keep the most system interesting properties, such as
reusability and adaptability. In this paper, we present a synthetic study of the most efforts of using the aspect oriented programming paradigm (AOP) in the simulation modeling field. Besides that, we explore the promising perspectives in this research area and our ongoing work towards an Aspect Oriented Simulation Framework (Japrosim).

William Chung, William Harrison, Vincent Kruskal, Harold Ossher, Stanley M. Sutton Jr., Peri Tarr IBM Thomas J. Watson Research Center PO Box 704 Yorktown Heights, NY 10598 USA +1 914 784 7975 [email protected] ... Matthew Chapman, Andrew Clement, ...

The quality evaluation of software metrics measurements are considered as the primary indicator of imperfection prediction and software maintenance in various empirical studies of software products. However, there is no agreement on which metrics are compelling quality pointers for new software development approaches such as Aspect-Oriented Programming techniques. Aspect-Oriented Programming intends to enhance programming quality by providing fundamentally different parts of the systems, for example, pointcuts, advice, and inter-type relationships. Hence, it is not evident if quality characteristics for AOP could be extracted from direct expansions of traditional Object Oriented Programming measurements. Then again, investigations of Aspect-Oriented Programming do regularly depend on established static and dynamic metrics measurements; notwithstanding the late research of AOP in empirical studies, few analyses been adopted using ISO  9126 quality model as useful markers of flaw inclination in this context. This paper examination we have considered different programming quality models given by various authors every once in a while and distinguished that adaptability was deficient in the current model. We have testing ten projects developed by Aspect-Oriented Programming. We have used many applications to extract the metrics, but none of them could extract all AOP metrics. It only can measure some of AOP metrics, not all of them. This study investigates the suitable framework for extract AOP metrics, For instance, static and dynamic metrics measurements for hybrid application systems (Aspect-Oriented Programming, Object-Oriented Programming), or only Aspect-Oriented Programming application.

The application of aspect-oriented programming (AOP) to the embedded operating system domain is still a very controversial topic, as this area demands high performance and small memory footprint. However, recent studies quantifying aspects overheads in AspectC++ show that the resource cost is very low. Therefore, operating system development may benefit with the modularization of crosscutting concerns and system specialization offered by AOP.

Moodle approach to Collaborative Learning is just limited to "putting people around a table". It provides a means for participants to interact with other participants (other people around the same table) and with Learning Contents (the objects on the table). In this scenery, by no means it can be guaranteed that collaboration will occur. In order to assure that real collaboration will take place, we define workflow-like collaboration structures which we name learnflows. In this paper, we present a conceptual architecture and a concrete implementation for the support of learnflows in Moodle. We design a Learnflow Engine on top of a generic-purpose Workflow Engine, just by using out-of-the-box workflow functionality. This Learnflow Engine is exposed as a Web Service, enabling the consumption of Learnflow Web Service Methods from the Moodle integration code, which is designed following Aspect-oriented Software Development techniques.

This position paper presents a concept for aspect-oriented design and a seamless integration of AO design and implementation. We suggest a design notation based on standard UML which separates clearly the reusable programming language independent design of aspect code and base (business logic) code from the language dependant cross-cutting parts. Thus fostering reuse of aspect code and simplifying the replacement

Aspect-Oriented requirements engineering helps to achieve early separation of concerns by supporting systematic analysis of broadly-scoped properties such as security, real-time constraints, etc. The early identification and separation of aspects and base abstractions crosscut by them helps to avoid costly refactorings at later stages such as design and code. However, if not dealt with in an effective way, the aspect identification task can become a bottleneck requiring a significant effort due to the large amount of, often poorly structured or imprecise, information available to a requirements engineer. In this paper, we describe a tool, EA-Miner, that provides effective automated support for identifying and separating aspectual and non-aspectual concerns as well as their crosscutting relationships at the requirements level. The tool utilises natural language processing techniques (part-of-speech and semantic tagging, word frequencies, etc.) to reason about the properties of the concerns and model their structure and relationships. The quality of the tool's output is comparable to that of an experienced requirements engineer carrying out the task manually while the performance is significantly better.

Component-Based Software Development (CBSD) and Aspect-Oriented Software Development (AOSD) are solutions to support software evolution by decomposing a software system into concerns. In this paper, we propose Fractal Aspect Component (FAC), a general and symmetrical model for components and aspects. FAC decomposes a software system into regular components and aspect components which embody crosscutting concerns. We reify the relationship between an aspect component and a component, called an aspect binding, as a first-class runtime entity. The evolution of the system can be expressed by adding or removing components (aspect or regular) and by setting bindings (regular or crosscutting).

In this article we present our industrial demonstrator about building a digital publishing system using Aspect-Oriented Software Development (AOSD). We have applied AOSD methods and tools during the full software development process from requirements to deployment. The goal of the demonstrator is to show that (i) AOSD integrates well with existing standard paradigms such as component-based software engineering, (ii) the

Program analysis is useful for debugging, testing, and maintaining software systems due to availability of information about the structure and relationship of the program modules. In general, program analysis is performed either based on control flow graph (CFG) or dependence graph (DG). However, in the case of aspect-oriented programming (AOP), control flow graph or dependence graph are not enough to model the features of Aspect-oriented (AO) programs. Although AOP is good for modular representation and crosscutting concern, a suitable graph model for program analysis is required to gather information on its structure for the purpose of minimizing maintenance effort. In this thesis, a graph model known as Slicing Aspect-Oriented Program by Using Dependence Flow Graph For Software Maintenance Purpose is proposed to represent the structure of aspect-oriented programs. The graph is formed by merging CFG and DG.  As a consequence, more information about dependencies involving the features of AOP, such as join point, advice, aspects, their related constructs, and the flow of control are able to be gathered. Based on AODFG, slicing criteria are defined for aspect-oriented features. The concept of slicing AODFG model is also proposed. A prototype tool called Aspect-oriented Slicing Tool was developed to implement AODFG. The performance of AODFG was evaluated by analysing some AspectJ  programs taken from AspectJ  Development Tools. The analysis showed the consistency of the output compared with DG and CFG. In addition, an empirical study was conducted to find out the effect of AOST in terms of effectiveness,  understandability , and modifiability in maintenance purpose. The results of the empirical analysis showed positive responses.

Aspect-Oriented Software Development (AOSD) is an emerging area with the goal of promoting advanced separation of concerns throughout the software development lifecycle. However, since there are many different approaches to Aspect-Oriented Programming (AOP), it is very difficult to identify the essential concepts and properties for supporting the design of aspect-oriented languages and tools, and effectively promote advances in the field of AOSD. In this context, this paper presents a theory of aspects -a conceptual framework for AOP that provides consistent terminology and basic semantics for thinking about a problem in terms of the core concepts and properties that characterize the aspect-oriented style as an emerging paradigm to software development. This theory has been used for evaluating existing aspect-oriented languages and tools and, in special, it has been used to characterize aSide, an aspect-oriented modeling language.

We define and study bisimulation for proving contextual equivalence in an aspect extension of the untyped lambda-calculus. To our knowledge, this is the first study of coinductive reasoning principles aimed at proving equality of aspect programs. The language we study is very small, yet powerful enough to encode mutable references and a range of temporal pointcuts (including cflow and regular event patterns).

Many of the problems that stem from the use of exception handling are caused by the local way in which exceptions are handled. It demands that developers understand the source of an exception, the place where it is handled, and everything in between. As a consequence, exceptions easily get "out of control" and, as system development progresses, exceptional control flows become less well-understood, with potentially negative consequences for the program maintainability and reliability. This paper presents an innovative aspect-oriented model for exception handling implementation. In contrast to other exception handling mechanisms, our model provides abstractions to explicitly describe global views of exceptional control flows. As a result, this new model makes it possible to understand exception flows from an end-to-end perspective by looking at a single part of the program. Also, it leverages existing pointcut languages to make the association of handlers with normal code more flexible. The implementation of our proposed model, called EJFlow, extends the AspectJ programming language with the aim of promoting enhanced robustness and program modularization. We evaluate qualitatively and quantitatively the proposed exception handling model through a case study targeting a real mobile application.

The construction and maintenance of large and complex software systems depend on the existence of global principles describing the structure and the interaction among its various components. Due to their critical nature, such principles have to be explicitly formulated and strictly verified and enforced throughout the lifetime of the software product. Aspect Oriented Software Development (AOSD) provides necessary tools for the formulation of such principles as aspects-called here structural aspects, and for their compile-time verification and dynamic enforcement. This enforcement, however, becomes problematic when aspects are also used as a vehicle for programming the components themselves, due to aspect interference.

Shakeins are a novel programming construct which, like mixins and generic classes, generates new classes from existing ones in a universal, uniform, and automatic manner: From a given class, a shakein generates a new class which has the same type as the original, but with different data and code implementation. We argue that shakeins are restricted, yet less chaotic, aspects. We further claim that shakeins are well suited for the introduction of aspect-oriented programming (AOP) into existing middleware applications. We introduce the AspectJ2EE language which, with the help of shakeins and a new deploy-time weaving mechanism, brings the blessings of AOP to the J2EE framework. A unique advantage of AspectJ2EE, which is less general (and hence less complicated) than AspectJ, is that it can be smoothly integrated into J2EE implementations without breaking their architecture.

Aspect-Oriented Programming (AOP) provides another way of thinking about program structure that allows developers to separate and modularize concerns like crosscutting concerns. These concerns are maintained in aspects that allows to easily maintain both the core and crosscutting concerns. Much research on this area has been done focused on traditional software development. Although little has been done in the Web development context. In this paper is presented an overview of existing AOP PHP development tools identifying their strengths and weaknesses. Then we compare the existing AOP PHP development tools presented in this paper. We then discuss how these tools can be effectively used in the Web development. Finally, is discussed how AOP can enhance the Web development and are presented some future work possibilities on this area.