About LePUS3 and Class-Z

LePUS3 and Class-Z are formal object-oriented Design Description Languages. They are formal specification lanaguges for modelling non-functional specifications representing the design of object-oriented class libraries, design patterns, and object-oriented application frameworks (What can be modelled with LePUS3). LePUS3 diagrams ('Codecharts', or simply charts) are axiomatized as decidable statements in the first-order predicate logic. LePUS3 is tailored for tool support in fully automated design verification (ie, checking conformance to Codecharts) and program visualization (ie design recovery from source code), as demonstrated by the the Two-Tier Programming Toolkit.

Related links:


LePUS3 and Class-Z are formal Design Description Languages tailored for the following purposes:

What can be modelled with LePUS3

Collections and Iterators in java.util Iterator pattern Java RMI
Object-oriented programs
(Above: collections and iterators in java.util)
Object-oriented design patterns
(Above: Iterator pattern)
Object-oriented application frameworks
(Above: Java RMI)


LePUS3 and Class-Z relate to languages of the following broad categories:

  1. Object oriented modelling languages (e.g., UML) are (mostly visual) notations that represent the building-blocks in the design of object-oriented programs.
    • Unlike UML, LePUS3 and Class-Z a formal language that are unpacked in a subset of the (first-order) predicate logic
    • Unlike UML, Codecharts (specifications in LePUS3) and schemas (specifications in Class-Z) are automatically verifiable
  2. Formal Specification Languages are mathematical languages (such as Z, B, and CSP) used to articulate properties of software systems in a language that lends itself to reasoning and verification.
    • Unlike these languages, LePUS3 is a visual language and charts therein are decidable formulas.
    • Unlike these languages, specifications in LePUS3 are automatically verifiable
  3. Logic Visual Languages use diagrams to articulate sentences in mathematical logic.
    • LePUS3 is a logic visual language geared towards specifications of object-oriented design.
  4. Architecture Description Languages are non-functional, [semi-]formal specification languages used to represent [architectural-]design decisions, normally associated with tools which integrate specifications with their implementations.
    • LePUS3 and Class-Z are Design Description Languages, not Architecture Description Languages. This means, among others, that LePUS3 is suitable for modelling Java programs and design patterns, not architectural styles.
  5. Program Visualization Notations offer a graphical representation of the program in a higher level of abstraction, normally generated by reverse-engineering the source code of the program (see how this is done by the Design Navigator).

The building-blocks of object-oriented design

Object-oriented programs written in languages such as Java, C++, C# and Smalltalk are encoded in text files ('source-code') which span across many files and directories. The size and complexity of these systems render code-level reasoning prohibitive; we cannot afford to design, understand, and use large systems by reading source code. Instead, we employ design abstractions: mental pictures of course-grained class hierarchies and sets of dynamically-bound methods and their interaction. These building-blocks can be coarse or refined, depending on the level of abstraction. A good specification language must allow us to represent these building-blocks at all levels of abstraction (example below).

We contend that a minimal set of conceptual building-blocks of object-oriented design can be observed [Eden 2002], that these building-blocks are amenable to formal analysis (using mathematical logic and finite set theory), and that they can be adequately expressed in a visual formalism (LePUS3). These building-blocks include the following:

  1. Individual classes ("classes of dimension 0") and methods ("methods of dimension 0")
  2. Properties of individual classes and methods ("unary relations") and relations amongst them ("binary relations")
  3. Sets of classes ("classes of dimension 1") and methods ("methods of dimension 1"), in particular dynamically-bound methods
  4. Correlations between sets of classes and methods ("predicates")

LePUS3 and Class-Z were tailored to model these building-blocks in a minimal vocabulary.

LePUS3 vocabulary (see also: LePUS3 and Class-Z Legend)



All examples

Further reading