***********************************************************************
*                                                                     *
*                             ANNOUNCEMENT                            *
*                                                                     *
*                            Release of the                           *
*                                                                     *
*                                 ROL                                 *
*                                                                     *
*                        Deductive Object Base                        *
*                                                                     *
*                               System                                *
*                                                                     *
*                             Version 2.1                             *
*                                                                     *
*                            May 15,  1996                            *
*                                                                     *
***********************************************************************

This notice announces the third public release of the ROL system via
anonymous ftp.

1. What is it?

ROL (Rule-based Object Language) is a deductive object base system
developed at the University of Regina in Canada with support from
Natural Sciences and Engineering Research Council of Canada.

The ROL language effectively integrates important features in deductive
databases and object-oriented databases. It supports object-oriented
features such as object identity, complex objects, classes, class
hierarchy, multiple inheritance with overriding and blocking, and schema.
It also supports structured values such as functor objects and sets and
provides powerful mechanisms for representing both partial and complete
information on sets. It is a pure declarative query language without any
imperative parts. It builds-in important integrity constraints, such as
domain, key, referential, functional dependency, and cardinality in a
uniform framework. Furthermore, it has a logical semantics that cleanly
accounts for all of its object-oriented and value-oriented features.

2. Who may use it?

The ROL system has been used by hundreds of users world-wide for various
data and knowledge-based applications since its first public release.
Some users say that the ROL is so far the only product available that
can do everything for their research projects and it is quite easy to
learn and use.

The ROL system has also been used to teach advanced database courses on
deductive databases, object-oriented databases, and/or deductive and
object-oriented databases at a number of universities around the world.

3. What is new in 2.1:

3.1     Query result control and processing
        It now provides the write command so that the user can control the
        way the query results are displayed and can store the results into
        a file in the way similar to C++. Here is an example:
        query A[age -> B], B > 20, write(stdout, A, '[age ->', B, ']\n')

3.2     Error message reporting
        If a ROL program has errors, the error messages are displayed
        more meaningful so that it is easier to debug the program.

3.3     Graphical database display
        If the ROL database used is a graphic database containing functor
        objects such as point, line, circle, polygon, polyline, and inpicture,
        then the database can be drawn on the screen by using the drawpicture
        command.

3.4     X-window interface (xrol)
        The user can simply use mouse to select commands rather than type
        everything.

3.5     Extensive and classified examples
        Significantly more examples are included in this distribution.
        Some of them are contributed by ROL users world-wide.

4. What is new in 2.0

4.1     Simplify and unify user interface

4.2     Support multiple class, object, and rule updates

4.3     Support createdb, destroydb for creating and destroying all
        database system files within ROL

4.4     Add the data type 'real' and the corresponding operations

4.5     Add string operations such as concat, like, substring

4.6     Add the 'in' (member-of) operation for sets

5. Features of 1.0

5.1     Effectively combining the bottom-up with top-down evaluation
        strategies together to answer user queries, and return all query
        results to the user at reasonable speed

5.2     Supporting higher-order features so that the user can write
        more general rules and issue more general queries

5.3     Providing basic update facilities so that the user can update facts
        and rules at run-time

6. Where to get it?

Release 2.1 of ROL is available via anonymous ftp from server

        ftp.cs.uregina.ca/pub/rol

7. What platforms can it run on?

        Hardware                Operating Systems
        --------                -----------------
        SUN SparcStations       Solaris 2.4 (both rol and xrol)
        SGI Workstations        IRIX 5.3 (both rol and xrol)
        DEC Workstations        Untrix V4.3 (only rol)
        IBM PC Compatibles      Linux 1.2.8 (only rol)

8. Future work

8.1     Client-Server architecture

8.2     Interface to C/C++ so that rol can call C/C++ functions and
        C/C++ programs can embed ROL commands.

8.3     Efficient Object Management

8.4     Work that users suggest

9. An Example

Following is a graphic ROL program which can show the power of ROL system:

%       This is a graphic database represented in ROL format.
%       This database can be displayed on the screen by using the drawpicture
%       command. To obtain the complete picture described by this program,
%       first type query X:inpicture, then type drawpicture, as some objects
%       in the picture are inferred by rules.

Schema

        object
        point(integer, integer)                 % x, y
        line(point, point) isa object           % from, to
        circle(point, integer) isa object       % center and radius
        polygon(integer, {point}) isa object    % location, side #, points
        polyline(integer, {line}) isa object    % location, side #, lines

        house[  roof => polygon,
                door => polygon,
                windows => {polygon},
                frame => polygon,
                paveway => {line} ] isa object

        human[  head => circle,
                body => line,
                arms => {line},
                legs => {line} ] isa object

        tree [  lines => {line} ] isa object

        inpicture(point, object)

Program

%       Define the graphic object standing human

%       Here standing is an object identifier which identifies a graphic
%       structure so that several objects in the picture can use/share the
%       same structure.

        standing: human[head -> circle(point(10,25),5),
                        body -> line(point(10,20), point(10,10)),
                        arms -> {line(point(10,15),point(0,10)),
                                 line(point(10,15), point(20,10))},
                        legs -> {line(point(5,0), point(10, 10)),
                                 line(point(10,10), point(15, 0))}]

