Container-based virtualization is becoming a preferred choice to deploy services since it is lightweight and supports on-demand scalability as well as availability. The Process Automation Industry has accepted this technology to make their applications service oriented. However, container-based microservice architecture is effective only when the original software strictly followed modularity principles during its design. In this article, we share our learning of converting a distributed software to a microservice-based architecture using containers. Though the existing system has a modular design and deployed as distributed components, analysis of the current architecture shows that the application is monolithic (though modularized) and the components are strongly coupled in an indirect manner. As a result, it turns to be impossible to attain microservice-based architecture without changing the architecture. Next, we propose a microservice-based containerized TO-BE architecture of the application, and demonstrate that this TO-BE architecture does not incur any significant overhead. Finally, we propose a set of recommendations that the practitioners can follow to convert a monolithic application to a containerized architecture.

Test suite minimization ensures that an optimum set of test cases are selected to provide maximum coverage of requirements. In this paper, we discuss and evaluate techniques for test suite minimization of evolving software systems. As a case study, we have used an industrial tool, Static Code Analysis (SCAN) tool for Electronic Device Description Language (EDDL) as the System Under Test (SUT). We have used standard approaches including Greedy, Greedy Essential (GE) and Greedy Redundant Essential (GRE) for minimization of the test suite for a given set of requirements of the SUT. Further, we have proposed and implemented k-coverage variants of these approaches. The minimized test suite which is obtained as a result reduces testing effort and time during regression testing. The paper also addresses the need for choosing an appropriate level of granularity of requirements to efficiently cover all requirements. The paper demonstrates how fine grained requirements help in finding an optimal test suite to completely address the requirements and also help in detecting bugs in each version of the software. Finally, the results from different analyses have been presented and compared and it has been observed that GE heuristics performs the best (run time) under certain conditions. Copyright © 2019 by SCITEPRESS - Science and Technology Publications, Lda. All rights reserved.

Agriculture 4.0 aims to use recent advances in technology to enhance productivity and reduce operating costs. In precision feeding systems using robots, farm configuration should support robot maneuvers and precision feeding operations. Such configuration needs to be checked during design and operations to avoid costly modifications and damage to robots. This investigation presents an incremental model- based approach for robot farm runtime configuration management. First, an abstract model of the configuration is generated and its feasibility is verified using model checking. Then, simulation based verification by introducing low-level operational details (robot speed, capacity, etc.) is performed which is used to refine formal verification. Finally, operational correctness in real exploitation conditions is tested against the simulation. Our results show that the proposed incremental validation minimizes the validation time, design space exploration and cost during early stages of design, rather than during operations which could lead to significant cost.

Commercial software development projects frequently build code on third-party components. However, depending on third-party code requires that projects keep current with the latest version of each component. When projects do not stay current, they begin to incur a form of technical debt where API calls that have been deprecated remain in the code base. At some point, projects must upgrade the third-party component to remain on a supported version of the component. Then the projects incur the cost of paying down the debt that was built up over time. The model described herein intends to estimate the cost of paying down the debt for aging third-party components.

In this paper, we report our experiences of applying three complementary automated software architecture analysis techniques, supported by a tool suite, called DV8, to 8 industrial projects within a large company. DV8 includes two state-of-the-art architecture-level maintainability metrics—Decoupling Level and Propagation Cost, an architecture flaw detection tool, and an architecture root detection tool. We collected development process data from the project teams as input to these tools, reported the results back to the practitioners, and followed up with telephone conferences and interviews. Our experiences revealed that the metrics scores, quantitative debt analysis, and architecture flaw visualization can effectively bridge the gap between management and development, help them decide if, when, and where to refactor. In particular, the metrics scores, compared against industrial benchmarks, faithfully reflected the practitioners’ intuitions about the maintainability of their projects, and enabled them to better understand the maintainability relative to other projects internal to their company, and to other industrial products. The automatically detected architecture flaws and roots enabled the practitioners to precisely pinpoint, visualize, and quantify the “hotspots" within the systems that are responsible for high maintenance costs. Except for the two smallest projects for which both architecture metrics indicated high maintainability, all other projects are planning or have already begun refactorings to address the problems detected by our analyses. We are working on further automating the tool chain, and transforming the analysis suite into deployable services accessible by all projects within the company.

Industry 4.0 aims at highly flexible and digitized model of industrial production that is smarter and more reliable than the current possibilities. This requires vertical integration of different operations in a manufacturing to promote reconfigurable smart factory. This investigation proposes a method to schedule maintenance operations using formal methods considering power balance and production constraints in process industries. First, we provide an optimization model for scheduling maintenance and operation along production schedules. Second, we use timed model checking to schedule maintenance considering various physical and operating constraints. Third, we illustrate the method in a smart aluminium factory. The main contribution of this investigation is the integration of optimization models and formal methods in one framework, which leads to verified production/maintenance schedules and contributes to the objectives of Industry 4.0.

