Aspect Oriented Software Development

The study focuses on how the four language skills namely Listening, Speaking, Reading and Writing (LSRW) can be enhanced usin g a Learning Management System (LMS) like Google Classroom. The study also intends to analyse the outcome and impact of using Google Classroom among English as Second Language (ESL) learners via graded assessments and activities. The study identifies the advantages and disadvantages of using Google Classroom in an ESL classroom. Based on the feedback received from the students in a language classroom, the study identifies that Google Classroom encourages an advantageous, interactive, and learner-centred environment and turns out to be an effective alternative for the traditional teacher-centred chalk and talk classrooms. The general observation from the sample population is that using Google Classroom a teacher can keep track of the gradual progress of students through assignments and questionnaires. The learners, on the other hand, find in Google Classroom an effective medium to profuse their creativity and a promising platform to undergo advanced language learning activities in future.

Research in the area of multi-DSAL development has been mainly devoted to enabling the interoperability of multiple aspect mechanisms. Less attention has been given to making programming with multiple aspect languages practical. For domain specific aspect languages (DSALs) to be used in practice, there is a need for tools that make multi-DSAL development effective. This paper focuses on one such tool: a debugger. We define a multi-DSAL debug interface (MDDI) for inspecting the composition specification and the runtime state and behavior of applications written in multiple DSALs. To implement the interface, a multi-DSAL debug agent and special debug attributes are introduced into the weaving process. A concrete implementation of MDDI over the AWESOME aspect composition framework is presented. For validation we demonstrate a simple command line AWESOMEDEBUGGER that uses the debug interface.

Loadable Kernel Modules (LKMs) provide a mechanism of inserting extending functionalities of the kernel at the run time. LKMs are the most convenient way to customize an OS kernel. Instead of modifying the source code and recompiling it, we get the possibility to plug-in little pieces of code, called modules at runtime. An LKM is a relocatable object file which can be loaded into the kernel address space to add new functionality at run time. We can also remove the module from the kernel, when that functionality is not needed. This approach keeps the basic kernel size thin and allows the flexibility of extending the OS capability at run time. LKMs are much faster to maintain and debug and help save precious memory. They are commonly used to add new functionality into the OS kernel as device drivers. One can also install new systems calls as LKMs which help user space programs to get services of the kernel. LKMs act like plugins. When a device is plugged in one can add the relevant dr...

Balancing competing dependability concerns related to security, fault tolerance and performance is a challenge during software development. Addressing these concerns early on in the development lifecycle can reduce the need for extensive and costly design changes later on. We have developed an Aspect-Oriented Modeling framework that allows early localization of competing concerns into aspects and their composition with models reflecting the core functionality. This paper presents approaches for systematic evaluation ...

The Tracker project is studying rework in systems engineering projects. Our hypothesis is that providing decision makers with information about previous relevant decisions will assist in reducing the amount of rework in a project. We propose an architecture for the flexible integration of the tools implementing the variety of theories and models used in the project. The techniques include ethnographic analysis, natural language processing, activity theory, norm analysis, and speech and handwriting recognition. In this paper, we focus on the natural language processing components, and describe experiments which demonstrate the feasibility of our text mining approach.

An Orc-based abstract model of grid computation is used as a basis for re-engineering a grid-oriented skeleton based programming environment to remove one of the skeleton system's recognized weak points. Lightweight reasoning about non-functional properties is used to guide the redesign of the system. It is argued that such a use of a formal model delivers significant return for small investment. The approach is then extended by enhancing Orc specifications with metadata to capture non-functional properties of systems being specified. It is shown that this approach allows reasoning about cost and security in a qualitive way that is consistent with actual experimental results.

We discuss a framework supporting fast prototyping as well as tuning of distributed applications. The approach is based on the adoption of a formal model that is used to describe the orchestration of distributed applications. The formal model adopted (Orc by Misra and Cook) can be used to support semi-formal reasoning about the applications at hand. We build on results achieved earlier and show here how the framework can be used to derive and evaluate alternative orchestrations of a well know parallel/distributed computation pattern; and describe how the same formal model can also be used to support generation of prototypes of distributed applications skeletons directly from the application description.

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 experimen...

