Notion Of Design Research Articles

The Effect of Overlapping Area on Ping-Pong Handover in LTE Networks

Aspect Oriented Programming (AOP) is a technique used to enhance the separation of concern in software design and implementation. To implement AOP developers most commonly use AspectJ, an extension of the Java language. In order to represent the separation of concerns a new design technique is needed for modeling of aspects. Aspect Oriented Design language (ASDL) is a design notation could build on the existing design language UML. It is capable of supporting many aspects-oriented languages. This research aims to investigate where developers can use aspect-oriented programming in the software development process. This includes how to identify Aspects in the design stage, then how they can be applied in the implementation process in software development. This will lead to improve modularity and reusability of the software. The paper will be a position paper abut Aspect Oriented Software Design, also will investigate several case studies of the design and implementation of a software application that shows how we can identify the Aspect in the process.

IMPROVING THE DESIGN AND IMPLEMENTATION OF SOFTWARE SYSTEMS USES ASPECT ORIENTED PROGRAMMING

Aspect Oriented Programming (AOP) is a technique used to enhance the separation of concern in software design and implementation. To implement AOP developers most commonly use AspectJ, an extension of the Java language. In order to represent the separation of concerns a new design technique is needed for modeling of aspects. Aspect Oriented Design language (ASDL) is a design notation could build on the existing design language UML. It is capable of supporting many aspects-oriented languages. This research aims to investigate where developers can use aspect-oriented programming in the software development process. This includes how to identify Aspects in the design stage, then how they can be applied in the implementation process in software development. This will lead to improve modularity and reusability of the software. The paper will be a position paper abut Aspect Oriented Software Design, also will investigate several case studies of the design and implementation of a software application that shows how we can identify the Aspect in the process.

Design notations for secure software: a systematic literature review

In the past 10 years, the research community has produced a significant number of design notations to represent security properties and concepts in a design artifact. These notations are aimed at documenting and analyzing security in a software design model. The fragmentation of the research space, however, has resulted in a complex tangle of different techniques. Hence, practitioners are confronted with the challenging task of scouting the right approach from a multitude of proposals. Similarly, it is hard for researchers to keep track of the synergies among the existing notations, in order to identify the existing opportunities for original contributions. This paper presents a systematic literature review that inventorizes the existing notations and provides an in-depth, comparative analysis for each.

Repast Simphony Statecharts

Agent states and transitions between states are important abstractions in agent-based social simulation (ABSS). Although it is common to develop ad hoc implementations of state-based and transition-based agent behaviors, 'best practice' software engineering processes provide transparent and formally grounded design notations that translate directly into working implementations. Statecharts are a software engineering design methodology and an explicit visual and logical representation of the states of system components and the transitions between those states. Used in ABSS, they can clarify a model's logic and allow for efficient software engineering of complex state-based models. In addition to agent state and behavioral logic representation, visual statecharts can also be useful for monitoring agent status during a simulation, quickly conveying the underlying dynamics of complex models as a simulation evolves over time. Visual approaches include drag-and-drop editing capabilities for constructing state-based models of agent behaviors and conditions for agent state transitions. Repast Simphony is a widely used, open source, and freely accessible agent-based modeling toolkit. While it is possible for Repast Simphony users to create their own implementations of state-based agent behaviors and even create dynamic agent state visualizations, the effort involved in doing so is usually prohibitive. The new statecharts framework in Repast Simphony, a subset of Harel's statecharts, introduces software engineering practices through the use of statecharts that directly translate visual representations of agent states and behaviors into software implementations. By integrating an agent statecharts framework into Repast Simphony, we have made it easier for users at all levels to take advantage of this important modeling paradigm. Through the visual programming that statecharts afford, users can effectively create the software underlying agents and agent-based models. This paper describes the development and use of the free and open source Repast Simphony statecharts capability for developing ABSS models.

Embodied Design Cognition: Action-Based Formalizations in Architectural Design