Renewables play an important role in today's sustainable power and energy systems. In this paper, we model and analyze an FPGA based power management system for renewables by using the UPPAAL modeling and verification tool. Our main objective is to ensure correctness of the system design using formal methods based techniques. Through our case study, we establish the correctness of the FPGA based control algorithm with respect to the system requirements. All requirements regarding effective utilization of loads and sources by their activation and deactivation, and also requirements of battery bank (which ensures that battery will not charge and discharge deeply), are specified using Timed Computation Tree logic. On the basis of our analysis, we confirm that the design of the implemented power management system conforms to its specifications.

We present our monitoring and decision framework for collaborative engineering for globally distributed operation, support, maintenance, and services for industrial automation. The framework provides relevant information to plant operators, engineers, staff and stakeholders to support the handling of incidents, based on semantically-appropriate factors such as personnel skills, physical location of affected equipment and dependencies between plant elements. We discuss the proposed application and present the architecture and implementation. Based on incoming events the framework selects, aggregates and displays information automatically for human processing possibly at distant control centres. For example an alarm in a manufacturing facility can trigger the display of relevant information on multiple devices such as workstations, tablets, or large control-room screens to supervisors and experts. Devices can be potentially in different locations and can comprise different visualization capabilities. The core of our framework uses semantic models and formal methods-based techniques to aggregate and process this information.

Software evolutionary stability has become an important issue in software maintenance and evolution. It is directly related to software reusability, maintainability and evolvability. In reported prior research, software evolutionary stability has been measured with architecture-level metrics, including reference points and program-level metrics, such as number of modules and number of lines of code. In this paper, information-level metrics based on Kolmogorov complexity are used to measure the differences between versions of software products. Using normalized compression distance, various evolutionary stability metrics of software artifacts are defined: version stability, branch stability, structure stability and aggregate stability. Case studies are performed on two open-source products, Apache HTTP server and Apache Ant build tool. The results from this study show that information-level evolutionary stability metrics can be used together with architecture-level metrics and program-level metrics to assist monitoring the software evolution process, as well as identifying stable or unstable software artifacts.

We present work towards using ontological information to facilitate collaborative tasks during operation, maintenance and service of industrial automation facilities. We use semantic models as an additional layer for a collaboration framework to enable automatic reasoning, decision support and knowledge sharing among multiple parties. Documents such as texts, workflows, images, social media profiles or models of production plants can be semantically annotated to facilitate their ontological classification. Our semantic models comprise behavior and space information, as well as links between documents and from documents to external data collections, such as logs, tables and sensor data. Our semantic models can be used to check consistency, confidentiality and security properties and to support collaborative tasks.

Internet, on one hand, is a primary foundation for knowledge acquisition in a child's life. On the other hand, there are many growing exploits over children. Motivated by the rising need to shield children's communication channels from obnoxious sources, this paper proposes a framework named SafeChat. SafeChat is the result of aggregating the context based authentication features of 4-CBAF model and the message encryption features from demonstrated SecureString 2.0. SafeChat intercepts children's communication and eradicates explicit words coming into the children's devices. SafeChat filters explicit words without recognizing their meaning. Such an approach hardens the system against malicious attacks. Furthermore, it secures the communication channels against possible man-in-the-middle attacks by employing an encryption mechanism. In addition, it encompasses the tools to authenticate and authorize communications and allows parents to monitor children communication channels in case an intervention is desirable. SafeChat supports to extend it to incorporate essential features including a facility to censor users through building a social network. Such a social network would allow other children to learn about the users with potential threats.

Our experiences with industrial software development projects have often revealed that requirements change even after their formal approvals. Although the requirements are never stable, proactive identification of potentially changeable or deferrable requirements, and estimation of their impacts early in a project can be useful in minimizing the risks and cost overruns. In practice, the decisions to change or defer certain requirements are based on experience, and are mostly driven by business needs and product release timelines. There are no techniques available which could foresee such changes early in the project. In this work, we perform exploratory analysis of the requirement artifacts from thirty three industrial software development projects and shared our observations on different requirement change attributes. Through empirical analysis, we evolve the relative weights of each of these attributes in terms of their impacts on the project schedule and effort. Based on the analysis, a model is developed to predict the impact due to requirement changes and it is validated. This model can be used to develop a requirement change decision support tool to assist decision makers.

