SoftDock: a distributed collaborative platform for model-based software development

Unified Modeling Language (UML) plays an important role in the modern software development process by offering standardized methods for visual modeling, analysis, and design of complex systems. This paper discusses the main aspects of storing, editing, and integrating UML documents with integrated development environments (IDEs). The main focus is on comparing the two main formats for storing UML models – XML Metadata Interchange (XMI) and JavaScript Object Notation (JSON). XMI, being an official standard developed by Object Management Group, provides a high degree of detail and compatibility with various UML tools, making it preferable for large and complex projects that require support for the full UML specification. At the same time, JSON is simple and flexible, which makes it suitable for projects where speed of development and ease of integration are important, although it is inferior to XMI in describing complex aspects of UML models. The paper analyzes in detail the methods of editing UML documents, including manual editing and automated approaches, using APIs and scripts. Manual editing is useful when you need to make small changes to the structure of a UML document, but it can be time-consuming and error-prone when working with large projects. Automation, on the other hand, provides effective tools for mass editing and generating UML elements, which significantly speeds up development and minimizes the likelihood of errors, especially since modern tools such as StarUML offer the necessary tools for programmatically modifying UML documents by integrating them into development processes. Combining of UML documents with integrated development environments also plays a key role in increasing development efficiency, as this allows automating code generation based on UML models, maintaining synchronization between code and diagrams, and facilitating visualization and documentation of architectural solutions. Despite the significant advantages, there are challenges associated with limited support for all UML features and potential conflicts between models and code. This only emphasizes the need for further research in this area. Prospects for further research include the development of new methods and tools for working with UML documents, improving their integration with development environments, and using artificial intelligence to automate the analysis and design of UML models. Attention should also be paid to the using of UML with continuous integration processes, which can significantly increase the flexibility and adaptability of software development. Thus, the study of the structure of storing, editing, and integrating UML documents is an important area for optimizing the design and development of modern software systems.

We present the first conceptual results in the design of an object-oriented framework that tackles recurrent problems encountered when developing acquisition and triggering systems for high-energy physics experiments. These problems include software/hardware frontier definition and the impact of both intrinsic and performance-related distribution on software development. Based on the UML (unified modeling language) extension mechanisms and a real-time CORBA (common object request broker architecture) implementation, the framework aims at providing (1) high-level concepts for flexible hardware-software separation, and (2) simple mechanisms for transparently deriving the distribution automatically from system-level definitions. The framework will therefore implement design patterns that result from our experience of HEP (high energy physics) TDAQ (trigger and data acquisition) system development.

Unified Modeling Language (UML) has been widely accepted in the software engineering area, because it provides most of the concepts and notations that are essential for documenting object-oriented models. However, UML does not have an explicit format to describe and interchange its model information intentionally. This paper addresses the UML model interchange and presents our efforts to make UML highly interoperable. We developed an interchange format called UXF (UML eXchange Format) based on XML (Extensible Markup Language). UXF is a simple and well-structured format to encode UML models. It leverages the tool interoperability, team development and reuse of design models by interchanging the model information with the the XML standard. Also, we propose an open distribution platform for UML models, which provides multiple levels of interoperability of UML models. Our work shows an important step in the evolution for the interoperable UML.

Under the double pressures of global competition and increasing environmental awareness, the importance of high‐performance simulation tools in the process industries (food, chemicals, oil, …) is rapidly growing. However, traditional simulation environments are closed monolithic systems which are extensible only by a small group of market‐leading vendors. The resulting bottlenecks in interoperability, reuse and innovationled to the CAPE‐OPEN project, in which the chemical and oil industries are defining standards for a component‐based approach to process simulation, in order to open up the market to smaller vendors and to facilitate rapid industrial uptake of academic research prototypes. For general systems engineering, the CAPE‐OPEN standardising process has at least two interesting features: (a) it has experimented on a large scale with a distributed use case approach, following a variant of the UML (Unified Modelling Language) approach for modelling, but also linking down to programming standards based on CORBA (Common Object Request Broker Architecture) and COM (Common Object Model); (b) the management of this world‐wide distributed effort has been facilitated by the use of an Internet‐based workspace co‐operation environment, augmented by advanced structuring and analysis methods from software engineering and computational intelligence.

