Post by Heping » Wed, 01 Apr 1992 03:32:20

About Three weeks ago, I posted an article asking about Object-oriented
4GL for engineering applications and promised to post a summary of the
replies. I have got six replies from different people. My appreciation
to all of them for their time and informative messages.

The following is the summary of the six replies, in which I did not include
names of people who sent me messages except those that have to be included
for getting further information.

------------- the Eiffel language -------------

Eiffel, developed by Interactive, is an object-oriented
programming language for engineering
quality software for production applications. The Eiffel Extended
Environment developed by Interactive  combines
the ideas of object-oriented design with modern
principles of software engineering, providing a framework
for the development of highly reusable and flexible
software packages.

The Eiffel language itself is in the public domain, and
is defined in "Eiffel: The Language" by Dr. Bertrand Meyer,
(Prentice Hall 1991).

There are Eiffel library and environment components available for database
capabilities {EiffelStore (Standard Relational DBMS interface)},
GUI Capability {EiffelBuild (Interactive GUI development system)},
and concurrent/distributed processing capabilities.

The software components are available through:

  Interactive Software Engineering
  270 Storke Road, Suite 7
  Goleta, CA 93117
  Phone: 805-685-1006, Fax: 805-685-6869
  email: quer...@eiffel.com

The book "Eiffel: The Language" is available through most

------------------- Objectworks\Smalltalk and Facets -----------------

I am responding to your request for information about CASE tools or systems
using 4th generation languages.  I would like to introduce you to ParcPlace
Systems' products Objectworks\Smalltalk and Facets.  Objectworks\Smalltalk
(OWST) is a pure object oriented development environment.  Facets is a
4/GL, written in Smalltalk, that helps you build graphical interfaces.  If
you would forward your complete mailing address, I would be happy to send
you the product brochures, and information about the educational discount
we offer.

In the meantime, I would like to tell you a little about the products:

What is Objectworks\Smalltalk?

It is a development environment for creation, management and delivery of
object-oriented software programs using Smalltalk-80.  The development
environment includes:
        Substantial Class Library
        Source code browsers and editors
        Symbolic Debugger
        Object inspector
        Access to other languages, such as C
        On-line Tutorial

What hardware will it run on?

Objectworks\Smalltalk will run on Macintosh II, 80386 PCs with MS-Windows
Sun-3, Sun-4, SPARCStation, DECStation 3100 and 5000, Hewlett-Packard 9000
series 300, Apollo workstations, IBM RS/6000, and Sequent.  Applications
written in Smalltalk-80 are portable across all platforms.

What is Facets?

Facets is a fourth generation language written in Smalltalk that helps you
quickly generate screens,reports, menus, and other interface components.

What hardware will it run on?

The Facets product will run on all platforms that OWST runs on.

How can I order Objectworks\Smalltalk and Facets?

ParcPlace Systems accepts purchase orders, check, Visa and MasterCard.  To
place your order or request additional information contact me at:

        ParcPlace Systems
        1550 Plymouth Street
        Mountain View, CA  94043
        Phone:    415-691-6734-direct line
          Fax:             415-691-6715
        email: ci...@ParcPlace.COM

Cindy Sage
ParcPlace Systems
Corporate Sales

-------------------- Accent -----------------------

My firm (Caseware), in Costa Mesa, and soon Irvine, has developed
a language for just this purpose. The language is called Accent,
and has been used to develop a best-of-class CASE product,
called Amplify (which is a configuration management environment).

Here are some of the language features which you may need:

 - object oriented features
 - strong static type checking
 - built-in communication (inter-process function calls)
 - several other distributed processing features
 - simplified definition and operation of graphical interfaces (X/Motif)
 - very high-level built-in data types (e.g. tables)
 - many useful built-in methods (e.g. string manipulation)
 - no need to do memory management and other low level chores
 - easy access to portable OS features
 - object database capability provided by Amplify
 - object code is machine independent

The language is bundled at no cost with our Amplify product.
If you obtain an evaluation copy of Amplify (or perhaps a free
copy since your interests are apparently research), then you
get unlimited use of Accent.

Right now, documentation on Accent is scant, but we do have
reference manual, and you should be able to get any questions
answered easily by e-mail or phone.

If you are interested, please let me know. While we don't sell
Accent as a product, I am personally interested in testing
its use in other applications, and am willing to help you out
if I can.

            Amplify(R) Control from CaseWare(R), Inc.

