Developing Distributed Applications Rapidly and Reliably Using the Tena Middleware

Power management systems for embedded devices can be developed in operating system (OS) or in applications. If power management policy is applied in OS, then developers can concentrate only on application development. OS contains specific and accurate information about the various tasks being executed. Therefore, it is logical to place algorithms that place components not being used into lower power states. This can significantly reduce the energy consumption by the system. Real-time-operating-system (RTOS) has a comprehensive set of power management application programming interfaces (APIs) for both device drivers and applications within a power management component. In this paper, we provide abstracted concepts of a system power manager (PM), device power managers, and application power managers. We present relationship and interactions of these managers with each using Unified Modeling Language (UML) class diagrams, sequence diagrams and state charts. We recommend that PM must be implemented at operating system level in any embedded device. We also recommend the interfaces for interactions between PM and the devices power manager, as well as PM and application power manager. Device driver and application developers can easily use this object oriented approach to make the embedded system more power efficient, easy to maintain, and faster to develop

This chapter introduces a programming environment for SCI clusters that takes advantage of both parallel and distributed programming paradigms. It aims at helping programmers to design high performance applications based on the assembling of generic software components. This environment is based on CORBA (Common Object Request Broker Architecture), with our own extensions to support parallelism across several cluster nodes within a distributed system. Our contribution concerns extensions to support a new kind of object, which we call a parallel CORBA object (or parallel object), as well as the integration of message-passing paradigms, mainly MPI, within a parallel object. These extensions exploit as much as possible the functionality offered by CORBA and require few modifications to an available CORBA implementation. This paper reports on these extensions and the description of a runtime system, called Cobra, which provides resource allocation services for the execution of parallel objects.

The US Department of Defense (DoD), through the Office of the Secretary of Defense (OSD), has determined that evolutionary acquisition is their strategy of choice for future software-intensive systems, and that the spiral development model (SDM) is the preferred method/process for software-intensive development life cycles. Electronic Systems Command (ESC) at Hanscom AFB, Massachusetts, has written a draft handbook on the use of Spiral Development for all future Command and Control (C2) systems, including reference to the DoD 5000 series and Air Force Program Directive 63-1, Acquisition System, which deploys this OSD mandate for future C2 systems. Barry Boehm's continued work on SDM which he conceived in the 1980s, is heavily biased toward development of new systems that are software-intensive, as noted in a workshop he gave at the Software Engineering Institute (SEI) in 2000.

The Telecommunications Management Network (TMN) has been developed as the framework to support administrations in managing telecommunications networks. It suggests the use of OSI Systems Management (OSI-SM) as the technology for management information exchanges. Distributed object technologies, such as the Common Object Request Broker architecture (CORBA), address the use of software application program interfaces (APIs) in addition to interoperable protocols. Their use in TMN has been the subject of intensive research in previous years, with most approaches focusing on interoperability aspects with OSI-SM. We examine the issues behind using distributed object technologies in TMN via a native fashion, with network elements supporting distributed objects directly, e.g., a CORBA to the switch approach. The proposed solution tries to maintain the full OSI-SM expressive power in a way that other solutions have not attempted before. Performance and scalability issues are considered, while the approach has been validated through implementation.

Component-based software development is the successor of object-oriented software development. Authors of the paper extend existing Unified Modeling Language standard to describe containers semantically, automate the process of creating containers and later deploying them to the platform as a service. The paper presents the concept of using Unified Modeling Language (UML) as well as principles of Model Driven Architecture (MDA) to automate creating of and maintaining containers. The main aims are designing meta-model language that is capable of defining Docker containers as part of software architecture modeling process and using transformations to create Docker files that can be used to instantiate container. The paper presents UML profile UML Docker Services Profile and model-to-text transformation Model2DockerFile transformation. Both, the profile and the transformation were designed, implemented and incorporated in IBM Rational Software Development environment. The developed environment can be used to generate DockerFile files, from UML models with applied specific stereotypes from UML Docker Services Profile, that can be used in containers runtime.