Search engines are competing to be seen as universal, consistent and language independent. In principle, users searching for information through the Internet should get consistent information regardless of the language of the words they are searching for and regardless of the language of the matching or the relevant documents. Nevertheless, the language should affect the sequence or the ranking of the retrieved results. In this project, several tools are built to evaluate words and statements in several languages. Results are evaluated and compared for possible correlation. Another tool is built to crawl websites from different languages and locations in order to measure several aspects of those websites. Results from both studies showed that while it seems that popular search engines are making very good progress toward building search engines that are language and location independent, however, there are some limitations and situations where search for results can be biased toward...

TransJ is an extension to AspectJ for encapsulating transaction-related cross-cutting concerns in modular aspects. This paper presents an empirical study to evaluate the reusability and performance cross-cutting concerns implemented with TransJ compare to AspectJ alone. As part this study, we define a reuse and performance quality model as an extension to an existing quality model. We then formalize eight hypotheses that can be tested using metrics from the quality model. Finally, to assess the hypotheses, we compare implementations of different sample applications across two study groups: one for TransJ and another for AspectJ. Results from the study show improvement in reusability when using TransJ, while preserving the performance. Keywords-Transaction-related Aspects; Aspect-Oriented Programming (AOPL); Abstractions; Transaction Joinpoint; Dynamic Weaving; Pointcuts; Transaction-related Contexts (TCC's); software reuse; and performance.

Abstract—Distributed transaction processing systems can be unnecessarily complex when crosscutting concerns, e.g., logging, concurrency controls, transaction management, and access controls, are scattered throughout the transaction processing logic or tangled into otherwise cohesive modules. Aspect orientation has the potential of reducing this kind of complexity; however, currently, aspect-oriented programming languages and frameworks only allow weaving of advice into contexts derived from traditional executable structures. This paper lays a foundation for weaving advice into distributed transactions, which are high-level runtime abstractions. To establish this foundation, we capture key transaction events and context information in a conceptual model, called Unified Model for Joinpoints Distributed Transactions (UMJDT). This model defines interesting joinpoints relative to transaction execution and context data for woven advice. A brief discussion of advice weaving and the potenti...

Background: Aspect-Oriented Software Development (AOSD) is a paradigm that promotes advanced separation of concerns and modularity throughout the software development lifecycle, with a distinctive emphasis on modular structures that cut across traditional abstraction boundaries. In the last 15 years, research on AOSD has boosted around the world. The AOSD-BR research community (AOSD-BR stands for AOSD in Brazil) emerged in the last decade, and has provided different contributions in a variety of topics. However, despite some evidence in terms of the number and quality of its outcomes, there is no organized characterization of the AOSD-BR community that positions it against the international AOSD Research community and the Software Engineering Research community in Brazil. Aims: In this paper, our main goal is to characterize the AOSD-BR community with respect to the research developed in the last decade, confronting it with the AOSD international community and the Brazilian Software Engineering community. Method: Data collection, validation and analysis were performed in collaboration with several researchers of the AOSD-BR community. The characterization was presented from three different perspectives: (i) a historical timeline of events and main milestones achieved by the community; (ii) an overview of the research developed by the community, in terms of key challenges, open issues and related work; and (iii) an analysis on the impact of the AOSD-BR community outcomes in terms of well-known indicators, such as number of papers and number of citations. Results: Our analysis showed that the AOSD-BR community has impacted both the international AOSD Research community and the Software Engineering Research community in Brazil.

An aspect-oriented design model consists of a set of aspect models and a primary model. Each aspect model describes a feature that crosscuts elements in the primary model. Aspect and primary models are composed to obtain an integrated design view. In this paper we describe a composition approach that utilizes a composition algorithm and composition directives. Composition directives are used when the default composition algorithm is known or expected to yield incorrect models. Our prototype tool supports default class diagram composition.

Abstract. Software reuse is one of the most important goals in software engineering. However, server components have set, traditionally, functional and non-functional requirements what makes hard to reuse them when developing software by composing components. Of course, server components can and should set conditions in order to ensure their functionality and to avoid run-time errors. Along this paper, we will show how starting from the" Design by Contract" metaphor proposed by Meyer, we have been developed a ...

Aspect-Oriented Software Development (AOSD) techniques are gaining increased attention from both academic and industrial organisations. In order to promote a smooth adoption of such techniques it is of paramount importance to perform empirical analysis of AOSD to gather a better understanding of its benefits and limitations. In addition, the effects of aspect-oriented (AO) mechanisms on the entire development process need to be better assessed rather than just analysing each development phase in isolation. As such, this paper outlines our initial effort on the design of a testbed that will provide end-to-end systematic comparison of AOSD techniques with other mainstream modularisation techniques. This will allow the proponents of AO and non-AO techniques to compare their approaches in a consistent manner. The testbed is currently composed of: (i) a benchmark application, (ii) an initial set of metrics suite to assess certain internal and external software attributes, and (iii) a "repository" of artifacts derived from AOSD approaches that are assessed based on the application of (i) and (ii). This paper mainly documents a selection of techniques that will be initially applied to the benchmark. We also discuss the expected initial outcomes such a testbed will feed back to the compared techniques. The applications of these techniques are contributions from different research groups working on AOSD.

Runtime monitoring, where some part of a pro- gram's behavior and/or data is observed during execution, is a very useful technique that software developers to use for un- derstanding, analyzing, debugging, and improving their software. Aspect oriented programming is a natural fit for supporting the wide ranging instrumentation needs of runtime monitoring, but so far the limitations of AOP frameworks, namely supporting only code-based weaving and only a limited set of code feature joinpoint types, have hindered the application of AOP to many runtime monitoring needs. In this paper we present ideas for extending AOP to support weaving on dimensions other than source code, and for extending code-based weaving to finer- grained language constructs. I. INTRODUCTION Aspect oriented programming is an elegant framework for constructing and implementing program behavior that is orthogonal to the underlying program code base. This type of crosscutting concern historically meant that the ...

When it comes to software that runs on devices as varied as cell phones, PDAs and desktops, one size does not fit all. This paper describes how mixin layers, a kind of nested generic type, can be used to implement a graphical user interface library that can be configured to run on platforms with widely dissimilar capabilities. We describe the language support needed to incrementally build software in layers, and we describe how crosscutting concerns can be encapsulated within a layer. We then show how layers can be reconfigured to meet changing requirements. We also show how a new design pattern, the Sibling pattern, can be used with mixin layers to coordinate changes to multiple classes in the same inheritance hierarchy. When used appropriately, the Sibling pattern increases our ability to separate design concerns and to reuse code.

Nowadays, distributed and mobile systems are acquiring importance and becoming widely extended for supporting ubiquitous computing. In order to develop such systems in a technology-independent way, it is important to have a formalism that describes distribution and mobility at a high abstraction level. Ambient Calculus is a formalism that allows the representation of boundaries where computation occurs. Also, distributed and mobile systems arc usually difficult to develop as they need to take into account functional and non-functional requirements and reusability and adaptability mechanisms. In order to achieve these needs it is necessary to separate the distribution and mobility concerns from the rest of the concerns. PRISMA is an approach that integrates the advantages of Component-Based Software Development and Aspect-Oriented Software Development for specifying software architectures. In this paper, we describe how our work combines Ambient Calculus with PRISMA to develop distributed and mobile systems gaining their advantages.

Timeliness and criticality of a process are the two main concerns when designing real-time systems. In addition to that embedded systems are bounded by limited resources. To achieve these concerns while at the same time using a minimal amount or resources, real-time embedded systems use different techniques such as task scheduling, resource management and task synchronization. These techniques involve a number of the modules of the system which makes the use of Aspect-Oriented Software Development imperative. AOSD is a programming technique which uses the notion of join points to capture specific locations in code execution and then use advices to insert new code. This paper examines existing work in the development of schedulers, resource allocation agents and synchronization techniques using Aspect-Oriented Software Development in real-time embedded systems. An analysis of the existing research is used to describe the advantages of using AOSD over conventional OOP methods and to identify areas where further research may be required.

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. This paper addresses our experience in applying aspects to synchronization (mutual exclusion) and logging in a real-time embedded operating system (BOSS). Furthermore, we present our ideas for future investigation in aspect-oriented implementations for fault tolerance, middleware customization and platform variability.

Timeliness and criticality of a process are the two main concerns when designing real-time systems. In addition to that embedded systems are bounded by limited resources. To achieve timeliness and conform to the criticality issues of various processes while at the same time using a minimal amount or resources, real-time embedded systems use different techniques such as task scheduling, resource management and task synchronization. All of these techniques involve a number of the modules of the system which makes the use of Aspect-Oriented Software Development imperative. AOSD is a programming technique which uses the notion of join points to capture specific locations in code execution and then use advices to insert new code. This paper examines existing work in the development of schedulers, resource allocation agents and synchronization techniques using Aspect-Oriented Software Development in real-time systems and more specifically in embedded systems. An analysis of the existing research is used to describe the advantages of using AOSD over conventional OOP methods and to identify areas where further research may be required.

Aspect-oriented programming languages such as AspectJ provide a new way to separate out and consolidate code for debugging, profiling, distribution and other tasks that would otherwise become tangled with the main-line computation. Without aspects, this code can ...

The purpose of our present research was to diminish line stores. The outcome may well be used also by the firms which implement transactions and commercial web applications. Our case study was carried out on the platform of a virtual store, for whose navigation model we used a class diagram, via UWE (UML-based Web Engineering), which needed be modified for the navigation sustainability. There were two main sequences in the model development. In the first instance, we chose the classes which could be accessed directly and, in this fashion, structures and system menu, thus resulting a navigation structure diagram used for easily gaining each point of the application. At this point, we utilized refactoring in an attempt to offer a quality model for both developers and users.

Aspect oriented software development offer several benefits compared to the existing object oriented approach and modular approach. Aspect Oriented (AO) approach combines concerns that crosscut the modularity of the traditional programming like modular programming and object oriented programming. The reusability assessments for software practitioners and researchers have projected the various software quality models. Based on these existing quality models for software, we have proposed a reusability assessment model for AO software using Multi Criteria Decision Making (MCDM) approach. In this paper, the software reusability model for AO system is proposed and validated using Analytic Hierarchy Process (AHP) and cross validated by Fuzzy AHP (FAHP) technique. This proposed software reusability model for AO software may be used to evaluate AO software reusability and also helps software professionals to choose best reusable components and software among the available choices.

Dynamic program analysis tools based on code instrumentation serve many important software engineering tasks such as profiling, debugging, testing, program comprehension, and reverse engineering. Unfortunately, constructing new analysis tools is unduly difficult, because existing frameworks offer little or no support to the programmer beyond the incidental task of instrumentation. We observe that existing dynamic analysis tools re-address recurring requirements in their essential task: maintaining state which captures some property of the analysed program. This paper presents a general architecture for dynamic program analysis tools which treats the maintenance of analysis state in a modular fashion, consisting of mappers decomposing input events spatially, and updaters aggregating them over time. We show that this architecture captures the requirements of a wide variety of existing analysis tools.

Defining domain specific abstractions for generator systems leads to a quandary between choosing abstractions that exhibit powerful programming amplification through the combinatorial opportunities provided by composition, and choosing abstractions that can be easily transformed into high performance code. Most generation systems opt for high levels of abstraction to achieve programming amplification and as an added benefit get safety, understandability, and several other-ilities. As a consequence, the performance of their generated code is often compromised. My hypothesis is that a new generator architecture is needed to achieve both high levels of abstraction and high performance code. A generator based on such an architecture has been implemented in Common LISP. It is called the Anticipatory Optimization based generator because it allows the component and transform writers to anticipate the kinds of optimization opportunities that might arise and to prepare an abstract, distributed plan that attempts to achieve them. Based on a small number of examples that we have tested, the approach appears promising, allowing high levels of abstraction, flexibility, and performance. (See Biggerstaff98a-b.

Background: Aspect-Oriented Software Development (AOSD) is a paradigm that promotes advanced separation of concerns and modularity throughout the software development lifecycle, with a distinctive emphasis on modular structures that cut across traditional abstraction boundaries. In the last 15 years, research on AOSD has boosted around the world. The AOSD-BR research community (AOSD-BR stands for AOSD in Brazil) emerged in the last decade, and has provided different contributions in a variety of topics. However, despite some evidence in terms of the number and quality of its outcomes, there is no organized characterization of the AOSD-BR community that positions it against the international AOSD Research community and the Software Engineering Research community in Brazil. Aims: In this paper, our main goal is to characterize the AOSD-BR community with respect to the research developed in the last decade, confronting it with the AOSD international community and the Brazilian Software Engineering community. Method: Data collection, validation and analysis were performed in collaboration with several researchers of the AOSD-BR community. The characterization was presented from three different perspectives: (i) a historical timeline of events and main milestones achieved by the community; (ii) an overview of the research developed by the community, in terms of key challenges, open issues and related work; and (iii) an analysis on the impact of the AOSD-BR community outcomes in terms of well-known indicators, such as number of papers and number of citations. Results: Our analysis showed that the AOSD-BR community has impacted both the international AOSD Research community and the Software Engineering Research community in Brazil.

Adopting aspect-oriented technologies for software development requires revisiting the entire traditional software lifecycle in order to identify and represent occurrences of crosscutting during software requirements engineering and design, and to determine how concerns are composed. In this work, we propose sets of quality measurements to be associated with the activities of aspect-oriented software development (AOSD). The intended goal of the measurements is to assist stakeholders with quantitative evidences to better map or iterate system modules at different activities in the development process and to better set the design decisions for the analyzed requirements.

Aspect-oriented software development still lacks practical evidence. While aspects are claimed to be useful in adapting existing applications there is also first evidence that theymight themselves be re-usable. We present results from twocase studies with the aspect-oriented programming language ObjectTeams/Java that investigate the re-usability of aspects in developing as ecurity framework. During the development of the framework we have identified patterns for re-usable aspects that increase the flexibility when applying aframework to agiven application.

The interest in aspect-oriented software development naturally demands tool support for both implementation and evolution of aspect-oriented software, as well as refactoring current objectoriented software to aspect-oriented. In this paper, we present AJaTS-a general purpose AspectJ Transformation System, that supports AspectJ code generation and transformation. AJaTS allows the definition of specific transformations, providing a simple template-based language, as well as pre-defined aspectoriented refactorings.

The main goal of Aspect-Oriented Software Development (AOSD) is the separation of crosscutting concerns throughout the software development process in order to improve the modularity of software system artifacts and hence its comprehensibility, maintainability and reusability. However, currently, there is not a solid process for AOSD that covers the software development from requirements to design activities. Since the aspect-oriented paradigm builds on the object-oriented paradigm, it is natural the attempt to adapt existing object-oriented software development methods, processes and techniques to be used in AOSD. In this context, this work adapts some use-case driven activities of the Unified Software Development Process in order to explicitly provide the reasoning and separation of crosscutting concerns from requirements artifacts to design artifacts. Our approach is illustrated by a case study of an Internet Banking System.

Navigation modeling is one of the critical activities during web application development. It is not enough to consider only the navigation modeling based on the elements of the problem domain: it is also necessary to take into account the description of the navigation associated with tasks (i.e. the navigation needed to obtain or provide the inputs for the operations of a task and to show the information about the results of the task). Besides, it is important to describe how nonfunctional requirements and crosscutting concerns are considered during navigation modeling. Due to these requirements, navigation modeling is a complex and difficult activity whose demands can be satisfied if we adopt an aspectoriented software development (AOSD) approach that involves aspect-oriented requirements engineering, aspect-oriented navigation design, and a simple trace relation from requirements to navigation. In this work we propose an AOSD method with these features, which considers navigation modeling based on the elements of the problem domain, task navigation modeling, and the separation of the navigation for the aspects identified during requirements engineering from the navigation of the rest of the system. In addition, we provide a notation for the composition of navigation concerns.

The relationships between objects in an object-oriented program are an essential property of the program's design and implementation. Two previous approaches to implement relationships with aspects were association aspects, an AspectJ-based language extension, and the relationship aspects library. While those approaches greatly ease software development, we believe that they are not general enough. For instance, the library approach only works for binary relationships, while the language extension does not allow for the association of primitive values or values from non-weavable classes. Hence, in this work we propose a generalized alternative implementation via a direct reduction to tracematches, a language feature for executing an advice after having matched a sequence of events. This new implementation scheme yields multiple benefits. Firstly, our implementation is more general than existing ones, avoiding most previous limitations. It also yields a new language construct, relational tracematches. We provide an efficient implementation based on the AspectBench Compiler, along with test cases and microbenchmarks. Our empirical studies showed that our implementation, when compared to previous approaches, uses a similar memory footprint with no leaking, but the generality of our approach does lead to some runtime overhead. We believe that our implementation can provide a solid foundation for future research.

Evolutionary Structural Optimization (ESO) seeks to mimic the form in which nature designs shapes. This paper focuses on shape carving triggered by environmental stimuli. In this realm, existing algorithms delete under - stressed parts of a basic shape, until a reasonably efficient (under some criterion) shape emerges. In the present article, we state a generalization of such approaches in two forms: (1) We use a formalism that enables stimuli from different sources, in addition to stress ones (e.g. kinematic constraints, friction, abrasion). (2) We use metagraphs built on the Finite Element constraint graphs to eliminate the dependency of the evolution on the particular neighborhood chosen to be deleted in a given iteration. The proposed methodology emulates 2D landmark cases of ESO. Future work addresses the implementation of such stimuli type, the integration of our algorithm with evolutionary based techniques and the extension of the method to 3D shapes.

This report summarizes the outcomes of the 9th Workshop on Aspect-Oriented Modeling (AOM) held in conjunction with the 9th International Conference on Model Driven Engineering Languages and Systems-MoDELS 2006-in Genoa, Italy, on the 1st of October 2006. The workshop brought together approximately 25 researchers and practitioners from two communities: aspect-oriented software development and software model engineering. It provided a forum for discussing the state of the art in modeling crosscutting concerns at different stages of the software development process: requirements elicitation and analysis, software architecture, detailed design, and mapping to aspect-oriented programming constructs. This paper gives an overview of the accepted submissions and summarizes the results of the different discussion groups. Papers and presentation slides of the workshop are available at http://www.aspect-modeling.org/.

The modularization concept behind component-based software (CBS) cannot be applied effectively for cross-cutting concerns such as security. Aspect-oriented programming (AOP) helps in better modularization by identifying crosscutting concerns and providing a suitable way to separate those concerns. In this paper, we provide an aspectconnector based intrusion response (detection and prevention) architecture for CBS by bringing the concepts of aspects into components. The aspect-connector is named as ACIR (Aspect Connector for Intrusion Response). Component interfaces act as join points, and aspects containing pointcuts and advices are defined in ACIR configuration file. Advices applicable to particular pointcuts are two types. Signature advices are used to detect intrusions, and action advices are executed to prevent intrusions. A prototype of this architecture is implemented and evaluated using some intrusions included in the Web Application Security Consortium (WASC) intrusion list. This approach detects and prevents intrusions in CBS while maintaining encapsulation, reusability, and modularity.

Distributed vehicular control systems include several safety-critical processes so that reliability aspects are of growing importance, raising concerns about faults affecting them. Observing this fact, this paper presents a combination of aspectoriented concepts to model faults in early-design phases of distributed vehicular control systems. A fault modeling approach in communication protocols as non-functional requirements-NFR is proposed, using aspect-oriented modeling (AOM) with the support of the Real-Time From Requirements to Design using Aspects (RT-FRIDA) framework. Following practical experiments about the effect of electrical fast transients in vehicular control systems, a study was performed specifying NFR associated with these faults. Then, an evaluation with a SIG graph using the softgoal weight method and the NFR framework is presented to validate the proposed approach. The results emphasize that early fault modeling could improve the control system modeling mapping fault behaviors in order to mitigate and diagnosis the fault impact in critical tasks. The approach cover gaps related to fault modeling and allow requirements specification with AOM concepts emphasized in the case study by the correlation among network performance degradation and requirements related to faults. The analysis with the softgoal weight method also provides an alternative view of the impact of fault modeling in vehicular critical real-time systems. Keywords Fault modeling • Aspect-oriented modeling (AOM) • Distributed control systems • NFR framework 1 Introduction Distributed embedded control systems have increasing importance in the automotive area, mainly because of the growing application of electronic control units (ECU) that are fundamental to safety applications, such as ABS, traction control, AirBags among other systems. Currently, intra-vehicular networks apply communication protocols that are responsible for interconnecting several ECUs, according to a specific topology. Some safety-critical tasks communicate over the B Alexandre dos Santos Roque