Amplify Control is an interactive development environment which
emphasizes configuration management and tool integration. Amplify
provides both graphical and non-graphical user-interfaces which may be
modified or extended by the user. The graphical interfaces support
current standards such as Motif, Sunview, and OpenLook.  Amplify also
supports a variety of configuration management methodologies via its
flexible object-oriented data modeling capabilities. Use of Amplify
is not limited to software development and is not language specific.

These are the main functional areas of Amplify:

Configuration Management:
    Managed objects in Amplify are considered versions of
    components.  Each such component is stored and manipulated
    according to its type, which may be user defined. The component
    types are defined in a "development model," and form a
    hierarchy in which inheritance of both data and methods
    occurs.  Certain component types, called "assemblies", are used
    to collect others into configurations over which functions such
    as software product construction may be performed.

Graphical Development Interface:
    Most amplify operations, as well as a variety of development
    tasks, may be performed via the GUI's. Configurations and
    version histories may be traversed and manipulated using the
    "point-and-click" style of operation. Both built-in and
    user-defined operations may be invoked from menus which
    accompany the various displayed objects.

Tool Integration Platform:
    By means of a combination of development models and
    extensibility of both the graphical and command-line
    interfaces, users may add their own operations and integrate
    other tools with Amplify.

Important features of Amplify include:

Version History View:
    A graphical depiction of the derivation history of any
    component in the system may be viewed and manipulated.
    Parallel, successive, and merged versions may be represented.
    Version histories of entire configurations may also be
    manipulated. Each version has a status (e.g. working, released)
    within a user-defined life-cycle.

Configuration View:
    Assemblies of components, which are internally represented
    as directed graphs, may be viewed and traversed using the
    configuration view. This view, as well as history view,
    permits invocation of various operations on the displayed
    objects via mouse buttons and menus (such as editing of
    source code).

Build Graph View:
    Provides a means to visually define the processes, data
    flow, and dependency paths involved in constructing one or more
    products from a collection of input data. These graphical
    representations are termed "build graphs", and the semantic
    information they convey drives the automatic build process.

Automatic Build Process:
    The build process, which may be invoked from the configuration
    view or the build graph view, allows construction of software
    products such as executables, or other development products
    such as documents. The build algorithm utilizes "build graphs"
    in conjunction with assembly hierarchies to determine
    dependency information and updates all out-of-date products.
    Build processes may be distributed to appropriate machines
    for load balancing or cross-development.

Automatic Configuration Update:
    The "reconfigure" algorithm employs user-defined rules to
    automatically update the contents of assemblies. Thus
    assemblies may be updated with the latest versions of their
    constituent components, or with versions which meet other
    criteria such as test or QA level, target compatibility, etc.
    Software component dependencies (such as include files) may
    also be automatically updated by this process.

Build Product Sharing:
    Build products, such as object files, executables, and
    libraries, are automatically shared among many configurations
    and users.

Problem Tracking:
        An advanced and customizable problem tracking and task
        management system is optionally provided, which is
        integrated with the rest of the CM functions.

Query and Reporting:
    A sophisticated ad hoc query and reporting capability is

Security and Access Control:
    These features permit enforcement of methodologies, as well as
    ordinary access restrictions.

Extensible Command Language:
    Amplify includes a command language interface which may be
    extended by installations as well as individual users. This
    language provides access to most Amplify capabilities.

Extensible Graphic Interface:
    Development modelers may alter or extend the Amplify user
    interfaces by changing control panels, extending type-specific
    menus, and by adding their own dialog boxes. All such
    extensions will work with all window systems which Amplify
    supports and can be made without knowledge of the API's of
    these window systems.

ACcent(TM) Programming Language:
    This very high-level, procedural and partly object-oriented
    language provides the means for making the various extensions
    to the Amplify platform. The "methods" which belong to
    user-defined data types, as well as user-interface extensions,
    are all made using this language.

Amplify is currently supported on several Unix platforms, including
Sun Sparc, HP300/400 and 700/800, and others. Both the X Window
System and Sunview are supported.

CaseWare is committed to open systems and supports a variety of emerging
standards in the CASE and software systems industries.

Packages integrating Amplify with tools from other vendors are also
available. Please inquire about tools for which you need support.

For additional information please contact:

    Sales Department
    CaseWare, Inc.
    3530 Hyland Ave. #115
    Costa Mesa, CA 92626
    (714) 754 0308
    FAX: (714) 754 1568

    email: ampl...@cwi.com