In this paper, we propose a verification methodology for System-On-Chip (SoC) design using Unified Modeling Language (UML). We introduce UML as a formal model to analyze and formalize the specification. The specification and implementation validation can be performed systematically by introducing UML. We applied our method to a Mobile Media Processors SoC. We improved the quality of ζ the specification written in informal natural language through UML modeling techniques. The test scenarios and coverage metrics for implementation are derived from the UML model systematically. The result shows that our proposal is effective for eliminating errors from both specification and implementation.

The basic precondition for effective management and protection of a forest is a concept built on modern methods of collection, processing, analysis and publication of spatial data about forest coverage, as well as its health status. This paper provides a structural concept for integration of heterogeneous data in the support of the forest protection with implementation of the latest methods of remote sensing data collection. The main principles of the structural concept of Forest protection management system (FPMS) result from the assessment of the current and new available data sources (represented by the Diagram of data sources), data analysis and development of innovative mathematical techniques of image processing (represented by the Diagram of methods and tools). Mind maps of the proposed diagrams were created in the free mind mapping application FreeMind. The structural concept is represented by an analytical model of the co-operation of data sources, tools and applications. The dynamic structure was proposed using Unified Modelling Language (UML). The Diagram of the use cases is represented by a Use Case Diagram in UML. The Diagram of the processes, which describes the main processes realized within forest protection management, is represented by an Activity Diagram in UML. The UML diagrams were created in open-source software StarUML. The resulted structural concept of FPMS is the basis of a predictive model improvement and a web application development for the forest protection from the bark beetle.

Software developers are increasingly using Unified Modeling Language (UML) tools to automate source code generation. Therefore, nowadays calculating software metrics from UML diagrams to evaluate software quality is an important trend in the software industry. However, acquisition of software metrics from Extensible Markup Language (XML) export of UML tools has been predominantly tool dependent. Moreover, each new tool may have different specifications in XML. Despite the overall need for a process to automate XML unification, no current solution has yet been proposed. Creating a framework to automate this assessment would streamline development and increase efficiency in software industry. With the aim to overcome this deficiency, we developed a parser-based framework, named UXSOM, to calculate software metrics independently from the UML tool. Particularly UXSOM is able to generate software metrics from the XML-based outputs of the tools, ArgoUML, UMLET, MagicDraw, Sparx Systems, and ESS Model. We showed a very general case of UML class diagram, in which we extracted and compared software metrics from these five different tool.

Risk is the possibility of suffering loss. Risks identified during the early stages of software development are easier and cheaper to handle by making changes to the software architecture. This thesis presents methodologies to assess software risk using Unified Modeling Language (UML) specifications of the software from the early design stages. We present methodologies to assess two types of software risk: Requirements-based risk and Performance-based risk. In assessing requirements-based risk, each requirement is mapped to a specific operational scenario in UML. The risk factor of a scenario in a failure mode is obtained by combining the probability of failure of the scenario and the severity of the failure. For the performance-based risk analysis, we use UML diagrams with performance related annotations, build a software execution model for each scenario and then map it to a system execution model using the deployment information. For estimating the performance-based failures of each scenario we use an asymptotic bounding analysis. The methodologies are applied on various case studies.

In the evolving landscape of complex business ecosystems and their digital platforms, an increasing number of business Application Programming Interfaces (APIs) are encountering challenges in ensuring optimal authorization control. This challenge arises due to factors such as programming errors, improper configurations, and sub-optimal business processes. While security departments have exhibited proficiency in identifying vulnerabilities and mitigating certain viral or adversarial incursions, the safeguarding of comprehensive business processes remains an intricate task. This paper introduces a novel paradigm, denoted as the Low-Intervention Security Embedding Architecture (LiSEA), which empowers business applications to enhance the security of their processes through judicious intervention within business APIs. By strategically incorporating pre- and post-intervention checkpoints, we devise a finely grained access control model that meticulously assesses both the intent of incoming business requests and the outcomes of corresponding responses. Importantly, these advancements are seamlessly integrated into the existing business codebase. Our implementation demonstrates the effectiveness of LiSEA, as it adeptly addresses eight out of the ten critical vulnerabilities enumerated in the OWASP API Security Top 10. Notably, when the number of threads is less than 200, LiSEA brings less than 20 msec of latency to the business process, which is significantly less than the microservice security agent based on the API gateway.

