Academia.eduAcademia.edu

Outline

Title
Abstract
Introduction 1 .L Motivation
An Overview of the Larch Shared Language
An Overview of Clu
Larch/Clu Procedure Specifications
Implications of the Two-Tiered Approach
References
All Topics
Computer Science
Software Engineering

Writing Larch interface language specifications

Profile image of Jeannette WingJeannette Wing

1987, ACM Transactions on Programming Languages and Systems

https://doi.org/10.1145/9758.10500
visibility

…

description

24 pages

link

1 file

Abstract

Current research in specifications is emphasizing the practical use of formal specifications in program design. One way to encourage their use in practice is to provide specification languages that are accessible to both designers and programmers. With this goal in mind, the Larch family of formal specification languages has evolved to support a two-tiered approach to writing specifications. This approach separates the specification of state transformations and programming language dependencies from the specification of underlying abstractions. Thus, each member of the Larch family has a subset derived from a programming language and another subset independent of any programming languages. We call the former interface languages, and the latter the Larch Shared Language. This paper focuses on Larch interface language specifications. Through examples, we illustrate some salient features of Larch/CLU, a Larch interface language for the programming language CLU. We give an example of writing an interface specification following the two-tiered approach and discuss in detail issues involved in writing interface specifications and their interaction with their Shared Language components.

Related papers

Crossing the Borderline — From Formal to Semi-Formal Specifications
Andreas Bollin

IFIP International Federation for Information Processing, 2006

Being part of the systems' documentation state-based formal specifications can play a crucial role in the software development process. Hovv' ever, besides dense mathematical expressions, their semantical compactness and lack in visually appealing notations impede their use and comprehensibility among different stakeholders. One solution to this problem is to enrich the specification by a semi-formal view, in most cases diagrams with a sufficiently understood semantic meaning. However, as control-and data-dependencies within declarative specifications are hard to detect, existing approaches only cover statics-bearing diagrams. As a way out this paper presents an approach for control-and data dependency analysis within declai-ative formal specifications. Based on these dependencies, UML diagrams showing static and dynamic properties of the specification arc generated.

View PDFchevron_right
A Formal Semantics for CORBA Interface Definition Language
Marjan Sajjadi

Common Object Request Broker Architecture (CORBA) is a standard for hybrid applications that is designed and supported by Object Management Group (OMG). This standard defines protocols and Relational Data Model Objects / Services which can be connected into heterogeneous software (written in different languages). So we can use CORBA to share the distributed object platform, without worrying about where they are located or who has designed them. CORBA can package the codes (in some programming languages) and add the packaging information, such as the ability to execute the codes and how to implement them. So this package or object code can execute some other programs or CORBA objects that they are in the network. CORBA uses a relational language called Interface Definition Language (IDL) to specify the interface of the classes and objects. The IDL definitions can be connected to the written codes in some popular languages such as Java, C++, Ada, and Smalltalk. To know the functionality and behaviors of objects and their interfaces, we need to abstractly model their definitions and specifications. Models are in different types (e.g., physical, mathematical, numerical, software, etc.) and have a variety of critical applications in all areas of science and technology. In other words, a summary of the facts is known as the models. Therefore, it could be mentioned that there are two objectives for the model including exploration and specification, the modeling process considers either or both of them. One of the main approaches to the modeling process is based on state-transition systems such as Kripke structures, Petri nets, and Büchi automata. The paper's ultimate goal is to provide a method to model the formal behavioral specifications of CORBA objects. In this paper, we use the formalism of Büchi automata as the operational semantics for the behavior of CORBA based objects. For this purpose, two different approaches that include using Petri nets as basic operational models and translating them to Büchi automata and direct using of Büchi automata are considered. Also, we show the applicability of our suggested modeling approaches by considering them in some case studies. As result, a Büchi automaton is a better model to verify a system.

View PDFchevron_right
PROSPER: A language for specification by prototyping
Jacek Leszczylowski

Computer Languages, 1989