-------------------- Windows4GL -------------------

    You might be interested in looking at Windows4GL, a product developed
by Ingres Corporation.  We're in Alameda, and are best known, I guess, for
developing the relational database of the same name.
    Windows4GL is a true application development 'environment', which you
said you were less interested in, but its language does have the features
you're looking for.  The language is an integration of 3gl (IF-THEN-ELSE,
WHILE-DO, BEGIN-END, pointers, etc), and SQL.  The object-orientation comes
in because the language comes with a library of about 50 pre-defined classes,
whose attributes can be referenced, and whose methods can be invoked, with
a very clean syntax in the 4GL.
    I think it's the greatest thing since sliced bread, but it may not fit
your needs because it's architecture is interpretive by nature.  Basically
you use a set of GUI-based tools to develop an application based on frames,
using the event-driven 4GL to process input and output.  The application
definition, once completed, is stored in a data dictionary.  At that
point, an interpretive engine is used to 'run' the application either from
the data dictionary, or from a flat file.
    If you want more information, call 1-800-4INGRES (1-800-446-4737).

--------------- Object/1 ---------------

You might want to look at Object/1, a product sold by my company.
It has a C-like language in a Smalltalk-like development environment
and object-hierachy, but using it is very like a 4GL because of the
built-in database and screen design facilities.

Jon Reid, Manager Software Development  Micro Data Base Systems, Inc.
                                        Box 6089 (Two Executive Dr.)
uunet!purdue!mdbs!jon                   Lafayette, IN  47903    USA

-------------------- DEC Trellis ----------------

Digital sells a product called DEC Trellis (on RISC/ULTRIX and VAX/VMS) that
is a workstation-based object-oriented environment, based around a very
high level language definition (Trellis). It includes browser and
other tools, and libraries for X-windows, SQL, Objectivity/DB. The product
manager Jerry Smith can be reached at <sm...@pipe.enet.dec.com>

------------------- end of summary ----------------

Heping He
Department of Information and Computer Science
University of California, Irvine
Irvine, CA 91717


1. OO 4GL, was: RE: open source and NewEra (was: IIUG Stuff)

Speaking personnaly, not in name of the company I work for. Please see
bottom note also.

It is a good opportunity to have a debate and to understand what the
real needs are. When I was a developer, I started by VB and went to more
serious things including Java and 4GL. They can suffer pretty well the
comparison - on a language base.

Productivity in 4GL is greater than in Java, in regards of Business
Applications. Sure, you can't do everything with 4GL but 4GL vendors are
working in that direction (speaking of Four J's, QueriX and Aubit).

None has yet offered offer OO. I know Andrej is speaking about it in
Aubit, but...

Do we want it?

I think it is a good question with an appropriate debate.

My toughts are:
- OO can be complex
- OO is evolving: patterns, structures are changing
- OO is not easily map-able to rdbms
- Some principles of OO are easy like polymorphism, but require strong
typing which is not the case of 4GL
- OO concepts can be applied without the language enforcing it (i.e.
isolation, securing data)
- OO may require complex diagram in UML
- OO increases flexibility
- OO is not only a RECORD with methods
- ...

Will OO 4GL attract more people? Perhaps. Comparing C++ and Java, C++ is
the OO of C, but if one has bad habits or keep a mixture of both C &

Speaking on economics, getting a developper to do OO is costly. Business
Apps focus on Business Logic, so I'd rather invest in training people to
understand the Business Logic rather than the OO technologies...

Of course, the debate is open and I'd love to hear comments from others.

Note: And remember, I speak **personnaly**, not in name of the company I
work for. And I am not at all in this business in the company I work
for. I endorse none of the choices. I am completely neutral there and I
want a clean & neat debate without vendors mentionned everywhere. By
reading the content of this e-mail, nobody knows who I am working for,
so I'd love the debate to stay on this level.


Jean Georges PERRIN

2. Urgent Help ! About VBSQL OLE Automation Errors

3. OTC OO 4GL, was: RE: open source and NewEra (was: IIUG Stuff)

4. dts fro Btrieve to sql server7

5. OO 4GL, was: RE: open source and NewEra (was: IIUG Stuff)

6. Visual Basic 6.0 Access 2.0

7. OO 4GL

8. HELP!!!: Replication Syncs ups but does not Replicate thereafter.

9. OODBMS and OO-4GL


11. OO Schema for RDBMS (was: Hierarchical vs OO question)