Aspects Of Software Development Research Articles

Combining metrics for software evolution assessment by means of Data Envelopment Analysis

SUMMARYResearch and practice in software engineering have led to an extensive set of metrics for the evaluation of almost every aspect of software development. One of the major challenges for any quality model is the combination of metrics, which are complementary to each other. In this paper, we propose the use of Data Envelopment Analysis (DEA), a non‐parametric technique employed in economics, as a means of providing a unified view of selected design metrics. The proposed application of DEA aims at assessing the overall trend of quality during the evolution of software systems, by considering releases of a project as units to be ranked. An important benefit derived from the use of DEA is the ability to “normalize” the evaluation over the size characteristics of the examined systems, which is vital when comparing projects of different scale. Results are presented for successive versions of two open‐source, one industrial and one research project, whereas validation, whereas validation is performed by comparing the findings with the results obtained by Analytic Hierarchy Process, which is an acknowledged multi‐criteria decision analysis approach. According to the results, DEA enables the perception of global trends in qualitative characteristics, which would be otherwise difficult to recognize and interpret. Copyright © 2012 John Wiley & Sons, Ltd.

Towards an Integrated AORE Process Model for Handling Crosscutting Concerns

The two fundamental principles in software engineering to deal software complexity are separation of concerns and modularity. A lot of techniques exist in literature adopting these fundamental principles and some success in this direction has been achieved. Despite this improvement, still complete separation of concerns is not achieved and is far from adequate. Aspect-Oriented Software Development is another step towards achieving improved modularity and aims to advanced separation of concerns. It handles crosscutting concerns in an efficient manner by encapsulation them in separate modules called aspects and further uses composition mechanism to integrate them with core concerns. Handling crosscutting concerns in the early stages of software development is beneficial rather than handling them in later stages of software development because it not only makes the design simpler, but also helps to reduce the cost and defects that occur in the later stages of development. Aspect-Oriented Requirements Engineering (AORE) focuses on identifying, analyzing, specifying, verifying, and managing the crosscutting concerns at the early stages of software development. In last few years, many researchers contributed their significant efforts in this area but, still it is not sufficient. In this paper, we have proposed such an approach that incorporates aspect-oriented concepts and which includes concern management as a key separate activity that is not clearly mentioned earlier in literature. Also, traceability is an essential activity to accommodate changes in requirements but it is very difficult to implement. Organizing large numbers of requirements into meaningful and more manageable groups and negotiating specification with clients can make traceability easier to implement and maintain. The proposed approach supports identification, management, specification, and composition of all concerns.

Applying dynamic separation of aspects to distributed systems security: a case study

Distributed systems are commonly required to be flexible and scalable, as the number and arrangement of their (potentially mobile) devices may easily change. Security in distributed systems is a complex issue which can produce several problems such as eavesdropping, phishing or denial of service. To overcome these problems, there are various security measures that can be applied. This study proposes the use of dynamic aspect-oriented software development (AOSD) to implement security mechanisms in distributed systems. By applying dynamic separation of concerns using AOSD, it becomes possible to adapt the security measures of distributed systems, even when their sizes and arrangements change, without compromising global security. These changes can be applied when a distributed system is running, without requiring its execution to be stopped or interrupted. Using the dynamic and static aspect weaving AOSD platform, the authors have implemented solutions for two common security problems in distributed systems: (i) access control and data flow and (ii) encryption of transmissions. Moreover, the proposed approach has been tested in a real client-server FTP scenario. Qualitative and quantitative evaluations of both implementations are presented to estimate the pros and cons of using dynamic AOSD in the development of security measures of distributed systems.

Extensión del Diagrama de Secuencias UML (Lenguaje de Modelado Unificado) para el Modelado Orientado a Aspectos

This article reviews the basic principles of UML sequence diagram (Unified Modeling Language) to model dynamic behavior of software and describes the steps needed to achieve an aspectoriented modeling using this tool. This with the object of reaching greater autonomy and cleaning during the modeling and implementation of the main tasks of a software application. For these purposes, the object-oriented software development methodology (OOSD) is described remarking the importance of UML for the modeling of structures and behavior of object-oriented software applications. Furthermore, the main characteristics of the aspect-oriented software development methodology (AOSD) are mentioned, considering AOSD as an extension of OOSD. This makes it necessary for reviewing and adapting UML for the support of aspect-oriented modeling. In this context, a classic case study of the AOSD method is modeled.

