grh@cbnewsl.att.com (george.r.heuer) (06/19/91)
Fellow Netters,
I recently posted a request for user information on two toolkits
(OI and OLIT) that offered OPEN LOOK look and feel. I received a large
number of responses from my post. Below are some edited
comments that I have extracted from the mail I received.
Randy Heuer
grh@cbnewsl.att.com
Comments from OI/OLIT users:
--------------------------------------------------------------------------
...bob klein...
att!druhi!rmk
I have been using the OI toolkit for over two years now. I was
the first AT&T person to use the toolkit from Solbourne because I
have a working relationship with the people at Solbourne.
Anyway I have used OI sucessfully in two large C++ projects. APT
was about 100K lines of C++ and my current project GHOST is
about 20K lines of C++ code (and growing daily).
In general, my experiences with OI have been very good. Of course
I suffered through many of the original alpha and beta versions of
the code. But now I would heartily recommend usage of the software.
It allows me to not have to concentrate on the user interface aspects
of the software project. I can do what I need to do simply and quickly
and can concentrate my efforts on the real programming problems.
--------------------------------------------------------------------------
From: matt@saber.com
Yup, I'd say we know quite a lot about OI at this point, having
been working with it for a few months. I'm not quite sure what you want
to know, however. Overall, it and InterViews are the only credible C++
UI toolkits I've ever seen, and InterViews ignores the "big two" application
style guidelines, so ...
OI is worlds ahead of OLIT, for a number of reasons. One is simply
that it's hard to provide the illusion of a class hierarchy and inheritance
mechanism in C, and the Intrinsics model does a pretty poor job of it, while
OI has the benefit of being a C++ toolkit. We're subclassing OI like crazy
to provide specialized bits of behavior, and it's so easy one finds it hard
not to pity people who are still working with Xt.
Programming languages aside, the OI designers have done a few things
in ways that are fundamentally different than I've seen anyone else do them.
Probably the most interesting is the separation between the OI object tree
and the X11 window tree -- removing the restriction that the window hierarchy
and the object hierarchy be isomorphic allows considerably more flexibility
in application design and behavior than I've seen in any other toolkit.
Combine that with dynamic reparenting, and with the exceptionally strong
use of resources, actions, translations, and accelerators in OI, and you've
got what I believe to be the best user interface toolkit you'll find outside
of NeXT.
If I had to GUESS, though, I'd say you can expect about a 25 - 40%
reduction in user interface code using OI. For example, I recently wrote a
color browser/editor in OI (in about 6 hours!) that does just about
everything xcoloredit does.
XColoredit is about 1600 lines of C code, using widgets. ColorView
is about 750 lines of C++ code. ColorView, being an OI application,
also provides Open Look 2D, Open Look 3D, and Motif visual behavior
and interaction semantics.
As far as performance goes, it appears that OI applications written
with the current version of the toolkit tend to be slightly smaller
than their Motif-based counterparts, about the same size as their
XView-based counterparts, and perform about as well as either XView
or OSF/Motif toolkit applications.
--------------------------------------------------------------------------
George Kakatsakis 303-772-3400 georgek@Solbourne.COM
I am the engineering manager responsible for the OI toolkit. If you want
additional information I can put you in touch with real users. These are
people putting together internal applications at Fortune 500 companys and
a couple ISVs. I can also get you in touch with internal AT&T sites that
are basing much of their application development on OI. Feel free to call
anytime.
--------------------------------------------------------------------------
I've worked with OLIT and played around a small bit with OI (just enough to
be dangerous :-)
There are various things you should consider:
1. Compatability with other tools
2. Maintainability
The OLIT toolkit is an Intrinsics-based toolkit - which means that anyone
who knows about X Windows Intrinsics will know how to write a GUI with
OLIT. If, in the future, you decide to go to another interface that is
Intrinsics-based, you shouldn't have too much of a problem. Also, OLIT
is supported by both Sun and AT&T, so you will not have to worry about
its disappearance any time soon.
OI, on the other hand, has the advantage of a C++-based design (OLIT is
a C-based toolkit. If you plan on standardizing on C++, you will not
get the benefit of any "classes" from OLIT). Anyway, OI is a class library
that is very powerful, apparently very intuitive, and very incompatible with
any X-Window Intrinsics-based toolkits (OI is compatible with X Windows
on the Xlib level). If you have people that are familiar with the Intrinsics,
they can chuck that knowledge out the window with OI. Also, since most of
the people on the net seem to be more familiar with Intrinsics-based toolkits,
you're more likely to get help with OLIT than with OI.
OI has the additional advantage that you can dynamically choose between
OpenLook and Motif interfaces, although the early version
I had was pretty primitive (I know the current version is supposed to look
really cool in either mode)...and if you're only concerned about OpenLook,
than this is not too much of an advantage.
In summary, from a technical perspective, OI is superior to OLIT. It's
C++ based design lends itself to better integration into C++ based
projects. However, unless more people start using it, there isn't enough
of a knowledge base to draw upon in times of need (as a matter of fact,
the only people I can remember talking about OI on the net were
the folks from Solbourne - ie. Tom et. al).
--------------------------------------------------------------------------
From: daw@honshu.att.com (David Wolverton)
I would probably try OI in your situation (fresh start/using C++)
assuming I did not get any strong negative reaction from the net.
The OI toolkit is better integrated into the C++ type system
(i.e. object oriented) than is OLIT, which should help make your
system's overall design cleaner. The "level of abstraction"
of both toolkits seemed to be comparable, but then I don't have
actual experience with OI. There is the benefit of Motif GUI
"for free" in OI, but that does not seem to be an important
factor in your case. A drawback of OI is that it has slightly
less industry momentum behind it than OLIT, with Sun and USL
both pushing OLIT, but only USL pushing OI (I don't know how
hard USL is pushing OI compared to OLIT).
The OLIT product I used (vers. 2 with extensions) worked well,
had a reasonable level of bugs (not 0, but not too many either),
and had OK (not great) documentation. OLIT's performance may
be slightly better then OI's (not totally sure of this), but I
would venture a guess that the performance of either of these
toolkits will not be a bottleneck in most systems.
--------------------------------------------------------------------------
uunet!tdatirv!sarima (Stanley Friesen)
My preference would be for OI. For three basic reasons:
1. OI is a C++ toolkit, and will thus mesh better with the rest of
your project. (While OLIT is nominally object oriented, this is
hacked on top of standard C, and its style certainly is not easily
coordinated with C++. Just the differenc in meaning of a prototype
with empty parenthesis in a header could kill you).
2. As I understand it, OI is switchable between OpenLook and Motif,
and I believe in flexibility. (OLIT is a pure OpenLook toolkit).
(I may be wrong here, since I do not have access to the OI docs).
(Since both Motif and OpenLook are here to stay, you need to
support both if possible - a switchable toolkit is the easiest way).
3. OLIT, as an Xt Intrinsics based toolkit, is very difficult to program.
(It is full of idiot little details that must be gotten *exactly* right).
(Not only must you create all of the widgets (== objects), you must
hand them configuration data, which often require a great deal of tuning
- just read comp.windows.x for awhile to get some idea of the problems).
--------------------------------------------------------------------------
Randy Brown (uunet!erik!rbrown)
We use OLIT. and have for about 18 months. It works. We use Wcl,
as published on comp.sources.x and on export.lcs.mit.edu, which allows
the widget instance tree and all callbacks to be specified in the
resource files, thus eliminating all the tedious widget creation
code and reducing our chores to writing callbacks.
This scheme works well. In particular, it works better than
the Motif toolkit, which we tried for about 8 months. It was buggy
and there were MANY undocumented side-effects and undocumented
"convenience" functions. We really couldn't get our work done as
fast with Motif, since we spent so much time on workarounds.
We use C, not C++. (Not my decision... ) OI certainly looks
fascinating. It, like Xt with Wcl, makes heavy use of the resource
database. In fact, it is being modified to make even more use of
resources. I wish I could report on experiences with it...
We also tried XView. (We've been doing X for more than two years.)
It's simply not as flexible as OLIT or OI, and is reported to have
some limitations irritating to those not coming from a SunView
background. For one, it makes very limited use of the resource
database.
--------------------------------------------------------------------------
From: malbert@govt.shearson.com (Marc Albert)
If you want real OpenLook conformity don't use OI. I use both
OI and OLIT and I prefer OLIT. The newest version, due out any day now,
makes it pretty complete. I don't know how well it
will work with c++ though.
--------------------------------------------------------------------------
From: djb@cborion.cb.att.com (David J. Bryant)
My project and several of our customers and development partners
have been using the OLIT toolkit for almost two years now. While we've had
some problems (mostly in the early days with OLIT 1.0), on the whole we've
been pleased with the OLIT toolkit and the support we've been able to get from
USL and Sun. We have had some experience mixing C++ and C in order to use OLIT,
and things have gone well. In general, I have a couple of reasons for
continuing to use OLIT:
1) It is based on the industry standard (and in some cases, like
government applications, mandatory) Xt Intrinsics interface
2) It is available on Sun, AT&T 6386, and HP systems, with DEC and
IBM support expected later on this year. Vendor support has been
good, and binary offerings are what we and most of our customers
require.
3) C is still more widely available than C++
4) OLIT offers more immediate access to toolkit object ("widget")
improvements and evolved adherence to the Open Look specification
We've looked at OI and are continuing to track new releases from Solbourne.
(In fact, Solbourne is just finishing a significant update that I'm trying to
get my hands on.) I consider OI's strongpoints to be:
1) Decoupling from Open Look and OSF/Motif look and feels
2) "True" C++ object-oriented implementation
If OI were available on more hardware platforms (which is important to us) and
were more agressively supported as a commercial binary product, it would
perhaps be of more interest to us for ongoing GUI development.
--------------------------------------------------------------------------
From: jk@acpy01 (John Kant )
Sun's OLIT is essentially a port of AT&T's Xt+ OPEN LOOK version to the
Sun platform, meaning that you are using C and the OPEN LOOK environment.
OI on the other hand is C++ orientated and uses both the OPEN LOOK and Motif
environments (although it does not give the OPEN LOOK or Motif widgets,
but rather it's own, but adequate, widget set). The current release of
OLIT on Sun is still '2-D' (version 2.0), the next release of OPEN LOOK
for AT&T and OLIT version for Sun, will be '3-D'. OI already comes with
the '3-D' look. No horror stories, both OLIT, OI and AT&T's OPEN LOOK
work just great!.
--------------------------------------------------------------------------
From ihlpa!mlgtw!mltga!djones
Working inside an AT&T company (AT&T Network Systems in the UK)
we had to make a similar decision. I was a bit confused at first
because OLIT provided with openwin on SUNs is in fact the USL OI
kit (sometimes knows as Xt+). For us the decision was between
the SUN Xview OpenLook toolkit and USL OpenLook Toolkit. On close
scrutiny we chose the USL Toolkit for the following reasons
Intrisics (Xt) based -- this means the resource file and resource
manager can be used. In the Xview toolkit most of the resources
have to be "hard-coded"
USL kit comes with SystemVR4 -- although our initial platform is
to be SUNs we may need to port our application to other platforms.
When we made our decision, we were unsure of how easy it would be to
get the Xview source (we do not have FTP access here) and so
assuming we would probably be targeted as "vanilla System V R4" systems
we thought the USL toolkit would be a better choice.
Performance -- Xview was written as a portability kit for sunview
applications to aid migration. I have heard it said ( but have no figures)
that the performance of the USL Xt kit is much better.