5,858 research outputs found
Object-oriented modelling with unified modelling language 2.0 for simple software application based on agile methodology
Unified modelling language (UML) 2.0 introduced in 2002 has been developing
and influencing object-oriented software engineering and has become a standard
and reference for information system analysis and design modelling. There are
many concepts and theories to model the information system or software
application with UML 2.0, which can make ambiguities and inconsistencies for a
novice to learn to how to model the system with UML especially with UML 2.0.
This article will discuss how to model the simple software application by using
some of the diagrams of UML 2.0 and not by using the whole diagrams as
suggested by agile methodology. Agile methodology is considered as convenient
for novices because it can deliver the information technology environment to
the end-user quickly and adaptively with minimal documentation. It also has the
ability to deliver best performance software application according to the
customer's needs. Agile methodology will make simple model with simple
documentation, simple team and simple tools.Comment: 15 pages, 30 figure
Extension to UML-B Notation and Toolset
The UML-B notation has been created as an attempt to combine the success and ease of use of UML, with the verification and rigorous development capabilities of formal methods. However, the notation currently only supports a basic diagram set. To address this we have, in this project, designed and implemented a set of extensions to the UML-B notation that provide a much fuller software engineering experience, critically making UML-B more appealing to industry partners. These extensions comprise five new diagram types, which are aimed at supplying a broader range of design capabilities, such as conceptual Use-Case design and future integration with the ProB animator tool
Distribution pattern-driven development of service architectures
Distributed systems are being constructed by composing a number of discrete components. This practice is particularly prevalent within the Web service domain in the form of service process orchestration and choreography. Often, enterprise systems are built from many existing discrete applications such as legacy applications exposed using Web service interfaces. There are a number of architectural configurations or distribution patterns, which express how a composed system is to be deployed in a distributed environment. However, the amount of code
required to realise these distribution patterns is considerable. In this paper, we propose a distribution
pattern-driven approach to service composition and architecting. We develop, based on a catalog of patterns, a UML-compliant framework, which takes existing Web service interfaces as its input and generates executable Web service compositions based on a distribution pattern chosen by the software architect
A thread-tag based semantics for sequence diagrams
The sequence diagram is one of the most popular behaviour modelling languages which offers an intuitive and visual way of describing expected behaviour of object-oriented software. Much research work has investigated ways of providing a formal semantics for sequence diagrams. However, these proposed semantics may not properly interpret sequence diagrams when lifelines do not correspond to threads of controls. In this paper, we address this problem and propose a thread-tag based sequence diagram as a solution. A formal, partially ordered multiset based semantics for the thread-tag based sequence diagrams is proposed
A software architecture for autonomous maintenance scheduling: Scenarios for UK and European Rail
A new era of automation in rail has begun offering developments in the operation and maintenance of industry standard systems. This article documents the development of an architecture and range of scenarios for an autonomous system for rail maintenance planning and scheduling. The Unified Modelling Language (UML) has been utilized to visualize and validate the design of the prototype. A model for information exchange between prototype components and related maintenance planning systems is proposed in this article. Putting forward an architecture and set of usage mode scenarios for the proposed system, this article outlines and validates a viable platform for autonomous planning and scheduling in rail
Three Dimensional Software Modelling
Traditionally, diagrams used in software systems modelling have been two dimensional (2D). This is probably because graphical notations, such as those used in object-oriented and structured systems modelling, draw upon the topological graph metaphor, which, at its basic form, receives little benefit from three dimensional (3D) rendering. This paper presents a series of 3D graphical notations demonstrating effective use of the third dimension in modelling. This is done by e.g., connecting several graphs together, or in using the Z co-ordinate to show special kinds of edges. Each notation combines several familiar 2D diagrams, which can be reproduced from 2D projections of the 3D model. 3D models are useful even in the absence of a powerful graphical workstation: even 2D stereoscopic projections can expose more information than a plain planar diagram
Automated Mapping of UML Activity Diagrams to Formal Specifications for Supporting Containment Checking
Business analysts and domain experts are often sketching the behaviors of a
software system using high-level models that are technology- and
platform-independent. The developers will refine and enrich these high-level
models with technical details. As a consequence, the refined models can deviate
from the original models over time, especially when the two kinds of models
evolve independently. In this context, we focus on behavior models; that is, we
aim to ensure that the refined, low-level behavior models conform to the
corresponding high-level behavior models. Based on existing formal verification
techniques, we propose containment checking as a means to assess whether the
system's behaviors described by the low-level models satisfy what has been
specified in the high-level counterparts. One of the major obstacles is how to
lessen the burden of creating formal specifications of the behavior models as
well as consistency constraints, which is a tedious and error-prone task when
done manually. Our approach presented in this paper aims at alleviating the
aforementioned challenges by considering the behavior models as verification
inputs and devising automated mappings of behavior models onto formal
properties and descriptions that can be directly used by model checkers. We
discuss various challenges in our approach and show the applicability of our
approach in illustrative scenarios.Comment: In Proceedings FESCA 2014, arXiv:1404.043
- ā¦