The paper describes our SoftDock system, which is a distributed model management system to support collaborative software development. SoftDock leverages the team development, tool interoperability, and model continuity across development lifecycle. It supports Unified Modeling Language (UML) to specify software models, and maintains the model information with UML eXchange Format (UXF), which is a XML-based model interchange format. UXF-encoded model descriptions are shared and managed through the Document Object Model (DOM) interface implemented on top of CORBA (Common Object Request Broker Architecture) middleware. The paper describes the SoftDock architecture, system organization, and design considerations in managing UXF descriptions in the distributed environment.

To solve the identification and comprehension problem of crosscutting concerns in existing legacy software system, a framework of aspects-oriented software reverse engineering was proposed. An approach on re-modularizing traversal features of legacy system was presented, which based on various Unified Modeling Language (UML) diagrams. While modeling crosscutting concerns in UML use case diagrams, the non-functional requirements that affect several use case modules can be enveloped into aspects modules with stereotype mechanism. The recurring message transmission patterns can be re-modularized as aspects in UML sequence diagrams with UML collaborations. Standard UML activity diagram notations were extended and modified by nodes fusion and addition, which support the graphical composition operation between crosscutting behaviors and primary business rules of concurrent system. The case study indicates traversal features of software system can be extracted and re-modularized from various perspectives in aspects-oriented reverse engineering, which improves the comprehensibility and maintainability of legacy system.

The Unified Modeling Language (UML) has been widely accepted as the standard object-oriented (OO) modeling language for modeling various aspects of software and information systems. The UML is an extensible language, in the sense that it provides mechanisms to introduce new elements for specific domains if necessary, such as web applications, database applications, business modeling, software development processes, data warehouses and so on. Furthermore, the latest work of the Object Management Group (OMG) on UML [1] resulted in a larger and more complicated specification, with even more diagrams for some good reasons. Although providing different diagrams for modeling specific parts of a software system, not all of them need to be applied in most cases. Therefore, heuristics, design guidelines, and lessons learned from experiences are extremely important for the effective use of UML and to avoid unnecessary complication.

Computer-aided software engineering (CASE) Tools is a set of software that results in high-quality and maintainable software products. The Unified Modeling Language (UML) is one of the most commonly used CASE tools for analyzing and expressing software requirements. Considerably, UML overcomes ambiguity limitation which results from infamous shortcoming of national language. However, how to express requirements of E-Commerce System is still a very challenging problem. In this paper, requirement analysis is highlighted by IBM Rational Rose and Microsoft Visio, and typical E-Commerce system by UML is investigated as well. At the end, a guideline generated for Jewellery E-Commerce (JEC) is presented by UML use cases, activity diagrams, and data flow diagrams in details.

In terms of data processing information, in NIASA CV there is no permanent systemyet, did not use any application like Microsoft Excel and others. For the size of a company, according to the author's observations there are many weaknesses, and the system used so far is only the result of the calculation of the purchase of raw materials and the sale of finished goods. The report also took a long time to record it because there is no bookkeeping.In this design system using the method of survey in the collection and processing of data information to contain a picture of the situation in place of research object. As for system design, the author uses Unified Modeling Language (UML). UML it self are one of many tools under Object Oriented Programming, so safe to assume that Star UML will be the right tool for analyze. The design is now expected to facilitate users in reporting and the owners of Niasa CV can view or collect reports easily, quickly, and probably help the CV to have a permanent system.