155 research outputs found
Recommended from our members
Test data generation from UML state machine diagrams using GAs
Automatic test data generation helps testers to validate
software against user requirements more easily. Test
data can be generated from many sources; for example,
experience of testers, source program, or software
specification. Selecting a proper test data set is a
decision making task. Testers have to decide what test
data that they should use, and a heuristic technique is
needed to solve this problem automatically. In this
paper, we propose a framework for generating test data
from software specifications. The selected specification
is Unified Modeling Language (UML) state machine
diagram. UML state machine diagram describes a
system in term of state which can be changed when
there is an action occurring in the system. The
generated test data is a sequence of these actions.
These sequences of action help testers to know how they
should test the system. The quality of generated test
data is measured by the number of transitions which is
fired using the test data. The more transitions test data
can fire, the better quality of test data is. The number of
coverage transitions is also used as a feedback for a
heuristic search for a better test set. Genetic algorithms
(GAs) are selected for searching the best test data. Our
experimental results show that the proposed GA-based
approach can work well for generating test data for
some types of UML state machine diagrams
Partial Reconfiguration in the Field of Logic Controllers Design
The paper presents method for logic controllers multi context implementation by means of partial reconfiguration. The UML state machine diagram specifies the behaviour of the logic controller. Multi context functionality is specified at the specification level as variants of the composite state. Each composite state, both orthogonal or compositional, describes specific functional requirement of the control process. The functional decomposition provided by composite states is required by the dynamic partial reconfiguration flow. The state machines specified by UML state machine diagrams are transformed into hierarchical configurable Petri nets (HCfgPN). HCfgPN are a Petri nets variant with the direct support of the exceptions handling mechanism. The paper presents placesoriented method for HCfgPN description in Verilog language. In the paper proposed methodology was illustrated by means of simple industrial control process
Teaching Concurrent Software Design: A Case Study Using Android
In this article, we explore various parallel and distributed computing topics
from a user-centric software engineering perspective. Specifically, in the
context of mobile application development, we study the basic building blocks
of interactive applications in the form of events, timers, and asynchronous
activities, along with related software modeling, architecture, and design
topics.Comment: Submitted to CDER NSF/IEEE-TCPP Curriculum Initiative on Parallel and
Distributed Computing - Core Topics for Undergraduate
Graph Digitalizer
Szükséges lehet kinyerni tudományos cikkek ábráiból, mért regisztrátumokból egy függvény grafikonjának (x, y) pontjait, de előfordulhat, hogy nincs mód megszerezni az eredeti adatokat. Pontok koordinátáit, oszlopdiagramok magasságát egyszerűen le lehet olvasni, de folytonos görbéket nem leeht szemmel digitalizálni. A program feladata beszkennelt PDF-ből kivágott grafikonok, mit képfájlok betöltése, binárissá alakítása, simitása, 1 pixelessé vékonyítása (szkelotonizálása) és kalibrálása. Tegye lehetővé az így kinyert függvénypontok fájlba mentését. A program rendelkezzen felhasználói felülettel, nyelve C++
Modelling learning behaviour of intelligent agents using UML 2.0
This thesis aims to explore and demonstrate the ability of the new standard of
structural and behavioural components in Unified Modelling Language (UML 2.0 / 2004)
to model the learning behaviour of Intelligent Agents. The thesis adopts the research
direction that views agent-oriented systems as an extension to object-oriented systems. In
view of the fact that UML has been the de facto standard for modelling object-oriented
systems, this thesis concentrates on exploring such modelling potential with Intelligent
Agent-oriented systems. Intelligent Agents are Agents that have the capability to learn and
reach agreement with other Agents or users. The research focuses on modelling the
learning behaviour of a single Intelligent Agent, as it is the core of multi-agent systems.
During the writing of the thesis, the only work done to use UML 2.0 to model
structural components of Agents was from the Foundation for Intelligent Physical Agent
(FIPA). The research builds upon, explores, and utilises this work and provides further
development to model the structural components of learning behaviour of Intelligent
Agents. The research also shows the ability of UML version 2.0 behaviour diagrams,
namely activity diagrams and sequence diagrams, to model the learning behaviour of
Intelligent Agents that use learning from observation and discovery as well as learning
from examples of strategies. The research also evaluates if UML 2.0 state machine
diagrams can model specific reinforcement learning algorithms, namely dynamic
programming, Monte Carlo, and temporal difference algorithms. The thesis includes user
guides of UML 2.0 activity, sequence, and state machine diagrams to allow researchers in
agent-oriented systems to use the UML 2.0 diagrams in modelling the learning components
of Intelligent Agents.
The capacity for learning is a crucial feature of Intelligent Agents. The research
identifies different learning components required to model the learning behaviour of
Intelligent Agents such as learning goals, learning strategies, and learning feedback
methods. In recent years, the Agent-oriented research has been geared towards the agency
dimension of Intelligent Agents. Thus, there is a need to conduct more research on the
intelligence dimension of Intelligent Agents, such as negotiation and argumentation skills.
The research shows that behavioural components of UML 2.0 are capable of
modelling the learning behaviour of Intelligent Agents while structural components of
UML 2.0 need extension to cover structural requirements of Agents and Intelligent Agents.
UML 2.0 has an extension mechanism to fulfil Agents and Intelligent Agents for such
requirements. This thesis will lead to increasing interest in the intelligence dimension
rather than the agency dimension of Intelligent Agents, and pave the way for objectoriented
methodologies to shift more easily to paradigms of Intelligent Agent-oriented
systems.The British
Council, the University of Plymouth and the Arab-British Chamber Charitable Foundation
Refactoring of UML models using AGG
Model refactoring is an emerging research topic that is heavily inspired
by refactoring of object-oriented programs. Current-day UML modeling environments provide poor support for evolving UML models and applying refactoring techniques at model level. As UML models are intrinsically graph-based in nature we propose to use graph transformations to specify and apply model refactoring. More in particular, we use a specific graph transformation tool, AGG, and provide recommendations of how AGG may be improved to better support model refactoring. These recommendations are based on a small experiment that we have carried out with refactoring of UML class diagrams and state machines
From UML specification into FPGA implementation
In the paper a method of using the Unified Modeling Language for specification of digital systems, especially logic controllers, is presented. The proposed method is based mainly on the UML state machine diagrams and uses Hierarchical Concurrent Finite State Machines (HCFSMs) as a temporary model. The paper shows a way to transform the UML diagrams, expressed in XML language, to the form that is acceptable by reconfigurable FPGAs (Field Programmable Gate Arrays). The UML specification is used to generate an effective program in Hardware Description Languages (HDLs), especially Verilog
Recommended from our members
Generation of Software Test Data from the Design Specification Using Heuristic Techniques. Exploring the UML State Machine Diagrams and GA Based Heuristic Techniques in the Automated Generation of Software Test Data and Test Code.
Software testing is a tedious and very expensive undertaking. Automatic test data generation is, therefore, proposed in this research to help testers reduce their work as well as ascertain software quality. The concept of test driven development (TDD) has become increasingly popular during the past several years. According to TDD, test data should be prepared before the beginning of code implementation. Therefore, this research asserts that the test data should be generated from the software design documents which are normally created prior to software code implementation.
Among such design documents, the UML state machine diagrams are selected as a platform for the proposed automated test data generation mechanism. Such diagrams are selected because they show behaviours of a single object in the system. The genetic algorithm (GA) based approach has been developed and applied in the process of searching for the right amount of quality test data. Finally, the generated test data have been used together with UML class diagrams for JUnit test code generation.
The GA-based test data generation methods have been enhanced to take care of parallel path and loop problems of the UML state machines. In addition the proposed GA-based approach is also targeted to solve the diagrams with parameterised triggers.
As a result, the proposed framework generates test data from the basic state machine diagram and the basic class diagram without any additional nonstandard information, while most other approaches require additional information or the generation of test data from other formal languages. The transition coverage values for the introduced approach here are also high; therefore, the generated test data can cover most of the behaviour of the system.EU Asia-Link project TH/Asia Link/004(91712) East-West and CAM
Does Code Generation Promote or Prevent Optimizations?
International audienceThis paper addresses the problem of code optimization for Real-Time and Embedded Systems (RTES). Such systems are designed using Model-Based Development (MBD)approach that consists of performing three major steps: building models, generating code from them and compiling the generated code. Actually, during the code generation, an important part of the modeling language semantics which could be useful for optimization is lost, thus, making impossible some optimizations achievement. This paper shows how adding a new level of optimization at the model level results in a more compact code. It also discusses the impact of the code generation on optimization: whether this step promotes or prevents optimizations. We conclude on a proposal of a new MBD approach containing only steps that advance optimization: modeling and compiling steps
- …