The Extended BON Tool Suite

Authors: Joseph Kiniry (kiniry@users.sourceforge.net)

$Id: index.html,v 1.9 2002/12/10 12:01:09 kiniry Exp $

Introduction

BON is the Business Object Notation, a clear and concise graphical and textual specification language for software[WaldenNerson95]. BON is unique in that every construct specified in BON is checkable and reversible. That is to say, we can consistently and completely check the conformance of a piece of software according to a BON specification and any changes to the software can be reflected back into the specification. The specification is obviously an abstraction of the software, but a bijection (equivalence relation) exists between the specification an a subset of the software it specifies.

BON is useful for much more than "business" objects --- don't let the name fool you. BON is easy to learn, has a grammar and style that are influenced by the Eiffel programming language, and doesn't require a math degree, dozens of immense tomes to explain, nor multi-thousand dollar pieces of software to use.

This document describes a suite of tools called "Extended BON" or "Extended BON", the core of which is a Extended BON scanner, parser, documentation generator, and design model checker. This set of tools is meant to help software developers keep their documentation, design, and implementation in sync as well as help find and correct errors as early as possible in the process of creating software artifacts.

Extended BON is an extension of BON by Joseph Kiniry that incorporates additional formal specification from [KiniryZimmerman97] and [Kiniry01] via the use of semantic properties [Kiniry02-SP] into the BON standard. Since Extended BON is a proper superset of BON, this suite of tools will work with BON or Extended BON specifications.

Overview

The Extended BON tool suite consists of the following tools:

A Extended BON parser that reads textual Extended BON and generates a faithful, in-memory representation of its content. We call this representation the Extended BON Meta Object Graph, or MOG for short.
A serializer that can read and write Extended BON MOGs to and from permanent storage.
A documentation generator that can convert an MOG into a set of documents in a variety of formats according to a "pluggable" set of rules.
A MOG differencing tool that can determine the minimal rewrites necessary to convert from a source MOG to a target MOG.
A EBON2Eiffel tool that generates Eiffel skeleton code from a Extended BON specification.
A EBON<->Eiffel refinement mapping tool that helps a user map a specification to code.
A Extended BON Eiffel design model checker that compares an Eiffel implementation against a Extended BON specification.

Requirements

The phrase "must" means that the design and implementation of the discussed component is not considered completely unless the indicated capability is present and correct. The phrase "may" means that the capability is optional; it is a secondary requirement.

The Extended BON parser must:

parse the full BON textual specification language and represent specifications written in this language unambiguously,
parse the full Extended BON textual specification language and represent specifications written in this language unambiguously,
flag syntax and usage errors in a clear, concise, and correct fashion,
include and parse a Extended BON specification of itself.

The Extended BON parser may:

cache parse trees between invocations,
detect and parse only those documents which have changed since the last parse,
Support redefinition of string delimiters (String_begin and String_end).

The Extended BON serializer must:

serialize and unserialize an in-memory representation to a time-efficient format,

The Extended BON serializer may:

serialize and unserialize in a space-efficient format.

All tools must:

compile correctly in the SmallEiffel and ISE compilers.

All tools may:

compilation in Object Tools's Visual Eiffel compiler and ISS (Halstenbach) compiler.

Dictionary

AST: an Abstract Symbol Tree; a set of data structures used to represent hierachical, structured information, typically the results of a parse.
BON: the Business Object Notation; a software specification language documented in [WaldenNerson95] and primarily used with the Eiffel programming language.
Extended BON: an extension of the BON specification language. Extended BON is described in Extended BON.txt and primarily consists of the addition of higher-level specification constructs and operators from the KindSoftware code standard[Kiniry01] to BON.
Extended BON<=>Eiffel: a specification language that describes a isomorphism between a Extended BON specification and an Eiffel implementation.
Eiffel: an object-oriented programming language created by Bertrand Meyer and supported by four major compilers: GNU SmallEiffel, ISE Eiffel, Object Tools Visual Eiffel, and Halstenbach Eiffel.
Isomorphism: a (full) equivalence function that is both one-to-one and onto, a bijection, a generalized homomorphism.
Lexer: a software component that reads a formal notation and breaks input up into distinct, indentified tokens for parsing.
MOG: a Meta Object Graph; a set of data structures used to represent networks of objects that reflectively describe some structure at the metalevel.
Parser: a software tool that converts a tokenized input into a data structure-based representation, typically either an abstract symbol table (AST) or a metaobject-based data structure like our MOG.
Semantic Property: domain-specific specification constructs used to augment an existing language with richer semantics.
Token: a basic construct of lexing and parsing that represents a fundamental atom, or idea, and typically one which has a textual or graphical representation that is more complex than that which the token itself has.

Example

Pending...

Bibliography

      @Book{WaldenNerson95,
      author =       { Kim Wald\'en and Jean-Marc Nerson },
      title =        { Seamless Object-Oriented Software Architecture -
      Analysis and Design of Reliable Systems },
      publisher =    pub-ph,
      address =      pub-ph:adr,
      series =       { The Object-Oriented Series },
      year =         1995
      }

A PDF of this text will soon be available online. If you are working on the EBON project, request a copy from Joe Kiniry (kiniry@users.sourceforge.net) until Kim Walden puts the PDF up on the web.

      @TechReport{KiniryZimmerman97,
      editor =       { Joseph R. Kiniry and Daniel M. Zimmerman },
      title =        { The Infospheres Java Coding Standard },
      institution =  { Department of Computer Science, California Institute of
      Technology },
      year =         { 1997 },
      note =         { Available at http://www.infospheres.caltech.edu/ }
      }

      @TechReport{Kiniry01,
      author =       { Joseph R. Kiniry },
      title =        { The KindSoftware Coding Standard },
      institution =  { KindSoftware, LLC },
      year =         { 2001 },
      note =         { Available at http://www.kindsoftware.com/.  Directly
      evolved from Kiniry97. }
      }

      @Unpublished{Kiniry02-SP,
      author =       { Joseph R. Kiniry },
      title =        { Semantic Properties for Lightweight Specification in
                       Knowledgeable Development Environments },
      year =         { 2002 },
      url =          { arxiv.org },
      note =         { Submitted to the 10th International Symposium on the
                       Foundations of Software Engineering
                       (FSE-10). }
      }

Scheduling Goal

This project was started with the intent of entering it into Eiffel Struggle 2001. Only the first three tools (parser, serializer, and documentation generator) are meant to be designed and written for this contest. Since the Stuggle did not happen for 2001, we will enter this tool into the next contest.

This document was last committed: $Date: 2002/12/10 12:01:09 $

The Extended BON Tool Suite project is hosted by