Aspects of software development

AbstractA lot of aspects have to be considered for the software development and maintenance. This article will give an overview of some of them when dealing with the creation or maintenance of standard systems especially within the clinical environment. These aspects are estimations regarding effort, required group sizes, programming principles, ways to motivate the end users, and other aspects.

THE DSAW ASPECT-ORIENTED SOFTWARE DEVELOPMENT PLATFORM

Aspect-Oriented Software Development (AOSD) provides systematic means to modularize crosscutting concerns in software development. Common AOSD benefits are a higher level of abstraction, concern reuse, better legibility, and software maintainability improvement. In AOSD, static weaving implementations commonly obtain better runtime performance, whereas dynamic weaving provides runtime application adaptiveness and a valuable aid in software development. Since both approaches provide benefits, we have developed a Dynamic and Static Aspect Weaving (DSAW) platform that supports both kinds of weavers: a full dynamic one to offer high dynamic adaptiveness and a static one to obtain better runtime performance when the application is deployed. Furthermore, both weaving techniques can even be used simultaneously in the same application. Depending on the adaptiveness requirements and the life cycle stage, the programmer could change from one type of weaving to the other without performing any modification in the source code of either components or aspects. Therefore, DSAW provides the separation of the dynamism (weaving-time) concern in the aspect-oriented software development process. Moreover, our platform also supports a wide set of join-points and is language and platform neutral. A detailed assessment has revealed that the DSAW platform provides a competitive alternative to develop aspect oriented software.

The common aspect proof environment

We describe the goals, architecture, design considerations and use of the common aspect proof environment (CAPE). The CAPE is an extensible framework integrating formal methods and analysis tools for aspect-oriented programs. It is intended both to encourage the use of formal methods and analysis tools for systems with aspects and to facilitate the development of new tools for aspect analysis. The general principles of the CAPE are first explained, and the components and their high-level organization are given. The user interfaces are described, providing both application oriented and tool oriented Eclipse views. A description of the tools already integrated into the CAPE is given, and some analysis and verification scenarios are shown for an example aspect system. The aid of the CAPE in tool evaluation and experimentation with innovative usage of tools is demonstrated. As one example, verification aspects are used to aid in the abstraction and specification needed for formal analysis in Java Pathfinder. The scenarios and strategies employed are steps towards a methodology that includes multiple formal methods tools in aspect-oriented software development.

Programming the cloud

Client + cloud computing is a disruptive, new computing platform, combining diverse client devices -- PCs, smartphones, sensors, and single-function and embedded devices -- with the unlimited, on-demand computation and data storage offered by cloud computing services such as Amazon's AWS or Microsoft's Windows Azure. As with every advance in computing, programming is a fundamental challenge as client + cloud computing combines many difficult aspects of software development. Systems built for this world are inherently parallel and distributed, run on unreliable hardware, and must be continually available -- a challenging programming model for even the most skilled programmers. How then do ordinary programmers develop software for the Cloud? This talk presents one answer, Orleans, a software framework for building client + cloud applications. Orleans encourages use of simple concurrency patterns that are easy to understand and implement correctly, building on an actor-like model with declarative specification of persistence, replication, and consistency and using lightweight transactions to support the development of reliable and scalable client + cloud software.

Managing crosscutting concerns in component based systems using a model driven development approach

