The authors introduce a high-level Petri net formalism-environment/relationship (ER) nets-which can be used to specify control, function, and timing issues. In particular, they discuss how time can be modeled via ER nets by providing a suitable axiomatization. They use ER nets to define a time notation that is shown to generalize most time Petri-net-based formalisms which appeared in the literature. They discuss how ER nets can be used in a specification support environment for a time-critical system and, in particular, the kind of analysis supported

No abstract

Abstract. Operator precedence languages were introduced half a century ago by Robert Floyd to support deterministic and efficient parsing of context-free languages. Recently, we renewed our interest in this class of languages thanks to a few distinguishing properties that make them attractive for exploiting various modern technologies. Precisely, their local parsability enables parallel and incremental parsing, whereas their closure properties make them amenable for automatic verification techniques, including model checking. In this paper we provide a fairly complete theory of this class of languages: we introduce a class of automata with the same recognizing power as the generative power of their grammars; we provide a characterization of their sentences in terms of monadic second order logic as it has been done in previous literature for more restricted language classes such as regular, parenthesis, and input-driven ones; we investigate preserved and lost properties when extending the language sentences from finite length to infinite length (ω-languages). As a result, we obtain a class of languages that enjoys many nice properties of regular languages (closure and decidability properties, logic characterization) but is considerably larger than other families -typically parenthesis and input-driven ones-with the same properties, covering "almost" all deterministic languages. 1 Key words. Operator Precedence, Visibly Pushdown Languages, Monadic Second Order Logic, Omegalanguages.AMS subject classifications. 03D05, 68Q45.Introduction. Operator precedence grammars and languages (OPGs and OPLs) certainly deserve an important place in the history of formal languages and compilers. They were invented by Robert Floyd [23] with the major motivation of enabling efficient, deterministic parsing of programming languages. In fact Floyd's intuition was inspired by arithmetic expressions whose structure is determined either by explicit parentheses or by the conventional, "hidden" precedence of multiplicative operators over additive ones. By generalizing this observation Floyd defined three basic relations between terminal symbols, namely yields and takes precedence and equal in precedence (respectively denoted by symbols ⋖, ⋗,=), in such a way that the right hand side (r.h.s.) of an operator precedence grammar rule is enclosed within a pair ⋖, ⋗, and= holds between consecutive terminal symbols thereof (in OPGs nonterminal symbols are "transparent", i.e., irrelevant, w.r.t. the precedence relations [23]).Subsequently, under the main motivation of grammar inference, it was shown that, once an operator precedence matrix (OPM) is given such that at most one relation holds between any two terminal characters, the family of OPLs sharing the given OPM is a Boolean algebra [19]. This result somewhat generalizes closure properties enjoyed by regular languages and by context-free languages whose structure, i.e., the syntax tree, is immediately visible in the terminal sentences, such as parenthesis languages [31] and tree-automata lan...

We address the problem of increasing the impact of formal methods in the practice of industrial computer applications. We summarize the reasons why formal methods so far did not gain widespread use within the industrial environment despite several promising experiences. We suggest an evolutionary rather than revolutionary attitude in the introduction of formal methods in the practice of industrial applications and we report on our long-standing experience which involves an academic institution, Politecnico di Milano, two main industrial partners, ENEL and CISE, and occasionally a few other industries. Our approach aims at augmenting an existing and fairly deeply rooted informal industrial methodology with our original formalism, the logic specification language TRIO. On the basis of the experiences we gained we argue that our incremental attitude towards the introduction of formal methods within the industry could be effective largely independently from the chosen formalism.

We address the problem of automated derivation of functional test cases for real-time systems, by introducing techniques for generating test cases from formal specifications written in TRIO, a language that extends classical temporal logic to deal explicitly with time measures. We describe an interactive tool that has been built to implement these techniques, based on interpretation algorithms of the TRIO language. Several heuristic criteria are suggested to reduce drastically the size of the test cases that are generated. Experience in the use of the tool on real-life cases is reported.

Floyd's operator precedence grammars and languages (FG, FL) are a classical subclass of deterministic context-free (DCF) grammars and languages. We prove that several recently introduced language families motivated by the needs of model checking and of specifying XML-like languages are proper subsets of FL. The main cases considered include visibly pushdown languages (VPL) and balanced languages (BALAN), which are characterized by restricted precedence relations. FL have all the closure properties available for regular languages and generally viewed as necessary for application to model checking: reversal, prefixing and suffixing, concatenation, Kleene star, and boolean operations. All but the last results are new, and some require complex proofs, due to the necessary changes of syntax structure. Thus FL are the largest known subfamily of DCF having the same closure properties as VPL. FG, unlike VPL grammars, which are intended for abstract syntax modelling, are structurally adequate to specify real programming languages.

The problem of formally analyzing properties of real-time systems is addressed. A method is proposed that allows specifying system properties in the TRIO language (an extension of temporal logic suitable to deal explicitly with the "time" variable and to measure it) and modeling the system as a timed Petri net. It is argued that such an approach is more general than analyzing program properties. The proof method is based on an axiomatization of timed Petri nets in terms of TRIO so that their properties can be derived as suitable theorems in much the same spirit as classical Hoare's method allows proving properties of programs coded in a Pascal-like language. The method is then exemplified through two classical "benchmarks" of the literature on concurrent and real-time systems, namely an elevator system and the dining philosophers problem. A thorough review of the related literature and a comparison thereof with the new method is also provided. Possible alternative methods, theoretical extensions, and practical applications are briefly discussed. . IntroductionIn the field of sequential programming there are now several well understood methods suitable to prove program properties that are expressed through some-possibly formal-specification language. A classical example is Hoare's method, which aims at proving properties of Pascal-like programs stated in terms of a first-order theory. Although the practical application of such methods to real-life cases is still under debate, these are now well-established and are receiving increasing consensus even in the industrial world, at least for the analysis of the most critical parts of the most critical systems [56,38].The state of the art is less well-established in the case of the analysis of concurrent systems. In fact such systems are intrinsically more difficult to analyze, what turns out into more complex formalization of their semantics and less satisfactory and less adopted specification languages. The situation is even worse for real-time systems. By "real-time systems" here we mean those systems whose behavior does depend on execution speed, not systems with generic requirements for high performance [95, 1]. In such systems one more difficulty arises from the necessity of modeling explicitly the dependence of system behavior on the time variable, whereas this dependency is usually abstracted away in the modeling of computing systems. On the other hand, real-time systems-which include plant control systems, embedded applications, air traffic control systems, etc.-have quite often

We discuss the technical skills that a software engineer should possess. We take the viewpoint of a school of engineering and put the software engineer's education in the wider context of engineering education. We stress both the common aspects that crosscut all engineering fields and the specific issues that pertain to software engineering. We believe that even in a continuously evolving field like software, education should provide strong and stable foundations based on mathematics and science, emphasize the engineering principles, and recognize the stable and longlasting design concepts. Even though the more mundane technological solutions cannot be ignored, the students should be equipped with skills that allow them to understand and dominate the evolution of technology.