Abstract: Requirements modeling and analysis are important in successful information systems' maintenance. Unified Modeling Language (UML) class diagrams are useful standards for modeling information systems. To our best knowledge, there is a lack of a systems development methodology described by the organism metaphor. The core concept of this metaphor is adaptation. Using the knowledge representation and reasoning approach and ontologies to adopt new requirements are emergent in recent years. This paper proposes an organic methodology which is based on constructivism theory. This methodology is a knowledge representation and reasoning approach to analyze new requirements in the class diagrams maintenance. The process and rules in the proposed methodology automatically analyze inconsistencies in the class diagram. In the big data era, developing an automatic tool based on the proposed methodology to analyze large amounts of class diagram data is an important research topic in the future.
Abstract: Unified Modeling Language (UML) is considered as one of the widespread modeling language standardized by the Object Management Group (OMG). Therefore, the model driving engineering (MDE) community attempts to provide reuse of UML diagrams, and do not construct it from scratch. The UML model appears according to a specific software development process. The existing method generation models focused on the different techniques of transformation without considering the development process. Our work aims to construct an UML component from fragments of UML diagram basing on an agile method. We define UML fragment as a portion of a UML diagram, which express a business target. To guide the generation of fragments of UML models using an agile process, we need a flexible approach, which adapts to the agile changes and covers all its activities. We use the software product line (SPL) to derive a fragment of process agile method. This paper explains our approach, named RECUP, to generate UML fragments following an agile process, and overviews the different aspects. In this paper, we present the approach and we define the different phases and artifacts.
Abstract: Unified Modeling language (UML) is one of the
important modeling languages used for the visual representation of
the research problem. In the present paper, UML model is designed
for the Instruction pipeline which is used for the evaluation of the
instructions of software programs. The class and sequence diagrams
are designed & performance is evaluated for instructions of a sample
program through a case study.
Abstract: Tanzania secondary schools in rural areas are geographically and socially isolated, hence face a number of problems in getting learning materials resulting in poor performance in National examinations. E-learning as defined to be the use of information and communication technology (ICT) for supporting the educational processes has motivated Tanzania to apply ICT in its education system. There has been effort to improve secondary school education using ICT through several projects. ICT for e-learning to Tanzania rural secondary school is one of the research projects conceived by the University of Dar-es-Salaam through its College of Engineering and Technology. The main objective of the project is to develop a tool to enable ICT support rural secondary school. The project is comprehensive with a number of components, one being development of e-learning management system (e-LMS) for Tanzania secondary schools. This paper presents strategies of developing e-LMS. It shows the importance of integrating action research methodology with the modeling methods as presented by model driven architecture (MDA) and the usefulness of Unified Modeling Language (UML) on the issue of modeling. The benefit of MDA will go along with the development based on software development life cycle (SDLC) process, from analysis and requirement phase through design and implementation stages as employed by object oriented system analysis and design approach. The paper also explains the employment of open source code reuse from open source learning platforms for the context sensitive development of the e-LMS for Tanzania secondary schools.
Abstract: A key to success of high quality software development
is to define valid and feasible requirements specification. We have
proposed a method of model-driven requirements analysis using
Unified Modeling Language (UML). The main feature of our method
is to automatically generate a Web user interface mock-up from UML
requirements analysis model so that we can confirm validity of
input/output data for each page and page transition on the system by
directly operating the mock-up. This paper proposes a support method
to check the validity of a data life cycle by using a model checking tool
“UPPAAL" focusing on CRUD (Create, Read, Update and Delete).
Exhaustive checking improves the quality of requirements analysis
model which are validated by the customers through automatically
generated mock-up. The effectiveness of our method is discussed by a
case study of requirements modeling of two small projects which are a
library management system and a supportive sales system for text
books in a university.
Abstract: In recent past, the Unified Modeling Language (UML) has become the de facto industry standard for object-oriented modeling of the software systems. The syntax and semantics rich UML has encouraged industry to develop several supporting tools including those capable of generating deployable product (code) from the UML models. As a consequence, ensuring the correctness of the model/design has become challenging and extremely important task. In this paper, we present an approach for automatic verification of protocol model/design. As a case study, Session Initiation Protocol (SIP) design is verified for the property, “the CALLER will not converse with the CALLEE before the connection is established between them ". The SIP is modeled using UML statechart diagrams and the desired properties are expressed in temporal logic. Our prototype verifier “UML-SMV" is used to carry out the verification. We subjected an erroneous SIP model to the UML-SMV, the verifier could successfully detect the error (in 76.26ms) and generate the error trace.
Abstract: Mathematical, graphical and intuitive models are often
constructed in the development process of computational systems.
The Unified Modeling Language (UML) is one of the most popular
modeling languages used by practicing software engineers. This
paper critically examines UML models and suggests an augmented
use case view with the addition of new constructs for modeling
software. It also shows how a use case diagram can be enhanced. The
improved modeling constructs are presented with examples for
clarifying important design and implementation issues.
Abstract: Unified Modeling Language (UML) extensions for real time embedded systems (RTES) co-design, are taking a growing interest by a great number of industrial and research communities. The extension mechanism is provided by UML profiles for RTES. It aims at improving an easily-understood method of system design for non-experts. On the other hand, one of the key items of the co- design methods is the Hardware/Software partitioning and scheduling tasks. Indeed, it is mandatory to define where and when tasks are implemented and run. Unfortunately the main goals of co-design are not included in the usual practice of UML profiles. So, there exists a need for mapping used models to an execution platform for both schedulability test and HW/SW partitioning. In the present work, test schedulability and design space exploration are performed at an early stage. The proposed approach adopts Model Driven Engineering MDE. It starts from UML specification annotated with the recent profile for the Modeling and Analysis of Real Time Embedded systems MARTE. Following refinement strategy, transformation rules allow to find a feasible schedule that satisfies timing constraints and to define where tasks will be implemented. The overall approach is experimented for the design of a football player robot application.
Abstract: UML is a collection of notations for capturing a software system specification. These notations have a specific syntax defined by the Object Management Group (OMG), but many of their constructs only present informal semantics. They are primarily graphical, with textual annotation. The inadequacies of standard UML as a vehicle for complete specification and implementation of real-time embedded systems has led to a variety of competing and complementary proposals. The Real-time UML profile (UML-RT), developed and standardized by OMG, defines a unified framework to express the time, scheduling and performance aspects of a system. We present in this paper a framework approach aimed at deriving a complete specification of a real-time system. Therefore, we combine two methods, a semiformal one, UML-RT, which allows the visual modeling of a realtime system and a formal one, CSP+T, which is a design language including the specification of real-time requirements. As to show the applicability of the approach, a correct design of a real-time system with hard real time constraints by applying a set of mapping rules is obtained.
Abstract: Component-Based software engineering provides an
opportunity for better quality and increased productivity in software
development by using reusable software components [10]. One of the
most critical aspects of the quality of a software system is its
performance. The systematic application of software performance
engineering techniques throughout the development process can help
to identify design alternatives that preserve desirable qualities such
as extensibility and reusability while meeting performance objectives
[1]. In the present scenario, software engineering methodologies
strongly focus on the functionality of the system, while applying a
“fix- it-later" approach to software performance aspects [3]. As a
result, lengthy fine-tunings, expensive extra hard ware, or even
redesigns are necessary for the system to meet the performance
requirements. In this paper, we propose design based,
implementation independent, performance prediction approach to
reduce the overhead associated in the later phases while developing a
performance guaranteed software product with the help of Unified
Modeling Language (UML).
Abstract: One of object oriented software developing problem
is the difficulty of searching the appropriate and suitable objects for
starting the system. In this work, ontologies appear in the part of
supporting the object discovering in the initial of object oriented
software developing. There are many researches try to demonstrate
that there is a great potential between object model and ontologies.
Constructing ontology from object model is called ontology
engineering can be done; On the other hand, this research is aiming to
support the idea of building object model from ontology is also
promising and practical. Ontology classes are available online in any
specific areas, which can be searched by semantic search engine.
There are also many helping tools to do so; one of them which are
used in this research is Protégé ontology editor and Visual Paradigm.
To put them together give a great outcome. This research will be
shown how it works efficiently with the real case study by using
ontology classes in travel/tourism domain area. It needs to combine
classes, properties, and relationships from more than two ontologies
in order to generate the object model. In this paper presents a simple
methodology framework which explains the process of discovering
objects. The results show that this framework has great value while
there is possible for expansion. Reusing of existing ontologies offers
a much cheaper alternative than building new ones from scratch.
More ontologies are becoming available on the web, and online
ontologies libraries for storing and indexing ontologies are increasing
in number and demand. Semantic and Ontologies search engines have
also started to appear, to facilitate search and retrieval of online
ontologies.
Abstract: Unified Modeling Language (UML) is a standard
language for modeling of a system. UML is used to visually specify
the structure and behavior of a system. The system requirements are
captured and then converted into UML specification. UML
specification uses a set of rules and notations, and diagrams to
specify the system requirements. In this paper, we present a tool for
developing the UML specification. The tool will ease the use of the
notations and diagrams for UML specification as well as increase the
understanding and familiarity of the UML specification. The tool will
also be able to check the conformance of the diagrams against each
other for basic compliance of UML specification.