This paper frames design knowledge as formalizable physical actions that can more fully exploit future design tools and production methods. As computational design tools become more physically interactive and integrated into our environment we need new research frameworks to develop theories of physical design action as a form of knowledge. Symbolic theories of design knowledge traditionally frame design activity as a mental process and as a result researchers have not fully explored the potential for bodily-based computational design knowledge. We present an action-based design notation drawing inspiration from music performance theory to illustrate how this may impact design research. We discuss findings from situated cognition in cognitive science as an alternative framework for exploring and expanding design knowledge. We conclude with suggestions for future work in robotic-aided design cognition.

Design and Instrumental Means of Electronic Services Generation for State Authorities

The article analyzes the existing information service design notations as per their applicability in state organs functioning; shows the low efficiency of the existing notations in such systems development. The goal of the article is to evaluate the new methodology of information services design elaborated within the author’s participation in TASIS G2B project (2005-2007) for electronic government setup in Russia. It is also to consider the information systems generation tools for state authorities being a unique informatization object. The publication shows the results of practical implementation of the approaches described in the creation of state-owned land allotment (to civil and legal entities) information system in Karelia.

Up and out

Systems are naturally constructed in hierarchies in which design choices made at higher levels of abstraction ``flow down'' to requirements on system components at lower levels of abstraction. Thus, whether an aspect of the system is a design choice or a requirement depends largely on one's vantage point within the hierarchy of system components. Furthermore, systems are often constructed middle-out rather than top-down; compatibility with existing systems and architectures, or availability of specific components influences high-level requirements. We believe that requirements and architectural design should be more closely aligned: that requirements models must account for hierarchical system construction, and that architectural design notations must better support specification of requirements for system components. In this presentation, I describe tools supporting iterative development of architecture and verification based on software models. We represent the hierarchical composition of the system in the Architecture Analysis & Design Language (AADL), and use an extension to the AADL language to describe requirements at different levels of abstraction for compositional verification. To describe and verify component-level behavior, we use Simulink and Stateflow and multiple analysis tools.

Your "What" Is My "How": Iteration and Hierarchy in System Design

Systems are naturally constructed in hierarchies, in which design choices made at higher levels of abstraction levy requirements on system components at the lower levels. Thus, whether an aspect of a system is a design choice or a requirement largely depends on your vantage point within the system components' hierarchy. Systems are also often constructed from the middle-out rather than top-down; compatibility with existing systems and architectures and availability of specific components influence high-level requirements. Requirements and architectural design should be more closely aligned: requirements models must account for hierarchical system construction and architectural design notations must better support requirements specification for system components.

Modeling and visualizing object-oriented programs with Codecharts

Software design, development and evolution commonly require programmers to model design decisions, visualize implemented programs, and detect conflicts between design and implementation. However, common design notations rarely reconcile theoretical concerns for rigor and minimality with the practical concerns for abstraction, scalability and automated verifiability. The language of Codecharts was designed to overcome these challenges by narrowing its scope to visual specifications that articulate automatically-verifiable statements about the structure and organization of object-oriented programs. The tokens in its visual vocabulary stand for the building-blocks of object-oriented design, such as inheritance class hierarchies, sets of dynamically-bound methods, and their correlations. The formalism was tailored for those pragmatic concerns which arise from modeling class libraries and design patterns, and for visualizing programs of any size at any level of abstraction. We describe design verification, a process of proving or refuting that a Java program (i.e. its native code) conforms to the Codechart specifying it. We also describe a toolkit which supports modeling and visualization with Codecharts, as well as a fully-automated design verification tool. We conclude with empirical results which suggest gains in both speed and accuracy when using Codecharts in software design, development and evolution.

Using structured analysis for the control of real-time systems

After a presentation of the real time system analysis and design, we present the Structured Analysis for Real Time Systems, or SA-RT. This graphical design notation is focusing on analyzing the functional behaviour and information flow through a system. In fact, the modeling of the real time systems helps us to understand its working, without eliminating its complexity. Then, we present the graphic and textual formalism of the SA-RT method on the one hand and we apply this method on a practical case of an ABS braking system, on the other hand. Key words: Real time systems, SA-RT method, ABS braking system.

