A Formal Architecture-Centric Model-Driven Approach for the Automatic Generation of Grid Applications

This paper discusses the concept of model-driven software engineering applied to the Grid application domain. As an extension to this concept, the approach described here, attempts to combine both formal architecture-centric and model-driven paradigms. It is a commonly recognized statement that Grid systems have seldom been designed using formal techniques although from past experience such techniques have shown advantages. This paper advocates a formal engineering approach to Grid system developments in an effort to contribute to the rigorous development of Grids software architectures. This approach addresses quality of service and cross-platform developments by applying the model-driven paradigm to a formal architecture-centric engineering method. This combination benefits from a formal semantic description power in addition to model-based transformations. The result of such a novel combined concept promotes the re-use of design models and facilitates developments in Grid computing.Comment: 11 pages, 9 figures. Proc of the 8th International Conference on Enterprise Information Systems (ICEIS06) Paphos, Cyprus. May 200

An overview of very high level software design methods

Very High Level design methods emphasize automatic transfer of requirements to formal design specifications, and/or may concentrate on automatic transformation of formal design specifications that include some semantic information of the system into machine executable form. Very high level design methods range from general domain independent methods to approaches implementable for specific applications or domains. Applying AI techniques, abstract programming methods, domain heuristics, software engineering tools, library-based programming and other methods different approaches for higher level software design are being developed. Though one finds that a given approach does not always fall exactly in any specific class, this paper provides a classification for very high level design methods including examples for each class. These methods are analyzed and compared based on their basic approaches, strengths and feasibility for future expansion toward automatic development of software systems

Modernizing science&engineering software systems

As the demands for modernized legacy systems rise, so does the need for frameworks for information integration and tool interoperability. The Object Management Group (OMG) has adopted the Model Driven Architecture (MDA), which is an evolving conceptual architecture that aligns with this demand. MDA could help solve coupling problems of multidisciplinary character in science and engineering that consist of one or more applications, supported by one or more platforms. The objective of this paper is to describe rigorous techniques to control the evolution from science & engineering software legacy systems to MDA technologies. We propose a rigorous framework to reverse engineering code in the context of MDA. Considering that validation, verification and consistency are crucial activities in the modernization of systems that are critical to safety, security and economic profits, our approach emphasizes the integration of MDA with formal methods

Encoding process discovery problems in SMT

Information systems, which are responsible for driving many processes in our lives (health care, the web, municipalities, commerce and business, among others), store information in the form of logs which is often left unused. Process mining, a discipline in between data mining and software engineering, proposes tailored algorithms to exploit the information stored in a log, in order to reason about the processes underlying an information system. A key challenge in process mining is discovery: Given a log, derive a formal process model that can be used afterward for a formal analysis. In this paper, we provide a general approach based on satisfiability modulo theories (SMT) as a solution for this challenging problem. By encoding the problem into the logical/arithmetic domains and using modern SMT engines, it is shown how two separate families of process models can be discovered. The theory of this paper is accompanied with a tool, and experimental results witness the significance of this novel view of the process discovery problem.Peer ReviewedPostprint (author's final draft

Formal methods for legacy systems.

Paper dated January 6, 1995A method is described for obtaining useful information from legacy code. The approach uses formal proven program transformations, which preserve for refine the semantics of a construct while changing its form. The applicability of a transformation in a particular syntactic context is checked before application. By using an appropriate sequence of transformations, the extracted representation is guaranteed to be equivalent to the code. In this paper, we focus on the results of using this approach in the reverse engineering of medium scale, industrial software, written mostly in languages such as assembler and JOVIAL. Results from both benchmark algorithms and heavily modified, geriatric software are summarised. It is concluded that the approach is viable, for self-contained code, and that useful design information may be extracted from legacy systems at economic cost. We conclude that formal methods have an important practical role in the reverse engineering process.Partly funded bu Alvey project SE-088, partly through a DTI/SERC and IBM UK Ltd. funded IEATP grant "From assembler to Z using formal transformations" and partly by SERC (Science and Engineering Research Council) project "A proof theory for program refinement and equivalence: extensions"

From distributed coordination to field calculus and aggregate computing

open6siThis work has been partially supported by: EU Horizon 2020 project HyVar (www.hyvar-project .eu), GA No. 644298; ICT COST Action IC1402 ARVI (www.cost -arvi .eu); Ateneo/CSP D16D15000360005 project RunVar (runvar-project.di.unito.it).Aggregate computing is an emerging approach to the engineering of complex coordination for distributed systems, based on viewing system interactions in terms of information propagating through collectives of devices, rather than in terms of individual devices and their interaction with their peers and environment. The foundation of this approach is the distillation of a number of prior approaches, both formal and pragmatic, proposed under the umbrella of field-based coordination, and culminating into the field calculus, a universal functional programming model for the specification and composition of collective behaviours with equivalent local and aggregate semantics. This foundation has been elaborated into a layered approach to engineering coordination of complex distributed systems, building up to pragmatic applications through intermediate layers encompassing reusable libraries of program components. Furthermore, some of these components are formally shown to satisfy formal properties like self-stabilisation, which transfer to whole application services by functional composition. In this survey, we trace the development and antecedents of field calculus, review the field calculus itself and the current state of aggregate computing theory and practice, and discuss a roadmap of current research directions with implications for the development of a broad range of distributed systems.embargoed_20210910Viroli, Mirko; Beal, Jacob; Damiani, Ferruccio; Audrito, Giorgio; Casadei, Roberto; Pianini, DaniloViroli, Mirko; Beal, Jacob; Damiani, Ferruccio; Audrito, Giorgio; Casadei, Roberto; Pianini, Danil

Colonising the Field ) Who,s Playing with Web-based Information Systems Development?