IEC 61131-3 is an open standard that provides guidelines for programmable logic controllers and control systems. The standard defines specifications for control system programming languages, both textual and graphical. A control system application developed using these languages can go through several changes over the course of the project's life-cycle. While differences in textual programs can be detected using traditional text difference algorithms, there exist no effective means for tracking changes at a granular, semantic level for graphical control system programs. In this paper, we present an approach for comparison of graphical IEC 61131-3 programs, specifically those written using the Function Block Diagram and Sequential Function Chart notations. To perform this comparison, we represent the programs in an XML format, and use this to compare individual elements. The differences are computed and the programs are then rendered in a customized graphical viewer that highlights changes between programs. We implement a prototype comparison utility for graphical IEC 61131-3 programs and show how it can help reduce the effort involved in manual review and maintenance activities.

Every organization strives to provide online support for their customers in an attempt to rapidly provide solutions to customer bug reports. In the automation software industry, wherein software bugs can have significant repercussions for the client, rapid response to reported bugs is a very critical function. Current approaches to such response focuses on a 911 type of dispatch mechanism, wherein a dispatcher coordinates the assignment process with the help of Subject Matter Experts (SMEs). In this exploratory paper, we propose a mechanism to automate this process. As a case study, we present comparative work on bug data from Firefox and Eclipse bug reports. We have proposed and demonstrated a field-based weighting scheme. Comparing well with other such reported efforts, our approach has achieved 96.25% accuracy on Firefox (out of 1764 bug reports) and 97.83% accuracy on Eclipse bug data (out of 1986 bug reports).

Traditional requirements engineering involves analyzing tradeoffs between available alternatives. In the context of Software Product Lines (SPLs) application engineers have to instantiate variability by evaluating a set of options available from the platform. In this position paper, we propose the adoption of multi-criteria decision-making for instantiating a variability model in application requirements engineering amenable to the adoption of a Product Lines approach.

Information system security policies have grown in complexity and the emerging collaborative nature of business has created new challenges in creating and managing such policies. These policies address several domains ranging from access control to disaster recovery and depend not only on the business itself but on socio-political/legal requirements as well. Events like collaborative work or project-based organisational units result in the need to create a new information system security policy for the specific work/project, while maintaining status quo of existing policies. This requires identification and evaluation of existing policies to enable creating the new policy in line with the existing ones with acceptable deviations based on informed decisions. This paper provides a framework for capturing and converting security policies in terms of an XML format and further into alloy language format. Policies are converted to alloy format for performing further policy consistency analysis using Alloy Analyser.

An agent in a cooperative system is convinced that other agents will take actions toward the same goal of maximizing the global utility. In contrast, a self interested agent needs to consider every possible course of action other agents may take. Our aim in this paper is to define a simple, extendible, and formal framework for multi agent cooperation, over which businesses may build their business frameworks for effecting cooperative business strategies using distributed multi-agent systems. Our model is a hybrid hierarchical model that is capable to response for the two extremities of multi agent systems mentioned previously.

Cargo container shipping is a multi-billion dollar industry that involves hundreds of ships and millions of containers. These containers are typically sealed after they are loaded and remain sealed until they reach their final destination. An efficient and cost-effective method to ensure that container breaches are reported in a timely manner is needed. Using current off-the-shelf wireless technology and peer-to-peer networking techniques, an agent based framework is under development to monitor container status, port interactions and anomaly identification.

The globalization of the economy has given increase to the number of shipping containers. The large number of shipping containers arriving at major ports makes inspecting every container impractical and therefore bears significant risks. This paper describes a solution that would monitor containers' integrity from the originating port to the destination port. Should there be an intrusion to the containers en route, the system will report the activity to its home station. The proposed system is envisioned to be secure and intrusion resistant. The proposed approach uses an implementation of Jigsaw Distributed File System (JigDFS) to further protect the container communities. This paper is the full version of extended abstract published at CSIIRW-09 [1].

From system security point of view, system calls are vulnerable as they operate in kernel space. Hence monitoring of system call patterns performed by an application has been extensively studied for the development of Intrusion Detection Systems(IDS), which have to respond immediately to abnormal behaviors. However these IDSs have limitations in detecting new types of attacks. Policy driven IDSs have the ability to detect novel attacks based on policies written for system activities. In this paper we propose a hybrid architecture for IDSs, that combines the features of both policy driven IDS and system call based IDS and the idea is experimented for sandboxing Linux 2.6.

This paper addresses the growing need for inculcating appropriate ethics within the computing curriculum by fostering the development of a societally-conscious ethical framework among our students to address the use of information technology vis-a-vis government, business and society. We propose a new integrated model based approach (IDEA) and suggest its adoption to encourage students on reflecting upon the social and ethical ramifications of technology, beyond the narrow, project-focused tunnel vision that currently (subliminally) exists in many computing curricula, and in particular, in today's profit-focused, consulting and contract-based software industry.