Describes the initial design work of the New Zealand Distributed Information Systems (NZDIS) research project, which seeks to develop an architecture for building distributed information systems from existing information resources, based on software agent and distributed object technologies. An agent-based architecture is used, with messages exchanged via the FIPA (Foundation for Intelligent Physical Agents) agent communication language (ACL). Novel features of this system include the use of standards from the object-oriented programming community, such as the Common Object Request Broker Architecture (CORBA) as a communications infrastructure, the Unified Modeling Language (UML), which is used as an ontology representation language, the Object Data Management Group's Object Query Language (OQL), which is used for queries, and the Object Management Group's Meta Object Facility (MOF), which is used as the basis for an ontology repository agent. 'Stringified' object references may be returned as the content of ACL messages, allowing query results to be made available via a variety of CORBA interfaces.

The test and training enabling architecture (TENA) middleware is the result of a joint interoperability initiative of the Director, Operational Test and Evaluation (DOT&E) of the Office of the Secretary of Defense (OSD). The goals of the initiative are to enable interoperability among ranges, facilities, and simulations in a quick and cost-efficient manner, and to foster reuse of range assets and future range system developments. The TENA middleware uses Unified Modeling Language (UML)-based model-driven code generation to automatically create a complex Common Object Request Broker Architecture (CORBA) application. This model-driven automatic code-generation greatly reduces the amount of software that must be hand-written and tested. Furthermore, the TENA middleware combines distributed shared memory, anonymous publish-subscribe, and model-driven distributed object-oriented programming paradigms into a single distributed middleware system. This unique combination yields a powerful middleware system that enables its users to rapidly develop sophisticated yet understandable distributed applications. The TENA middleware offers powerful programming abstractions that are not present in CORBA alone and provides a strongly-typed application programmer interface (API) that is much less error-prone than the existing CORBA API. These high-level, easy-to-understand programming abstractions combined with an API designed to reduce programming errors enable users to quickly and correctly express the concepts of their applications. Re-usable standardized objects farther simplify the development of applications. The net result of this combination of features is a significant reduction of application programming errors yielding increased overall reliability and decreased overall development time. Distributed applications developed using the TENA middleware exchange data using the publish-subscribe paradigm. Although many publish-subscribe systems exist, the TENA middleware represents a significant advance in the field due to the many high-level, model-driven programming abstractions it presents to the programmer. The TENA middleware API relies heavily on compile-time type-safety to help ensure reliable behavior at runtime. Careful API design allows a great number of potential errors to be detected at compile-time that might otherwise go unnoticed until run-time - where the cost of an error could be extremely high! The implementation of the TENA middleware uses C++, as well as a real-time CORBA ORB. The TENA middleware is currently in use at dozens of Department of Defense (DoD) testing and training range facilities across the county and has been used to support major test and training events such as Joint Red Flag '05. The TENA Middleware is available at http://www.tena-sda.org/

To develop a conventional CORBA(Common Object Request Broker Architecture)-based distributed object system, first the system’s requirements must be analyzed in requirements analysis step and system’s overall interface and details must be specified and built using IDL(Interface Definition Language) in design step. However, there are not too many models available that can be used as a benchmark in specifying the requirements and details of the CDO(CORBA-based distributed object) system. Conversion to IDL from requirements analysis step or preliminary design stage is a difficult task and an effective method for verification of IDL is not currently available. In the light of unique features of distributed object system, IDL errors that occur in the beginning of software development become the main causes of errors for the system as a whole. This paper suggests SACC (Software Architecture-based CORBA Component) model as a solution to the problems mentioned above m specifying details and verifying CDO system. SACC model uses SCI (SACC Converted IDL) algorithms to be converted to IDL. SACC model utilizes software architecture approach. SACC modeling method uses CTL (Computational Tree Logic) to verify CORBA system that is specified by SACC model. In conclusion, SACC modeling method is proven effective in specifying details and verifying the CDO system. Furthermore, it helps programmers to effectively convert to IDL, which is highly reliable.

