Visual Debugging of Object-Oriented Systems with the Unified Modeling Language

The Department of Defense (DoD) is developing a Joint Battlespace Infosphere, linking a large number of data sources and user applications. Debugging and analysis tools are required to aid in this process. Debugging of large object-oriented systems is a difficult cognitive process that requires understanding of both the overall and detailed behavior of the application. In addition, many such applications linked through a distributed system add to this complexity. Standard debuggers do not utilize visualization techniques, focusing mainly on information extracted directly from the source code. To overcome this deficiency, this research designs and implements a methodology that enables developers to analyze, troubleshoot and evaluate object-oriented systems using visualization techniques. It uses the standard UML class diagram coupled with visualization features such as focus+context, animation, graph layout, color encoding and filtering techniques to organize and present information in a manner that facilitates greater program and system comprehension. Multiple levels of abstraction, from low-level details such as source code and variable information to high-level structural detail in the form of a UML class diagram are accessible along with views of the program s control flow. The methods applied provide a considerable improvement (up to 1110%) in the number of classes that can be displayed in a set display area while still preserving user context and the semantics of UML, thus maintaining system understanding. Usability tests validated the application in terms of three criteria software visualization, debugging, and general system usability

Infopipes—an Abstraction for Information Flow

Building Object-Oriented Distributed Systems has been facilitated by Remote Message Sending (RMS) systems like Java RMI and implementations of CORBA. However, RMS systems are designed to support request/response interactions. Streaming applications, in contrast, are characterized by high-bandwidth, long-duration communication with stringent performance requirements. Examples of streaming applications include video-on-demand, teleconferencing, on-line education, and environmental observation. These applications transfer huge amounts of data and focus on distributed information flow rather than request/response. To simplify the task of building distributed streaming applications, we propose a new abstraction for information flow—Infopipes. Using Infopipes, information flow becomes the heart of the system, not an auxiliary mechanism that is hidden away. Systems are built by connecting pre-defined component Infopipes such as sources, sinks, buffers, filters, broadcasting pipes, and multiplexing pipes. An Infopipe has a data interface that pulls information items from the upstream Infopipes, or pushes them into the downstream Infopipes, or both. An Infopipe also has a control interface that dynamically monitors and controls the properties of the Infopipe, and hence the properties of the information flowing through it. We intend to provide property-preserving composition of Infopipes, so that the properties of the whole pipeline can be calculated from the properties of the component Infopipes in it. Quality of Service (QoS) requirements then can be analyzed and understood system-wide. In Section 2 we discuss related technologies. In Section 3 we describe the concepts of Infopipes. We report our work on an Infopipe prototype in Section 4. Section 5 summarizes the features of Infopipes and lists some open questions

Modélisation et vérification du flux d'information pour les systèmes orientés objets

RÉSUMÉ Afin d'assurer la protection de la confidentialité et l'intégrité des systèmes orientés objet, cet article propose une modèle d'étiquettes décentralisées (méfiance mutuelle et sécurité décentralisée) pour le contrôle des flux d'information dans des modèles UML et son intégration dans UML. Le document présente la syntaxe et la sémantique formelle des modèles UML (les diagrammes de classes, diagrammes d'objets et diagrammes d'états) étendus avec des fonctionnalités supplémentaires qui prennent en charge le contrôle des flux d'information. Il prend en charge la vérification du flux d'information à l'exécution et permet de s'assurer que le système n'admet que des flux d'information légaux. Ainsi des politiques de sécurité flexibles sont définies sur des diagrammes UML juste en les étiquetant. Le contrôle du flot de données et des canaux de transmission est effectué au niveau des diagrammes de classes, diagrammes d'objets et diagrammes d'états. Cela permet de définir le flux d'information lorsque le comportement des objets changent.----------ABSTRACT For protection of the confidentiality and integrity of object-oriented systems, this paper proposes a decentralized label model for control of information flow in UML system models with mutual distrust and decentralized security and its integration into UML. The paper introduces UML (class diagrams, object and statecharts) syntax and formal semantics extensions with additional features that support information flow control. It supports run-time verification of information flow so that the system model can be certified to permit only admissible information flows. Using this, flexible security policies can be easily defined through UML diagrams just by labelling them. The control of data flows and transmitting channels is performed at the level of Class diagrams, Object diagrams and Statechart diagrams. This allows to define information flow when the behaviour of objects change

Integration of an object formalism within a hybrid dynamic simulation environment

PrODHyS is a general object-oriented environment which provides common and reusable components designed for the development and the management of dynamic simulation of systems engineering. Its major characteristic is its ability to simulate processes described by a hybrid model. In this framework, this paper focuses on the "Object Differential Petri Net" (ODPN) formalism integrated within PrODHyS. The use of this formalism is illustrated through a didactic example relating to the field of Chemical Process System Engineering (PSE)

Towards Practical Graph-Based Verification for an Object-Oriented Concurrency Model

To harness the power of multi-core and distributed platforms, and to make the development of concurrent software more accessible to software engineers, different object-oriented concurrency models such as SCOOP have been proposed. Despite the practical importance of analysing SCOOP programs, there are currently no general verification approaches that operate directly on program code without additional annotations. One reason for this is the multitude of partially conflicting semantic formalisations for SCOOP (either in theory or by-implementation). Here, we propose a simple graph transformation system (GTS) based run-time semantics for SCOOP that grasps the most common features of all known semantics of the language. This run-time model is implemented in the state-of-the-art GTS tool GROOVE, which allows us to simulate, analyse, and verify a subset of SCOOP programs with respect to deadlocks and other behavioural properties. Besides proposing the first approach to verify SCOOP programs by automatic translation to GTS, we also highlight our experiences of applying GTS (and especially GROOVE) for specifying semantics in the form of a run-time model, which should be transferable to GTS models for other concurrent languages and libraries.Comment: In Proceedings GaM 2015, arXiv:1504.0244

Combining behavioural types with security analysis

Today's software systems are highly distributed and interconnected, and they increasingly rely on communication to achieve their goals; due to their societal importance, security and trustworthiness are crucial aspects for the correctness of these systems. Behavioural types, which extend data types by describing also the structured behaviour of programs, are a widely studied approach to the enforcement of correctness properties in communicating systems. This paper offers a unified overview of proposals based on behavioural types which are aimed at the analysis of security properties

History-sensitive versus future-sensitive approaches to security in distributed systems

We consider the use of aspect-oriented techniques as a flexible way to deal with security policies in distributed systems. Recent work suggests to use aspects for analysing the future behaviour of programs and to make access control decisions based on this; this gives the flavour of dealing with information flow rather than mere access control. We show in this paper that it is beneficial to augment this approach with history-based components as is the traditional approach in reference monitor-based approaches to mandatory access control. Our developments are performed in an aspect-oriented coordination language aiming to describe the Bell-LaPadula policy as elegantly as possible. Furthermore, the resulting language has the capability of combining both history- and future-sensitive policies, providing even more flexibility and power.Comment: In Proceedings ICE 2010, arXiv:1010.530