Integrating the SysML and the SystemC-UML profiles in a model-driven embedded system design flow

Modern embedded systems development, due to systems complexity and multifaceted nature, requires flexible high-level design techniques and notations. In this context, model-driven approaches are gaining popularity, both in industry as well as in academy, since they offer a high degree of abstraction and provide a common framework for the design, simulation and configuration management of complex heterogeneous systems. Moreover, a great variety of languages have been emerging as customization (or profiles) of the Unified Modeling Language (UML) for the embedded system and System-on-Chip (SoC) domains. No single modeling language or profile is adequate to cover aspects and requirements of the whole system development flow. Indeed, each of these languages owns characteristics and offers modeling primitives suitable for designing at a specific abstraction level. Therefore, possible strategies for integrating such UML profiles must be determined, in order to establish a common modeling framework able to support all steps of a system design development. This paper presents the integration of two modeling languages, the SysML and the SystemC UML profiles. The integration is based on a mapping from the SysML to the SystemC UML profile for the structural aspects, while for the behavioral aspects two main models of computation, SysML control-flow graphs and SystemC Process state machines, are proposed as complementary behavioral formalisms to be adopted in a model-driven SoC design flow at platform-independent and platform-specific description level, respectively. The integration we propose, has enabled us also to refine an already defined model-driven hardware-software co-design flow, where a gap remained moving from a platform-independent design level to a platform-specific level. The refined co-design flow starts from a SysML description at a high level of design abstraction, and proceeds through a chain of refined SystemC UML models, to lower levels of design abstraction, where the more complex last-level SystemC coding is left to automation.

A logic-based semantics for the verification of multi-diagram UML models

UML is a well-known and widely used design notation: it offers a rich set of modeling elements, but their behavior is often not properly defined. Many proposals have tried to provide UML with a formal semantics, but they often focus on a limited number of diagram types, and thus do not provide a viable solution for the actual verification of complex UML models. This paper addresses a significant and consistent set of UML diagrams, called MADES UML, and uses a metric temporal logic to ascribe a formal semantics to them. It also introduces a prototype verification tool based on a bounded model/satis ability checker. The verification of a car collision avoidance system gave encouraging results.

Rigorous development of composite grid services

Cress (Communication Representation Employing Systematic Specification) is introduced as notation, a methodology and a toolset for service development. The article focuses on rigorous development of composite grid services, with particular emphasis on the principles behind the methodology. A straightforward graphical notation is used to describe grid services. These are then automatically specified, analysed and implemented. Analysis includes formal verification of desirable service properties, formal validation of test scenarios, testing of implementation functionality, and evaluation of implementation performance. The case study that illustrates the approach is document content analysis to compare two pieces of text. This involves two composite services supported by two partner services. The usability of the service design notation is assessed, and a comparison is made of the approach with similar ones. These show that the Cress approach to developing services is usable and more complete than other comparable approaches.

Making sense of business process descriptions: An experimental comparison of graphical and textual notations

How effective is a notation in conveying the writer's intent correctly? This paper identifies understandability of design notations as an important aspect which calls for an experimental comparison. We compare the success of university students in interpreting business process descriptions, for an established graphical notation (BPMN) and for an alternative textual notation (based on written use-cases). Because a design must be read by diverse communities, including technically trained professionals such as developers and business analysts, as well as end-users and stakeholders from a wider business setting, we used different types of participants in our experiment. Specifically, we included those who had formal training in process description, and others who had not. Our experiments showed significant increases by both groups in their understanding of the process from reading the textual model. This was not so for the graphical model, where only the trained readers showed significant increases. This finding points at the value of educating readers of graphical descriptions in that particular notation when they become exposed to such models in their daily work.

Dependability analysis of DES based on MARTE and UML state machines models

UML (Unified Modeling Language) is a standard design notation which offers the state machines diagram to specify reactive software systems. The "Modeling and Analysis of Real-Time and Embedded systems" profile (MARTE) enables UML with capabilities for performance analysis. MARTE has been specialized in a "Dependability Analysis and Modeling" profile (DAM), then providing UML with dependability assets. In this work, we propose an approach for the automatic transformation of UML-DAM models into Deterministic and Stochastic Petri nets and the subsequent dependability analysis.