The Unified Modelling Language (UML) is a language for specifying, visualising, constructing and documenting software systems. The UML proved to be extremely successful and it has achieved tremendous popularity making it the de facto industry standard for object oriented system development. As such, many researchers presented empirical studies on the practical usage of UML but as well criticisms for UML complexity, difficulty to be learnt, etc. Even though a large number of articles and books are devoted to various aspects of UML language, there is little evidence on how UML is used. This study attempts to identify the profile of persons using UML, to pinpoint UML diagrams that are being used and their effectiveness, to discover whether CASE tools are being used and to record the perceived usefulness of UML language. For conducting the study a survey was developed and it was distributed to mailing lists of Greek IT professionals and to university students. The findings indicate that UML is used successfully in the majority of software development projects and that most users perceive UML positively since it supports faster system building, development of higher quality software systems, and for specific cases, it leads to software development cost‐decrease.

In the software community, modeling and programming are generally considered to be different things. However, some software models specify behavior precisely enough that they can be executed in their own right. And all programs can be considered models, at least of the executions that they specify. So perhaps modeling and programming are not actually so different after all. Indeed, there is a modeling/programming convergence going on right now in the Unified Modeling Language (UML) community, with a recent series of specifications on precise execution semantics for a growing subset of UML. But the language design legacy of UML is largely grounded in the old view that sharply separates models and programs, complicating the new convergence. It is perhaps now time to move forward to a new generation of unified modeling/programming languages.

Summary form only given. Since its adoption in 1997, the unified modeling language (UML) has proved very popular with software engineers and has become the de facto standard as a visual modeling language for software engineers. However, this software focus of UML has discouraged many systems engineers from adopting it in earnest. Those who did adopt UML developed strategies to cope with its shortcomings. A common approach was to model additional systems engineering concepts in other modeling tools. This made it difficult to integrate the different viewpoints and achieve traceability. Fortunately, with the release of UML 2.0 and the ensuing extensions to it in SysML - the soon-to-be adopted systems modeling language - the systems engineering community has a real alternative to systems modeling that provides a more integrated approach to systems and software engineering. Since its inception in 1997, ARTiSAN has endeavored to bridge the gap between systems and software engineering modeling by adding systems engineering extensions to the UML and, as a key member of the SysML initiative, is well poised to support these emerging standards for systems and software modeling. This presentation will provide a brief overview of the major extensions proposed by SysML, and will summarize how ARTiSAN's latest release of its flagship product Studio (version 6.0) takes the lead in supporting these concepts.

Component-based software development would allow application software to be largely constructed rather than programmed. This approach would dramatically improve the productivity of software development. Although there are many reusable software packages available, the integration of the chosen parts remains a very difficult problem because there are many barriers of integration, including programming languages, operating systems, communication mechanism, interface, etc. In this paper, an approach to developing real-time application software based on a distributed component architecture and cross-platform and cross-language integration of these software components is presented. The Common Object Request Broker Architecture (CORBA) is used in the implementation. The distributed components will satisfy easy retrieval and integration over a heterogeneous distributed system environment. A component replication mechanism is used for providing fault-tolerance. Using object adapters with a real-time request monitor and scheduler that are transparently generated by a distributed component integration tool, real-time and fault-tolerance features can be easily incorporated in the application software.

CAD/CAM systems are the important interface for automating manufacturing processes to accommodate the varying market demands. However, they are often operated in an isolated environment and are unable to communicate with each other. Rapid development and enhancement of the network technology had made it possible for manufacturing processes to be implemented in a distributed environment. The purpose of this study is to develop a dispersed networked multi-axis surface manufacturing system. The proposed research uses the Integrated Definition for Function Modelling (IDEF0) methodology to analyze the manufacturing activities and adopts the Common Object Request Broker Architecture (CORBA) standard as the infrastructure of software components. Using IDEF0, the manufacturing activities can be analyzed and represented as a hierarchical and structural functional model. The developed system has the “plug-and-play” capability and can be integrated with other development teams to achieve information sharing. On-line test of the prototype system has been implemented collaboratively by three development teams and the effectiveness of the developed system has also been confirmed. The developed system has successfully integrated resources of different locations through a network and can effectively reduce the product development and manufacturing time, thus enhancing the global competitiveness of the industry.

