SYCO G++

A Framework, a Method and an Environment for the Object Oriented Development of Computer Integrated Manufacturing Systems

Abstract

G++ is an environment for OO modelling, design, prototyping, and implementation, with the C++ and Java languages, of concurrent distributed software applications. It has been specifically conceived for the Computer Integrated Manufacturing domain.
 
Three philosophies are embedded in G++:

• the Boehm spiral model .
• the Rumbaugh idea of transformation from OO/A to OO/D.
• the Coad and Johnson OO patterns.

The environment encompasses:

• a design method enabled by a OO pattern language;
• libraries of reusable classes;
• an evolutionary software development process based on transformations;
• CASE tools for analysis, design, prototyping and code generation;
• GUI editors.

The Frameworks

• OAK  - a kernel of basic types and data structures in the Smalltalk style;
• Rodin  - classes supporting concurrency, to handle events, and to create discrete event simulated and real time systems,
• Mondrian  - objects encapsulating MS-Windows and OSF/Motif;
• Editors  - graphical editors for software development and gui generators;
• Colombo  - a library for distibuting objects in the style of OMG CORBA and Microsoft D-COM.
• Persist  - a framework for RDB persistency.

Common functionalities

All objects of the framework enjoy optional run-time pointer checking, exceptions and errors handling, function tracing, persistency and the "callback" mechanism for event based programming.

Objects and Concurrency

• fine grain - event based programming such as the actor model of computation, supported by an extended callback mechanism
• medium grain - concurrent processes cooperating through shared resources, supported by multi-threads
• large grain - active objects exchanging synchronous and asynchronous service requests, through a powerful G++ Active Object design pattern

An important feature of the Rodin framework, which support concurrency, is the set of classes that implements multitasking. At the basis there is the Thread class, i.e. a separate execution environment of a routine or a method. This is a thread of control "lightweight" and preemptive which wraps the corresponding operating system capability.
Threads synchronize each other through the Semaphore objects, the CriticalRegion objects or objects that encapsulate one of these objects.

Distributing objects

The library for distributing objects enables to build distributed applications in the style of CORBA. The library offers basic classes and the functionalities for constructing from the interface of an object, its remote Stub, and the Skeleton of its implementation.
The central class of the framework is DistributedProxy. All Stub includes an instance of this class and all Skeleton derives from that central class.

RDB Persistency

The RDBPersistency framework enables the object-oriented access to relational databases, which support the ODBC interface.
The central class of the framework is PersistentObject. User-defined classes are derived from this class, usually automatically by using the schema definition language and the schema parser provided by the environment.
Each subclass of PersistentObject maps to a relational table, and has a DbField object for each field which maps to an attribute of the class. Different subclasses of DbField are used for different field types. The following DbField subclasses are currently defined: DbString, DbDouble, DbLong, DbDate DbTime, DbTimeStamp.
PersistentObject and the DbField subclasses are implemented with calls to the static GppOdbc instance in PersistentObject. GppOdbc is an object-oriented encapsulation of the ODBC interface, and although the framework user seldom interacts with it directly, it is useful for experimentation against databases or for specialized queries or other database operations.

Pattern Language and Development Method

The software development process is evolutionary, achieved by transformations from analysis to logical architecture/class design, resulting in an early prototype, and from the prototype to physical architecture design, resulting in the final implementation.
These transformations are driven by an original pattern language, whose design patterns help to map the problem analysis onto the design supported by the G++ frameworks of classes. Each pattern documents and explains the use of the framework classes, and the whole language offers the development method to the environment.
Operationally evolution from specifications to design, is enabled by maintaining the different representations (spaces) of the object model and by transforming relationships between entities from the problem space (association, aggregation, generalization) to the logical design space (use, encapsulation, inheritance, creation, destruction), and the physical design space (linking between interfaces and implementations).

 The CASE Tools

All phases of the process, and more specifically the transformation processes between spaces are supported by integrated CASE tools, composed of graphical editors, code/document generators and a common repository.
The same graphical representations used for specification and design, offer at run-time, during the prototyping phase, data browsing, exception handling, and debugging through the animation of the specifications.
Moreover the environment has been conceived to support, based on cooperative team work, a spiral model which considers repeated visits to the different phases of the development process.

Analysis - MSC - high level design

Analysis, high level logical and physical design are carried out by using an object model which adopts the UML notation. Different views of the same problem, are offered for each phase of the development which allow to maintain the user description, completed by use case representations and Message Sequencing Charts (MSC), the software designer description, and the implmenetation description.

Class design and Interface specification

A detailed class design is obtained by transferring the ESA-HOOD modelling technique and notation to the C++ language. Class templates are started by capturing information directly from the high level logical design and are completed by adding sequential and concurrent behaviours to the class. From the class design the class interface specification is derived when needed for distribution, and conversely from an interface the prototype of the class can be started. Functionalities are offered to the class design to either generate C++ or Java code or reverse engineer legacy software, and to the interface specification to import/export CORBA-IDL files, offering complete interaction with external environments.

The behaviour editor

• The same SDL representation has been adopted to support fine grain event based programming, and medium grain process based programming styles, generating in both cases the control logic which implements the object’s dynamics.
• At the prototyping stage the graphical representation becomes the tool for animating the specification.

Editors

• personalized editors for graphical languages;
• GUI generators for process monitoring and control, and specification animation.

Graphical Languages

The basic G++ graphical editor encapsulates a Semantics object, which redefinition allows the user to customize editor behaviour, document and code generation functions.

Gui Generators

The editor to build graphical user interfaces, along with standard drawing functions, offers a common interface to handle animate icons used for monitoring and control. A library of those icons is already available, however new icons can be created from the common interface offered by the framework. A run-time kernel allows the graphical interfaces to be integrated into the application.

Document Generation

Each editor allows to generate a single document in HTML or RTF format of its contents. For the whole project the complete design and reference manual is derived in a form of a document where each chapter contains a fragment of the design or the detailed reference of each class.
The integration of G++ with OpenGL graphical libraries will offer soon the extension to 3D graphical representations.

Java

Platform

Conclusion

The approach supported by G++ aims at raising reusability in software development from the component level to the architectural level, and at easing the designer’s task, when making choices in the conceptually sophisticated environment of OOP. This has been made possible thanks to an innovative architectural model, unambiguous design rules, a framework of reusable classes and CASE tools which offer seamless evolution from the problem analysis stage to that of the software implementation.
G++ has been conceived for the development of large software projects in the realm of concurrent and distributed systems, with specific emphasis being originally placed on the area of process control with ship automation; CIM for the design of cell controllers, monitoring systems, decision making algorithms for production scheduling and dispatching; freeway automation.
However more recently telecommunication companies have discovered that G++ is the proper tool in their field, as well, and G++ derived environments have been adopted for design and prototyping inside the TINA consortium, for development of Telephon Computer Integration systems and for the interconnection of Enterprise Resource Planning Systems (ERPS) through Internet.
The range of action of the tools which extends from analysis to the physical process, and the power of its frameworks nowadays cannot be matched by any other environment of its kind present on the market.
Using the G++ environment, SYCO is specialized in offering training on OO analysis and design by developing together with the customer complete operative case studies, covering control, graphical interface and distribution, starting from the customer’s specifications.
SYCO can also show different demostrations of the environment, based on its recent work: Flexible Manufacturing System controllers, AGV systems, Monitoring and control systems, production schedulers, network configurators, finite state machine editors and interpreters, mobile agent based interaction of local ERPS in the virtual factory.