The PROSPER functional specification language supports a "specification by prototyping'" paradigm and relies on a unique and powerful type specification facility. Executable polymorphic specifications can be built from a small set of primitives. Types and functions are treated as values and can be the arguments and results of functions. Flexible parameterized type expressions are used to specify polymorphic functions and abstract data types. Abstract model specifications can be defined so that the invariants of a data structure can be part of the type, and only objects that meet the invariant are correctly typed.

View PDFchevron_right
Formal specification in metamorphic programming
Olga Baysal

1991

Formal specification methods have not been embraced wholeheartedly by the software development industry. We believe that a large part of industry's reluctance is due to semantic gaps that are encountered when attempting to integrate formal specification with other stages of the software development process.

View PDFchevron_right
The DisCo2000 Specification Language Annotated version
Hannu-Matti Järvinen

2003

View PDFchevron_right
LEX: a case study in development and validation of formal specifications
Heinrich Hussmann

2005

Abstract The paper describes an experiment in the combined use of various tools for the development and validation of formal speci cations. The rst tool consists of a very abstract,(non {executable) axiomatic speci cation language. The second tool consists of an (executable) constructive speci cation language together with a speci cation environment. Finally, the third tool is a veri cation system. The rst two tools were used to develop two speci cations for the same case study, viz.

View PDFchevron_right
Interface Specification Methods for Software Com Ponents
Keijo Heljanko

This report presents an interface specification language developed as a part of the LIME-project (LightweIght formal Methods for distributed component-based Embedded systems) and a tool implementation to support it. The intention is to provide a methodology that is lightweight and complementary to the existing means of quality assurance in a software process.

View PDFchevron_right
Integrating Specification and Documentation in an Object-Oriented Language
Emil Sekerinski

SAVCBS 2004, Specification and Verification of Component-Based Systems, 2004

View PDFchevron_right
A Specification Model for Interface Suites
Ruurd Kuiper

Lecture Notes in Computer Science, 2001

The paper describes a model and tool support for a UMLbased specification approach, extending UML with templates for structured specifications deriving from the ISpec approach. The approach is component-oriented where the unit of description is an interface suite: a coherent collection of interfaces defining interactions that transcend component boundaries. To handle complexity, descriptions from various points of view are necessary, expressed by UML diagrams, templates, etc. The issue is to ensure that the views are consistent. For this, we provide a model to integrate the views. The model is sequence-based; the elements of the sequences are carefully designed tuples that reflect the interface suite approach. Abstractions from the model reflect the views. The model provides the underlying structure for tooling. We developed extensions to Rational Rose by customizing specifications, automating diagram generation and enabling some consistency checks.

View PDFchevron_right
Formal Semantics of Programming Languages - An Overview
Peter Mosses

Electronic Notes in Theoretical Computer Science, 2006

These notes give an overview of the main frameworks that have been developed for specifying the formal semantics of programming languages. Some of the pragmatic aspects of semantic descriptions are discussed, including modularity, and potential applicability to visual and modelling languages. References to the literature provide starting points for further study.

View PDFchevron_right

References (57)

  1. ABRIAL, J. R. The specification language Z: Syntax and semantics. Programming Research Group, Oxford University, 1980.
  2. GOGUEN, J. A., THATCHER, J. W., WAGNER, E. G., AND WRIGHT, J. B. Abstract data types as initial algebras and correctness of data representations. In Proceedings of the Conference on Computer Graphics, Pattern Recognition and Data Structures (May 1975), ACM, New York, 89-93.
  3. ATREYA, S. K. Formal specification of a specification library. M.S. thesis, MIT, Dept. of Electrical Engineering and Computer Science, Cambridge, Mass., May 1982.
  4. BERZINS, V. Abstract model specifications for data abstractions. MIT Laboratory for Computer Science, Cambridge, Mass., July 1979.
  5. BIRKHOFF, G., AND LIPSON, J. D. Heterogeneous algebras. J. Comb. Theor. 8 (1970), 115-133.
  6. BJORNER, D., AND JONES, C. G. (Eds.). The Vienna Development Method: The Meta-langunge. Lecture Notes in Computer Science, 61. Springer, New York, 1978.
  7. BURSTALL, R. M., AND GOGUEN, J. A. Putting theories together to make specifications. In Proceedings of the 5th. International Joint Conference on Artificial Intelligence (Aug. 1977), 1045-1058. Invited paper.
  8. BURSTALL, R. M., AND GOGUEN, J. A. An informal introduction to specifications using CLEAR. In The Correctness Problem in Computer Science, 1981.
  9. CAINE, S. H., AND GORDON, E. K. PDL-A tool for software design. In Proceedings of the I975 National Computer Conference (Anaheim, Calif., May 19-22). AFIPS Press, Reston, Va., 1975, 271-276.
  10. EHRICH, H.-D. Extensions and implementations of abstract data type specifications. In Math- ematical Foundations of Computer Science 1978, Proceedings. Lecture Notes in Computer Science, 64. Springer, New York, 1978, 155-164.
  11. EHRIG, H., KREOWSKI, H.-J., THATCHER, J., WAGNER, E., AND WRIGHT, J. Parameterized data types in algebraic specification languages. In Automata, Languages, and Programming. Lectures Notes in Computer Science, 85. Springer, New York, 1980, 157-168.
  12. EHRIG, H., AND MAHR, B. Fundumentals of Algebraic Specification 1. Springer, New York, 1985.
  13. FORGAARD, R. A program for generating and analyzing term rewriting systems. M.S. thesis, TR-343, MIT Laboratory for Computer Science, Cambridge, Mass., 1985.
  14. GOGUEN, J. A. Abstract errors for abstract data types. In Proceedings of the IFIP Working Conference on Formal Basis of Programming Concepts (Aug. 1977). IFIP, 21.1-21.32. ACM Transactions on Programming Languages and Systems, Vol. 9, No. 1, January 1987. Writing Larch Interface Language Specifications l 23
  15. GOGUEN, J. A., AND PARSAYE-GHOMI, K. Algebraic denotational semantics using parameterized abstract modules. CSL-119, Stanford Research Institute, Menlo Park, Calif., Feb. 1981.
  16. GOOD, D. I., COHEN, R. M., HOCH, C. G., HUNTER, L. W., AND HARE, D. F. Report on the language Gypsy, version 2.0. ICSCA-CMP-10, Certifiable Minicomputer Project, Univ. of Texas, Austin, Sept. 1978.
  17. GUTTAG, J. V. The specification and application to programming of abstract data types. Ph.D. dissertation, Univ. of Toronto, Toronto, Sept. 1975.
  18. GUTTAG, J. V. Abstract data types and the development of data structures. Commun. ACM 20, 6 (June 1977), 396-404.
  19. GU?TAG, J. V., AND HORNING, J. J. Formal specification as a design tool. In Proceedings of the 7th ACM Symposium on Principles of Programming Languages (Las Vegas, Nev., Jan. 1980), ACM, New York, 251-261.
  20. GUWAG, J. V., HORNING, J. J., AND WING, J. M. Some notes on putting formal specifications to productive use. Sci. Comput. Program. 2, 1 (Oct. 1982), 53-68.
  21. GUTTAG, J. V., AND HORNING, J. J. An introduction to the Larch Shared Language. In Proceedings of the IFIP 9th World Computer Congress (Paris, Sept. 1983), IFIP, 1983.
  22. GUTTAG, J. V., HORNING, J. J., AND WING, J. M. The Larch family of specification languages. IEEE Softw. 2, 5 (Sept. 1985), 24-36.
  23. GUTTAG, J. V., HORNING, J. J., AND WING, J. M. Larch in five easy pieces. 5, DEC Systems Research Center, July 1985.
  24. GUTTAG, J. V., AND HORNING, J. J. Report on the Larch Shared Language. Sci. Comput. Program. 6 (1986), 103-134.
  25. GUTTAG, J. V., AND HORNING, J. J. A Larch Shared Language handbook. Sci. Comput. Program. 6 (1986), 135-157.
  26. HOARE, C. A. R. An axiomatic basis for computer programming. Commun. ACM 12, 10 (Oct. 1969), 576-583.
  27. HOARE, C. A. R. Proof of correctness of data representations. Acta Inf. 1, 1 (1972), 271-281.
  28. HORNING, J. J. Combining algebraic and predicative specifications in Larch. In Proceedings of the International Joint Conference on Theory and Practice of Software Development, TAPSOFT, 1985. Lecture Notes in Computer Science, 186. Springer, New York, 1985,12-26.
  29. HORNING, J. J. Cedar Mesa interface language. Private communication, 1983.
  30. JACKSON, M. A. Principles of Program Design. Academic Press, London, 1975.
  31. JONES, C. B. Software Deuelapment: A Rigorous Approach. Prentice-Hall International, Englewood Cliffs, N.J., 1980.
  32. KAMIN, S. Final data types and their specification. ACM Trans. Program. Lung. Syst. 5, 1 (Jan. 1983), 97-121.
  33. KAPUR, D. Towards a theory for abstract data types. TR-237, MIT Laboratory for Computer Science, Cambridge, Mass., May 1980.
  34. KATZAN, H., JR. Systems Design and Documentation: An Introduction to the HIP0 Method. Van Nostrand Reinhold, New York, 1976.
  35. KOWNACKI, R. W. Semantic checking of formal specifications. M.S. thesis, MIT, Dept. of Electrical Engineering and Computer Science, Cambridge, Mass., Aug. 1984.
  36. LESCANNE, P. Computer experiments with the REVE term rewriting system generator. In Proceedings of the 10th ACM Symposium on Principles of Programming Languages (Austin, Tex., Jan. 1983). ACM, New York, 1983,99-108.
  37. LISKOV, B. H., AND ZILLES, S. N. Specification techniques for data abstractions. IEEE Trans. Softw. Eng. SE-Z, 1 (1975), 7-19.
  38. LISKOV, B., SNYDER, A., ATKINSON, R., AND SCHAFFERT, C. Abstraction mechanisms in CLU. Commun. ACM 20,8 (Aug. 1977), 564-576.
  39. LISKOV, B. H., AND BERZINS, V. An appraisal of program specifications. Research Directions in Software Technology, Cambridge, Mass., 1979.
  40. LISKOV, B. H., ET AL. CLU Reference Manual: Lecture Notes in Computer Science, 114. Springer, New York, 1981.
  41. MUSSER, D. R. Abstract data type specification in the Affirm system. IEEE Trans. Softw. Eng. 6, 1 (Jan. 1980), 24-32.
  42. NAKAJIMA, R., HONDA, M., AND NAKAHARA, H. Hierarchical program specification and verifi- cation-A many-sorted logical approach. Acta Inf. 14 (1980), 135-155.
  43. l Jeannette M. Wing
  44. NAKAJIMA, R., AND YUASA, T. The Iota Programming System. Springer, New York, 1983.
  45. PARNAS, D. L. A technique for software module specification with examples. Commun. ACM 25,5 (May 1972), 330-336.
  46. ROBINSON, L., AND ROUBINE, 0. SPECIAL-A specification and assertion language. CSL-46, Stanford Research Institute, Menlo Park, Calif., Jan. 1977.
  47. SCHEID, J., AND ANDERSON, S. The Ina Jo specification language reference manual. TM-(L)-6021/001/00, System Development Corp., Santa Monica, Calif., Mar. 1985.
  48. STANDISH, T. A. Data structures: An axiomatic approach. Rep. 2639, Bolt, Beranek, and Newman, Cambridge, Mass., Aug. 1973.
  49. SUFRIN, B., MORGAN, C., SORENSEN, I., AND HAYES, I. Notes for a Z handbook: Part l-The mathematical language. Programming Research Group, Oxford Univ., Computing Laboratory, Aug. 1984.
  50. THATCHER, J. W., WAGNER, E. G., AND WRIGHT, J. B. Data type specification: Parameteriza- tion and the power of specification techniques. In Proceedings of the 1OthAnnunlACM Symposium on Theory of Computing (May), ACM, New York, 1978,119-132.
  51. WAND, M. Final algebra semantics and data type extensions. J. Comput. Syst. Sci. 19, 1 (Aug. 1979), 27-44.
  52. WING, J. M. A two-tiered approach to specifying programs. MIT-LCS-TR-299, MIT Laboratory for Computer Science, Cambridge, Mass., June 1983.
  53. WING, J. M. Helping specifien evaluate their specifications. In Pmceedings of the 2nd Software Engineering Conference (June 1984). AFCET, 179-191.
  54. YOURDON, E., AND CONSTANTINE, L. L. Structured Design: Fundamentals of a Discipline of Computer Programs and Systems Design, 2nd ed. Yourdon Press, New York, 1978.
  55. ZACHARY, J. A syntax-directed tool for constructing specifications. M.S. thesis, MIT, Dept. of Electrical Engineering and Computer Science, Cambridge, Mass., Mar. 1983.
  56. ZAVE, P. An operational approach to requirements specification for embedded systems. IEEE Trans. Softw. Eng. 8,3 (May 1982), 250-269.
  57. ZILLES, S. N. Abstract specifications for data types. IBM Research Laboratory, San Jose, Calif., 1975.

Related papers

The Larch/Smalltalk interface specification language
Gary Leavens

ACM Transactions on Software Engineering and Methodology, 1994

Object-oriented programming languages, such as Smalltalk, help one to build reusable program modules. The reuse of program modules requires adequate documentation | formal or informal. Larch/Smalltalk is a formal speci cation language for specifying such reusable Smalltalk modules. Larch/Smalltalk rmly separates speci cation from implementation. In Larch/Smalltalk the unit of speci cation is an abstract data type, which is an abstraction of the behavior produced by one or more Smalltalk classes. A type can be a subtype of other types, which allows types to be organized based on speci ed behavior, and also allows for inheritance of their speci cations. Larch/Smalltalk specications are developed using speci cation tools integrated in the Smalltalk programming environment.

View PDFchevron_right
An Overview of Larch/C++: Behavioral Specifications for C++ Modules
Gary Leavens

The Springer International Series in Engineering and Computer Science, 1996

An overview is presented of the behavioral interface speci cation language Larch C++. The features of Larch C++ used to specify the behavior of C++ functions and classes, including subclasses, are described, with examples. Comparisons are made with other object-oriented specication languages. An innovation in Larch C++ is the use of examples in function speci cations.

View PDFchevron_right
SLAN-4: A Language for the Specification and Design of Large Software Systems
Otthein Herzog

IBM journal of research and development, 1983

The language SLAN-4 has been defined in view of the need for formal tools supporting the specification and design of large software systems. It offers its users language constructs for algebraic and axiomatic specifications as well as for design in pseudocode. One of its major design goals has been to ease subsequent refinements of a (given) specification. The user can start his development with an informal high-level specification which can be formalized and implemented at a later date by using lower-level concepts. This paper provides the formal definitions of the SLAN-4 language, discusses the design decisions, and presents examples for the use of the syntactic constructs.

View PDFchevron_right
Debugging Larch shared language specifications
Stephen Garland

IEEE Transactions on Software Engineering, 1990

DEC's business and technology objectives require a strong research program. The Systems Research Center (SRC) and three other research laboratories are committed to filling that need.

View PDFchevron_right
SLAN-4-A software specification and design language
Otthein Herzog

IEEE Transactions on Software Engineering, 2000

SLAN-4 ("Software Language-4") was developed to meet mentation errors. There would thus appear to be a strong case the need for a formal tool for specifying and designing large software for emphasizing abstraction and the use of formal methods in systems. It provides language constructs for algebraic and axiomatic the specification and design process specifications and also pseudocode constructs for the design step. A Besides introducing abstract data types and the possibility to major design goal was to ease subsequent refinements of a (given) specification. The design can start with a very informal specification, parameterize the type, the following nonoperational ways of which can be implemented later using lower level concepts. specifying the designer's intent were developed: This paper gives an overview of the SLAN-4 syntax and semantics. * algebraic specifications of abstract data types [8]-[10], It concentrates on the most important aspects of: [20] and * abstract data types,. . ' *~~~~~~~~~denotational approaches [5], [13]. * algebraic specification of abstract data types, and * axiomatic specification of modules. These approaches have been proven in practice to offer: Because the pseudocode part of SLAN-4 consists mainly of control * precision without loss of generality and structures similar to those in modern high-level programming languages, * conciseness without loss of understandability. this element of the language is not separately described. Various specification languages have been developed (e~.g., The paper includes an example of how to use SLAN-4, and also the-'~~~SPECIAL [1 8]) to support these two approaches. The objecexperiences gained in using the language to formally specify a realworld software product of about 18 000 lines of code written in an tive of these languages is to prevent design errors by appropriate IBM internal high-level language. syntactical constructs which give the possibility to detect them by syntax and semantics checks at an early stage of software

View PDFchevron_right

Related topics

  • Information Systems
  • Formal Specification
  • Specification Language

    • Cited by

    Automated Translation and Analysis of a ToolBus Script for Auctions
    Bert Lisser

    Lecture Notes in Computer Science, 2010

    ToolBus allows to connect tools via a software bus. Programming is done using the scripting language Tscript, which is based on the process algebra ACP. In previous work we presented a method for analyzing a Tscript by translating it to the process algebraic language mCRL2, and then applying model checking to verify certain behavioral properties. We have implemented a prototype based on this approach. As a case study, we have applied it on a standard example from the ToolBus distribution, distributed auction, and detected a number of behavioral irregularities in this auction Tscript.

    View PDFchevron_right
    Preliminary design of JML
    G. Leavens

    ACM SIGSOFT Software Engineering Notes, 2006

    JML is a behavioral interface specification language tailored to Java(TM). Besides pre-and postconditions, it also allows assertions to be intermixed with Java code; these aid verification and debugging. JML is designed to be used by working software engineers; to do this it follows Eiffel in using Java expressions in assertions. JML combines this idea from Eiffel with the model-based approach to specifications, typified by VDM and Larch, which results in greater expressiveness. Other expressiveness advantages over Eiffel include quantifiers, specification-only variables, and frame conditions. This paper discusses the goals of JML, the overall approach, and describes the basic features of the language through examples. It is intended for readers who have some familiarity with both Java and behavioral specification using preand postconditions.

    View PDFchevron_right
    Modular specification of frame properties in JML
    Gary Leavens

    Concurrency and Computation: Practice and Experience, 2003

    View PDFchevron_right
    Reasoning about object-oriented programs that use subtypes
    Gary Leavens

    ACM SIGPLAN Notices, 1990

    Programmers informally reason about object-oriented programs by using subtype relationships to classify the behavior of objects of dierent types and by letting supertypes stand for all their subtypes. We describe formal specication and verication techniques for such programs that mimic these informal ideas. Our techniques are modular and extend standard techniques for reasoning about programs that use abstract data types. Semantic restrictions on subtype relationships guarantee the soundness of these techniques.

    View PDFchevron_right
    An overview of Larch
    Stephen Garland

    Lecture Notes in Computer Science, 1993

    We begin by describing the Larch approach to speci cation and illustrating it with a few small examples. We then discuss LP, the Larch proof assistant, a tool that supports all the Larch languages. Our intent is to give you only a taste of these things. For a comprehensive look at Larch see 12].

    View PDFchevron_right
    580 California St., Suite 400
    San Francisco, CA, 94104
    © 2025 Academia. All rights reserved