User-comprehension of Euler diagrams

Euler diagrams are a diagrammatic system for representing and reasoning with set theoretic statements. Syntactic constraints called wellformedness conditions (WFCs) are often imposed with the intention of reducing comprehension errors, but there is little supporting empirical evidence that they have the desired effect. We report on experiments which support the theory that the WFCs are generally beneficial for novice user comprehension, but we discover that violating some individual WFCs, such as concurrency, can be beneficial. Furthermore, we examine a prioritisation of the WFCs, derived from the user comprehension results, which could be used to prioritise theoretical work on generation problems or to assist in the provision of a choice of a diagram to display to users, for instance. We have used similar materials to our previous ‘preference study’ for cross comparison purposes. This accumulation of work has motivated the development of a model of the user comprehension with the aim of more closely linking theoretical and empirical works examining effective notation design, general approaches to displaying notations and interacting with notations.

Automatic generation of design search keywords from software specifications to improve design search results

Software Design Notation Storage and Inference Mechanism (DNSIM) is capable of storing software designs by using Design Markup Language (DGML) tags and reusing existing design elements to produce new software designs. This mechanism performs search operations on stored designs. The accuracy of the search results depends upon the correctness of the keywords provided to the search process. The challenge is to input the Software Requirement Specification (SRS) document as a search input to DNSIM and to produce the best possible design from existing design elements. This paper proposes a method to produce requirement specification keywords from the formal representation of the SRS. The DNSIM system uses the keywords produced by our method and shows significant improvements and accuracy in the design search results

How Developers' Experience and Ability Influence Web Application Comprehension Tasks Supported by UML Stereotypes: A Series of Four Experiments

In recent years, several design notations have been proposed to model domain-specific applications or reference architectures. In particular, Conallen has proposed the UML Web Application Extension (WAE): a UML extension to model Web applications. The aim of our empirical investigation is to test whether the usage of the Conallen notation supports comprehension and maintenance activities with significant benefits, and whether such benefits depend on developers ability and experience. This paper reports and discusses the results of a series of four experiments performed in different locations and with subjects possessing different experience-namely, undergraduate students, graduate students, and research associates-and different ability levels. The experiments aim at comparing performances of subjects in comprehension tasks where they have the source code complemented either by standard UML diagrams or by diagrams stereotyped using the Conallen notation. Results indicate that, although, in general, it is not possible to observe any significant benefit associated with the usage of stereotyped diagrams, the availability of stereotypes reduces the gap between subjects with low skill or experience and highly skilled or experienced subjects. Results suggest that organizations employing developers with low experience can achieve a significant performance improvement by adopting stereotyped UML diagrams for Web applications.

The “Physics” of Notations: Toward a Scientific Basis for Constructing Visual Notations in Software Engineering

Visual notations form an integral part of the language of software engineering (SE). Yet historically, SE researchers and notation designers have ignored or undervalued issues of visual representation. In evaluating and comparing notations, details of visual syntax are rarely discussed. In designing notations, the majority of effort is spent on semantics, with graphical conventions largely an afterthought. Typically, no design rationale, scientific or otherwise, is provided for visual representation choices. While SE has developed mature methods for evaluating and designing semantics, it lacks equivalent methods for visual syntax. This paper defines a set of principles for designing cognitively effective visual notations: ones that are optimized for human communication and problem solving. Together these form a design theory, called the Physics of Notations as it focuses on the physical (perceptual) properties of notations rather than their logical (semantic) properties. The principles were synthesized from theory and empirical evidence from a wide range of fields and rest on an explicit theory of how visual notations communicate. They can be used to evaluate, compare, and improve existing visual notations as well as to construct new ones. The paper identifies serious design flaws in some of the leading SE notations, together with practical suggestions for improving them. It also showcases some examples of visual notation design excellence from SE and other fields.

Data analysis for experimental design

Data analysis for experimental design