domain of systems and software development, in both practice and research. Surprisingly, while there would appear to be many common activities, the academic fields have traditionally had limited overlap or shared experience. The information systems school has largely focused on in-house systems, concentrating on the socio-technical approach toward systems development while software engineering attempts to apply engineering principles and formal methods to the production of software systems. However the fields collide where new, Web-based systems share both in-house usage and external commercial software characteristics. While it might be expected that practitioners would be informed by innovative development methods, research indicates that practitioners are not making use of new multimedia and web development method and techniques. The crossover between the fields of IS and SE resurrects up some old problems and new questions. This paper traces the roots of IS and SE; briefly contrasts education and research of each; and examines the differences and common areas of the fields. From a study of how each field is characterised an IS body of knowledge (ISBOK) is identified. How Web-based Information Systems relate to each field is discussed and from the analysis a simple classification framework is constructed, weighing a systems life cycle against quality. The paper concludes with a call for greater cross-fertilization between the fields. Finally the authors suggest important subjects that IS researchers should be studying and others that should be of interest to both SE and IS researchers

CAMILA: formal software engineering supported by functional programming

This paper describes two experiences in teaching a formal approach to software engineering at undergraduate level supported by Camila a functional programming based tool Carried on in diferent institutions each of them addresses a particular topic in the area requirement analysis and generic systems design in the first case specification and implementation development in the second Camila the common framework to both experiences animates a set based language extended with a mild use of category theory which can be reasoned upon for program calculation and classification purpose. The project afiliates itself to but is not restricted to the research in exploring Functional Programming as a rapid prototyping environment for formal software model. Its kernel is fully connectable to external applications and equipped with a component repository and distribution facilities. The paper explains how Camila is being used in the educational practice as a tool to think with providing a kind of cross fertilization between students under standing of diferent parts of the curriculum. Furthermore it helps in developinga number of engineering skills namely the ability to analyze and classify information problems and models and to resort to the combined use of diferent programming frameworks in approaching them

Ontology-based model-driven patterns for notification-oriented data-intensive enterprise information systems

International audienceIn the fourth industrial revolution, the current Enterprise Information Systems (EIS) are facing a set of new challenges raised by the applications of Cyber-Physical Systems (CPS) and Internet of Things (IoT). In this scenario, a data-intensive EIS involves networks of physical objects with sensing, data collection, transmission and actuation capabilities, and vast endpoints in the cloud, thereby offering large amounts of data. Such systems can be considered as a multidisciplinary complex system with strong interrelations between the involved components. In order to cope with the big heterogeneousness of those physical objects and their intrinsic information, the authors propose a notification-based approach derived from the so-called Notification Oriented Paradigm (NOP), a new rule and event driven approach for software and hardware specification and execution. However, the heterogeneity of those information and their interpretation relatively to an evolving context impose the definition of model-driven patterns based on some formal knowledge modelled by a set of skill-based ontologies. Thus, the paper focuses on the open issue related to the formalisation of such ontology-based patterns for their verification, ensuring the coherence of the whole set of data in each contextual engineering domain involved in the EIS