Abstract In the last few years, Model-Driven Development (MDD), Aspect-Oriented Software Development (AOSD), and Component-Based Software Development (CBSD) have become interesting alternatives for the design and construction of complex distributed applications. Although these methodological approaches share the principle of separation of concerns and their further integration as key factors to obtaining high-quality and evolvable large software systems, they usually each address this principle from their own particular perspective. In the present work, we combine Component-Based and Aspect-Oriented Software Developments in a Model Driven software process targeted at the development of complex systems. This process constitutes an enhancement of the separation of concerns by allowing the isolation of crosscutting concerns in both Platform Independent and Platform Specific models. Following a pure MDD philosophy, a set of model transformations are used to generate the system, from preliminary models to the final source code for the Corba Component Model platform. A twofold empirical analysis was used to evaluate the approach’s benefits in terms of two internal quality attributes: modularity and complexity. Conclusions were drawn from this evaluation regarding other quality attributes correlated with these two – stability, changeability, error-proneness, and reusability. An Eclipse plug-in was developed to drive the development of the entire system from early modeling to late deployment stages.

Incorporating AOSD to Enhance Model Driven Architecture

Various software development approaches in the present scenario are best suited for a specific application. The software development strategies include both merits and demerits when talked in terms of generalization. The Model Driven Architecture (MDA) describes software development based on models on various levels of abstraction. The model driven software development process consists of sequence of model transformations between various models. This paper presents incorporation of the merits of Aspect Oriented Software Development (AOSD) like modularization, reusability and reduced complexity into Model Driven Architecture (MDA) software development strategy. The proposed Model Driven Software Development approach which combines the merits of MDA and AOSD meets the ever changing and challenging demand of the enterprise software development.

A systematic literature review of software quality cost research

Abstract Software quality costs have not received as much attention from the research community as other economic aspects of software development. Over the last three decades, a number of articles on this topic have appeared in a range of journals, but comprehensive overviews of this body of research are not available. For the detailed review of software quality cost research presented in this article, we collect 87 articles published between 1980 and 2009 in 60 leading computing journals. We study the distribution of these articles across research disciplines and journals as well as over time. Moreover, we identify the predominant researchers in the software quality cost domain and the related research clusters. We also classify the articles according to three properties, namely, research topic, research scope, and research approach. This categorization enables us to identify aspects emphasized by previous research on software quality costs and to point out promising future research directions. Our review shows that prevention costs have gained the least attention, in spite of their big cost impact. It also reveals that only one article has targeted multiple companies. Further, we observe that many articles do not empirically validate their findings. This is especially true for those articles dealing with an entire firm.

Managing embedded systems complexity with aspect-oriented model-driven engineering

Model-driven engineering addresses issues of platform heterogeneity and code quality through the use of high-level system models and subsequent automatic transformations. Adoption of the model-driven software engineering paradigm for embedded systems necessitates specification of appropriate models of often complex systems. Modern embedded systems are typically composed of multiple functional and nonfunctional concerns, with the nonfunctional concerns (e.g., timing and performance) typically affecting the design and implementation of the functional concerns. The presence of crosscutting concerns makes specification of adequate platform-independent models a significant challenge. Aspect-oriented software development is a separation of concerns technique that decomposes systems into distinct features with minimal overlap. In this article, we illustrate how Theme/UML, an aspect-oriented modeling approach, can be used to separate embedded systems concerns and reduce complexity in design. We also present Model-Driven Theme/UML, a toolset for model-driven engineering of embedded systems that supports modularised design with Theme/UML and automatic transformations to composed models and source code.

Software engineering education: A study on conducting collaborative senior project development

Project and teamwork training is recognized as an important aspect in software engineering (SE) education. Senior projects, which often feature industrial involvement, serve the function of a ‘capstone course’ in SE curricula, by offering comprehensive training in collaborative software development. Given the characteristics of student team projects and the social aspects of software development, instructional issues in such a course must include: how to encourage teamwork, how to formalize and streamline stakeholder participation, and how to monitor students’ work, as well as sustain their desired collaborative effort throughout the development. In this paper, we present an exploratory study which highlights a particular case and introduces the meetings-flow approach. In order to investigate how this approach could contribute to the project's results, we examined its quantitative benefits in relation to the development of the project. We also conducted focus group interviews to discuss the humanistic findings and educational effects pertaining to this approach.

Assessment of reusability in aspect-oriented systems using fuzzy logic