Individual software elements in emerging large- scale distributed applications must exhibit simple, yet well- defined underlying patterns, which aid the development of scalable, complex software systems capable of demonstrating domain-specific intelligent coordination characteristics. Effective coordination among these distributed software elements is often contextual and often strictly related to the environment in which they reside; with the need to be acutely aware of, and execute in, dynamic group structures and environments. We discuss necessary extensions for enabling intelligent coordination in Service Oriented Architecture (SOA) and Grid computing frameworks - current widely adopted techniques. A software architectural framework for such a system, modeled and simulated using Petri nets has been prototyped.

This paper describes techniques developed for conflict detection during plan integration. Agents' intensions are represented with intended goal structure (IGS) and the E-PERT diagrams. Conflicts are classified as goal, plan, and belief conflicts. Before integrating individual plans and detecting plan conflicts, agents first detect and eliminate their goal conflicts by exchanging their IGS. Plan integration is done through merging individual E-PERT diagrams. Project estimation and review technique (PERT) diagrams have been used extensively in the systems analysis area since the 1980s to provide a global consistent view of parallel activities within a project. We extended the PERT diagrams for use in the plan integration activity within multi-agent systems (MAS). The E-PERT diagram contributes to maintain traceable temporal relations among agents' local scheduled actions. Combined with pattern matching, plan conflicts due to resource sharing, or conflicting conditions (i.e., postconditions of one action disabling preconditions of another action) can be detected. The conflict detection techniques are implemented in a sensible agent testbed to promote deployment and performance analysis.

In this paper, a Petri net based approach for establishing the minimal design and testing requirements for software systems is presented. It is based on a technique called the minimal transition cover set (MTCS), developed from minimal transition invariants of the corresponding Petri net model (Ramaswamy and Barber, 1997). The MTCS is based on identifying the important decisions being made within the design model. Depending on the design requirements, a designer may choose to expand lower level procedures during an analysis, and thereby, generate information about other lower-level decisions selectively within the design which are to be made available to other sub-systems. A further modification of the MTCS approach is used to derive the decision nodes that are buried within the design model. Again, a software test engineer may either choose to selectively build test cases for individual modules and incorporate them as stubs in a higher level module, or integrate these modules within higher level modules before deriving appropriate test case scenarios. Building test cases based on the deep decision nodes gives the necessary test cases for system verification. The equivalence and the easier applicability of MTCS based test case generation method with McCabe's cyclomatic complexity measure is also briefly addressed.

Finite state machines and their extensions are widely used for system modeling and analysis. Often, the models themselves do not provide much insight into critical system areas which need to be observed (or monitored) for effective control. The issue is mostly left to the discretion of the development team which often has limited domain knowledge. In this paper, an effective method to identify necessary critical system areas that need to be observed and those areas that lead example to the identification of varying levels of control in a design model are discussed. Also, the applicability of this method in differentiating and choosing between two similar system designs is discussed. Extended Statecharts (ESCs) that exploit the XOR configuration of Statecharts for system failure modeling are used for developing the high level system model. The ESC model is subsequently transformed into a high level Petri net model and Petri net analysis techniques are used for the identification of critical system areas for observation and control as well as to differentiate between nearly identical ESC system models.

The call admission control schemes for ATM-type networks are based on the concept of effective bandwidth (EB). Most schemes focus on the cell loss rate as the exclusive QoS metric and therefore base their EB on cell-loss rate approximations. We use simulation data to develop regression models for cell loss and cell delay; these estimates can be used to compute effective bandwidths to satisfy both cell loss and delay. We compare the accuracy of the regression models with that of the well-know fluid-flow model by Anick et al. (1982). Our results indicate that the regression models are computationally simple and sufficiently accurate for practical use.

In this paper, hierarchical time-extended Petri nets (H-EPNs), an extended Petri net based modeling and analysis tool, are used to derive the coordination level model of hierarchically decomposable systems, viewed from a three-level hierarchical structure of organization, coordination and execution of tasks. A two-layer (vertical) coordination level framework, consisting of the dispatcher/analyzer and the H-EPN controller is presented. A detailed two sub-level (horizontal) H-EPN controller model is derived to model system operations (including system soft failures). Error classification based on the interaction between the various system coordinators is derived from the H-EPN model. The H-EPN approach preserves multi-resolutional system details as well as effective communication flows between the various subsystems. A simple example illustrates the proposed approach. The important H-EPN properties of boundedness, safeness and reversibility are verified.

This paper discusses an architecture designed to provide support for the development of state transition models for an object-oriented distributed environment. The state transition models can be constructed and specified hierarchically as well as derived into new classes of objects through the use of inheritance. A new concept called "exit-safe states" is introduced to assist in the specification of hierarchical state transition models. A graphical monitor to analyze the system at run time has been developed.