%       Define the graphic object working human

        working: human[ head -> circle(point(10,25),5),
                        body -> line(point(11,20), point(13,10)),
                        arms -> {line(point(12,15), point(9,11)),
                                 line(point(9,11), point(4,8)),
                                 line(point(12,15), point(16,15)),
                                 line(point(16,15), point(20,10))},
                        legs -> {line(point(13,10), point(8, 2)),
                                 line(point(8,2), point(8, 0)),
                                 line(point(13,10), point(18, 0))}]

%       Define the graphic object bungalow house

        bungalow:house[ roof -> polygon(4, {point(10,50),point(60,50),
                                            point(70,40),point(0,40)}),
                        door -> polygon(4, {point(30,20), point(30,34),
                                            point(40,34),point(40,20)}),
                        windows -> {polygon(4, {point(15,27), point(15,32),
                                                point(25,32),point(25,27)}),
                                    polygon(4, {point(45,27), point(45,32),
                                                point(55,32),point(55,27)})},
                        frame -> polygon(4, {point(10,20), point(10,40),
                                             point(60,40),point(60,20)}),
                        paveway -> {line(point(30,20),point(27,0)),
                                    line(point(40,20),point(43,0))}]

%       Define the graphic object twostorey house

        twostorey: house[ roof -> polygon(3, {point(0,65),point(40,80),
                                              point(80,65)}),
                          door -> polygon(4, {point(35,20),point(35,40),
                                              point(45,40),point(45,20)}),
                          frame -> polygon(4, {point(10,20),point(10,65),
                                               point(70,65),point(70,20)}),
                          windows -> {polygon(4,{point(15,30), point(15,40),
                                                 point(30,40),point(30,30)}),
                                      polygon(4,{point(50,30), point(50,40),
                                                 point(65,40),point(65,30)}),
                                      polygon(4,{point(15,50), point(15,60),
                                                 point(30,60),point(30,50)}),
                                      polygon(4,{point(50,50), point(50,60),
                                                 point(65,60),point(65,50)}),
                                      polygon(4,{point(35,50), point(35,60),
                                                 point(45,60),point(45,50)})},
                          paveway -> {line(point(35,20),point(32,0)),
                                      line(point(45,20),point(48,0))}]  

%       Define the graphic object pine tree

        pine:tree[ lines  -> {line(point(18,0),point(18,20)),
                              line(point(0,20),point(36,20)),
                              line(point(0,20),point(18,55)),
                              line(point(18,55),point(36,20))}]

        maple:tree[ lines  -> {line(point(10,0),point(10,30)),
                                line(point(0,25),point(10,15)),
                                line(point(10,15),point(20,25))} ]

%       Draw initial humans

        inpicture(point(50,215), standing)
        inpicture(point(110,215), working)

%       Draw initial houses

        inpicture(point(50,220), bungalow)
        inpicture(point(400,220), twostorey)

%       Draw an initial tree

        inpicture(point(10,235), pine)

%       Draw the road  

        inpicture(point(10,220), line(point(0,0), point(640,0)))  
        inpicture(point(0,210), line(point(0,0), point(630,0)))  

%       Draw the Sun

        inpicture(point(500,500), circle(point(10,20), 20))  

%       Draw the mountain

        inpicture(point(100,300),
                  polyline(2,{line(point(0,0),point(150,150)),
                              line(point(150,150), point(300,0))}))

%       Draw the garden

        inpicture(point(50,100), polygon(4,{point(0,0), point(50,50),
                                            point(500,50), point(550,00)}))

%       Draw initial trees arround graden

        inpicture(point(120,140), maple)

        inpicture(point(90,110), maple)

%       Draw the rest humans with rules

        inpicture(point(X,Y), Z) :- inpicture(point(X1,Y), Z), Z:human,
                                X = X1 + 180, X < 650

%       Draw the rest pine trees with rules

        inpicture(point(X,Y), pine) :- inpicture(point(X1,Y), pine),
                                X = X1 + 120, X <650

%       Draw the rest maple trees with rules

        inpicture(point(X,Y), maple) :- inpicture(point(X1,Y), maple),
                                X = X1 + 50, X <550

%       Draw the rest houses with rules

        inpicture(point(X,Y), bungalow) :- inpicture(point(X1,Y), bungalow),
                                X = X1 + 120, X <400

        inpicture(point(X,Y), twostorey) :- inpicture(point(X1,Y), twostorey),
                                X = X1 + 120, X <550

--
--------------------------------------------------------------------------

Dept of Computer Science                    Tel:        (306) 585-4700 (O)
University of Regina                                    (306) 789-9823 (H)
Regina, Saskatchewan                        Fax:        (306) 585-4745
Canada S4S 0A2                              WWW:   www.cs.uregina.ca/~mliu
--------------------------------------------------------------------------