Reusability of the software systems is becoming a very important factor due to rapid software development and increasing complexity. Software reusability improves the quality of software product by reducing development time, effort and cost. Researchers have explored many methodologies in order to assess the reusability of Object-Oriented (OO) software systems but the assessment of the reusability of Aspect-Oriented (AO) software systems is underexplored. Aspect-Oriented Software Development (AOSD) is an emerging paradigm that aims to modularize the crosscutting concerns in an application, which cannot be modularized using traditional procedure-oriented and object-oriented approaches. By applying an aspect-oriented approach, such concerns can be isolated resulting in the increase maintainability and reusability of the system. In this paper, we propose a reusability model for aspect-oriented systems and assess it using fuzzy logic technique.

Cooperative and human aspects of software engineering

Software is created by people -- software engineers in cooperation with domain experts, users and other stakeholders--in varied environments, under various conditions. Thus understanding cooperative and human aspects of software development is crucial to comprehend how and which methods and tools are required, to improve the creation and maintenance of software. The 3rd workshop on Cooperative and Human Aspects of Software Engineering held at the International Conference on Software Engineering continued the tradition from earlier workshops and provided a lively forum to discuss current developments and high quality research in the field. Further dissemination of research results will lead to an improvement of software development and deployment across the globe.

On Architecture Styles and Paradigms

Sustainable software architectures portray the fundamental properties of their application domains explicitly, to ensure the virtual world can "mimic" the real world appropriately. This insight is independent of the concrete business case and requirements a software-centric system must meet-and also of organizational aspects in software development. Using problem frames and domain-driven design, pragmatic architects get concrete guidance for choosing the "right" architecture approaches and realization technologies.

Financial Pricing of Software Development Risk Factors

The ability to price (monetize) software development risks can benefit various aspects of software development. Cost estimators predict project cost by adjusting a project's nominal cost on the basis of risk factors' (cost drivers') expected values, but the predicted cost is often inaccurate because risk factors' actual values normally deviate from expectations. Because variability is a widely used risk measure in finance, this risk-pricing method relates risk factor variability to project cost variability. The method estimates two parameters for each risk factor: extra cost incurred per unit exposure and project sensitivity. Several areas can benefit from the benchmark risk-pricing parameters obtained when applying this method with a cost estimator such as Cocomo.

"Collaborative tagging as a community-driven approach to knowledge sharing" by Domenico Gendarmi with Jessica Rubart as Coordinator

Domenico Gendarmi received his PhD in computer science from the University of Bari, Italy in April 2010. He is currently working as a postdoctoral researcher at Collaborative Development Group of the same University. His recent research activities focus around the Social Web and Global Software Engineering: in particular, how these fields can interact with each other in order to extend knowledge on social aspects of software development, i.e. supporting informal processes in agile and distributed team setting.

ASPECT-ORIENTED SPECIFICATION: A CASE STUDY IN SPACE DOMAIN

Aspect-oriented software development claims to improve several software engineering principles, such as modularization, abstraction and composition. The Aspect for the Space Domain project (ASSD) developed a metadata-driven approach for aspect-oriented requirements analysis. The main objectives of the ASSD project, funded by the European Space Agency , were to study the applicability and usefulness of aspect-orientation for the space domain (ground segment software projects in particular), focusing on the early stages of the software development life cycle. Therefore, this paper describes a rigorous representation for requirements analysis concepts, refines an approach for handling early aspects, and proposes a client/server architecture based on a metadata repository. The ASSD approach has been validated with two space domain case studies.

Aspect Oriented Software Development vs. other Techniques (Structured Approach and Object Oriented Approach)

Aspects are a natural evolution of the object-oriented paradigm. They provide a solution to some difficulties you may have encountered with modularizing your object-oriented code: sometimes functionality just doesn't fit! You've probably found yourself repeating the same lines of code in lots of different object-oriented classes because those classes each need that functionality, and so you can't easily wrap it up in a single place. Good examples of this kind of code are audit trails, transaction handling, concurrency management, and so on. You can now modularize such code with aspects. Aspect-Oriented Software Development (AOSD). Provides unique and advanced program structuring and modularization techniques. The implementation of software applications using AOSD techniques results in a better implementation structure which has an impact on many important software qualities such as enhanced reusability and reduced complexity. In turn, these software qualities lead to an improved software development lifecycle and, hence, to better software.