Distributed software development is becoming a common practice among developers. Factors such as the development environments improvement, their extensibility, and the emergence of social networking software are leading factors. They lead the development process (both co-located and geographically distributed) to a practice that: 1) improves the team’s productivity, and 2) encourages and supports the social interaction among the teams’ members. The above factors along with the distributed development emergence, Integrated Development Environments (IDEs) evolution, and the social media advances got the attention of the software development teams, and made them consider how to better assist the social nature of software developers, and the social aspects of software development, including activity awareness of team members’ progress, their presence, collaboration, communication, and coordination around shared artifacts. IDEs are the most commonly used tools by developers and programmers. Integrating the most needed development tools inside the IDE, makes it a Collaborative Development Environment (CDE), and embedding a variety of social software features within a CDE helps support distributed development teams. It also creates a new genera of tools called Social Development Environments or “SDEs” as it is commonly called. This article discusses the origins and development of “SDEs”. It reflects and presents the research into development environments, explaining their role in supporting the communication and coordination needs of development teams. Also, it presents the effect of embedding social network features in such environments. It presents some emerging SDEs and future work. Finally, it concludes by introducing a new model named 5-star that classifies, and helps to evaluate and compare the collaborative tools. 5-star presents a new way to compare and evaluate the SDE systems based on their supported features. It bases the comparison on five major categories including: Communication, Coordination, Collaboration, Awareness & Presence, and Social networking (SN) tools.

In this paper, we identify a set of factors that may be used to forecast software productivity and software development time. Software productivity was measured in function points per person hours, and software development time was measured in number of elapsed days. Using field data on over 130 field software projects from various industries, we empirically test the impact of team size, integrated computer aided software engineering (ICASE) tools, software development type, software development platform, and programming language type on the software development productivity and development time. Our results indicate that team size, software development type, software development platform, and programming language type significantly impact software development productivity. However, only team size significantly impacts software development time. Our results indicate that effective management of software development teams, and using different management strategies for different software development type environments may improve software development productivity.

The smart grid is characterized as a power system that integrates real-time measurements, bi-directional communication, a two-way flow of electricity, and evolutionary computation. The power distribution system is a fundamental aspect of the electric power system in order to deliver safe, efficient, reliable, and resilient power to consumers. A distribution management system (DMS) begins with the extension of the Supervisory Control and Data Acquisition (SCADA) system through a transmission network beyond the distribution network. These transmission networks oversee the distribution of energy generated at power plants to consumers via a complex system of transformers, substations, transmission lines, and distribution lines. The major challenges that existing distribution management systems are facing, maintaining constant power loads, user profiles, centralized communication, and the malfunctioning of system equipment and monitoring huge amounts of data of millions of micro-transactions, need to be addressed. Substation feeder protection abruptly shuts down power on the whole feeder in the event of a distribution network malfunction, causing service disruption to numerous end-user clients, including industrial, hospital, commercial, and residential users. Although there are already many traditional systems with the integration of smart things at present, there are few studies of those systems reporting runtime errors during their implementation and real-time use. This paper presents the systematic model of a distribution management system comprised of substations, distribution lines, and smart meters with the integration of Internet-of-Things (IoT), Nondeterministic Finite Automata (NFA), Unified Modeling Language (UML), and formal modeling approaches. Non-deterministic finite automata are used for automating the system procedures. UML is used to represent the actors involved in the distribution management system. Formal methods from the perspective of the Vienna Development Method-Specification Language (VDM-SL) are used for modeling the system. The model will be analyzed using the facilities available in the VDM-SL toolbox.