Tech Insider					     Technology and Trends

			      USENET Archives

From: converse@EXPO.LCS.MIT.EDU (Donna Converse)
Subject: X Technical Conference, Jan. 23-25 1989
Message-ID: <8812162206.AA03774@EXPO.LCS.MIT.EDU>
Date: 16 Dec 88 22:06:51 GMT
Sender: daemon@bloom-beacon.MIT.EDU
Organization: X Consortium, MIT Laboratory for Computer Science
Lines: 623

  T H E   3 R D    A N N U A L   X   T E C H N I C A L   C O N F E R E N C E

The 3rd annual Technical Conference on the X Window System will be held
January 23-25 at MIT.  The conference is sponsored by the MIT X Consortium.
The purpose of the conference is to present and discuss leading edge research
and development in the X environment from both academia and industry.

The conference will consist of tutorials, presentations, and "Birds of a
Feather" sessions for general discussion of specific areas of interest.  There
will be no "trade show" attached to this conference.

The conference will be free, but registration is *required* in order to attend
tutorials and presentations.  All tutorials will be held Monday, January 23,
with presentations on Tuesday and Wednesday, January 24-25.

		       ~ P R E S E N T A T I O N S ~

			   Tuesday, January 24

      The Care and Feeding of Overlay Planes - A Religious Battle
		   Karen Bircsak, Sam Black, Ray Tice
		    Concurrent Computer Corporation

	There has been much discussion of late in the X community on how
to deal with graphics devices that have independent overlay planes.  The
two solutions that have been proposed have been to treat them as another
visual, or to treat them as another screen.  This paper will attempt to
discuss the pros and cons of each method, and arrive at a solution that
can become the standard way of dealing with overlay planes.


		Interactive Software Tools using X Widgets
		   Doug Blewett, Ken Hicks, Dat Nguyen
			  AT&T Bell Laboratories

	The Kernighan and Plauger books on constructing software tools
encouraged developers to think of programs in terms of filters.  Using a
collection of filter programs a developer can quickly construct new
applications.  Applications constructed in this manner exhibit a high
level of software reuse and the construction can be done interactively.
We describe how we have applied the software tools philosophy to writing X
widget applications.  Our examples include widgets manipulating color
scanned images.


	    The Inter-Client Communications Conventions Manual
		    David Rosenthal, Sun Microsystems

	At the last X conference the Inter-Client Communications
Conventions Manual, which describes how to write clients that co-exist
gracefully with others sharing the same server, was introduced.  In the
year since then the draft that went out with R2 has undergone an extensive
and detailed review process under the auspices of the Consortium.  A new
draft, with many changes, is being released for public review.  It will be
introduced, and the rationale for the changes provided.


	    Automatic Construction of User-Interface Displays
	       Paul Raveling, Larry Miller, and Yigal Arens
		    USC/Information Sciences Institute

	Construction of user interfaces for most computer applications
remains time consuming and difficult.  This is particularly true when the
user interface system must dynamically create displays integrating the use
of several interface modes.  The paper shows how artificial intelligence
knowledge base and rule technology can be used to address this problem,
and the presentation will include a discussion of X-related issues in
presentation planning and multi-modal input.


		   Why X is not our ideal window system
	 Joel McCormack, Hania Gajewska, Mark S. Manasse, DEC WSL

	We come to praise X, not to bury it, but the lack of perfection in
some points in the X11 protocol is plainly intolerable.  We hope to
encourage progress and reinterpretation in some areas in order to
establish a more perfect server.  We will present several instances of
shortcomings and awkwardnesses, including such problem areas as: unsigned
versus signed Dimensions, missing unviewability events, events without
timestamps, events without cursor positions, input focus redirection,
border and background inspection, inconsistencies in treatment of borders,
race conditions not cured by timestamps.


	     The Tektronix HVC (Hue-Value-Chroma) Color Model
	   Bob Toole, Al Tabayoyon, and Joann Taylor, Tektronix

	Tektronix HVC is a device independent color space based on human
color perception and the principles of CIE color spaces.  Its properties
facilitate precise color matching between CRT displays and other devices,
such as printers, and color selection and definition.  This presentation
will show how this color model can be incorporated into X to supplement
the current device dependent RGB color model.


			    X Terminal Issues
	    Dave Bundy or Mike Braca, Visual Technology, Inc.

	- Booting vs. ROM-based server
	- Initial connection
	- Font access 
	- Limited memory constraints
	- Local clients
	- Server extensions
	- Serial line communications
	- Benchmarking
	- Network loading

The object will be to lay out all the issues involved, as opposed
to presenting specific solutions.


			   The Graph Widget Set
	     Gabe Beged-Dov, Software Productivity Consortium

        The Graph Widget Set (GWS) is a set of R2 Intrinsics-based widgets
that support the display and editing of directed graphs. The current use
of the GWS is in the construction of interactive graph editors in the CASE
domain. The current editors are an Ada-oriented design tool and a
stochastic Petri editor. Both these editors are part of a larger CASE
toolset being developed by the Software Productivity Consortium.


			 Display PostScript and X
	   Susan Angebranndt, Phil Karlton, and Terry Weissman,
			Digital Equipment Company
		Jim Sandman, Ramin Betash and Ivor Durham
			       Adobe, Inc.

	This talk will describe the design and implementation of the
Display PostScript extension based on the X11 sample server.  Designing an
extension involves deciding on a wire protocol plus the appropriate DIX
and DDX interfaces.  It also requires determining the relationship of the
extension resources to X resources.  We'll discuss the trade-offs made in
the wire protocol and server implementation.  We'll show a video tape of a
version running almost completely on the DDX interface layer.


		    PEX (PHIGS/PHIGS+ Extension for X)
		    Marty Hess, Sun Microsystems, Inc.
		Dr. Spencer Thomas, University of Michigan

Dr. Spencer Thomas will speak on the work that was done for a SIGGRAPH '88
demonstration of PEX:

	During the summer of 1988, a demonstration implementation of PEX
was produced and shown at the SIGGRAPH '88 vendor exhibition.  The
implementation is described, illustrating solutions to some problems
induced by interoperability and portability requirements, and by the
extreme potential variability in the data presented by the client program.
The demonstration was successful, and the results are available on the X
V11R3 release tape.

Marty Hess will give a report on the current status of PEX and discuss the
PEX Sample Implementation Activity:

	An update on the status of PEX will be given.  Details about the
recently started activity to provide a sample implementation of PEX will
be covered.  Items that will be covered include a review of the results of
the PEX Sample Implementation (PEX-SI) activity to date, a description of
the planned contents and architecture of the SI, common terms used to
describe PEX and the SI, and a schedule of when and how the sample
implementation will be made available.

			  Wednesday, January 25

		Kee Hinckley, Open Software Foundation

	OSF will present a technical overview of its initial User
Environment Component Offering.


       Implementation of an Experimental Data Visualization System
	  Martin Schedlbauer, Marian Williams, Georges Grinstein
	   Graphics Research Lab, Dept. of CS, Univ. of Lowell

	We will describe a novel technique for visualizing
multi-dimensional data and report on the applicability of the X Window
System in implementing a highly interactive experimental visualization

			    The View2 Toolkit
		  Thomas W. R. Jacobs, Sun Microsystems

	The View2 Toolkit is an object-oriented user interface toolkit
designed for the X Window System version 11 (X11).  View2 is based upon a
mature toolkit named SunView.  View2 was redesigned and extended to take
advantage of the features that a networked window-system offers, while
still maintaining the flavor of SunView, and much of its Application
Programmer's Interface (API).  It was also transformed to provide the OPEN
LOOK Graphical User Interface.  Additionally, View2 is portable across
many versions of the UNIX operating-system.


      AT&T's OPEN LOOK Widget Set, The Story Behind its Development
		   Marcel Meth, AT&T Bell Laboratories

	AT&T has developed an Xt Based Widget set which supports the OPEN
LOOK Graphical User Interface (GUI).  The development of the OPEN LOOK
Widget Set presented a unique set of challenges.  We needed to provide a
toolkit that would support the OPEN LOOK GUI, as well as providing a
simple to use Application Programmer Interface (API).  Furthermore, we had
decided to implement the toolkit totally within the Xt framework.  The
goals behind our design were threefold, first the widget classes had to
provide high level functionality, second they had to provide application
writers with a simple and uniform way to create and manipulate widget
instances, and finally they had to work with the standard version of the

	The challenge behind this task was to keep the three goals aligned
as development progressed, and to periodically step back from the design
and revisit the design as well as the implementation.  Several examples of
these design and implementation decisions will be the focus of this talk.
The talk will also focus on performance improvements that were needed.


    Implementation of an X server on a pipelined display architecture
		   Michael Toy, Silicon Graphics, Inc.

I.   Very brief overview of SGI Display Architecture and  X implementation.
II.  Critique of SGI X Server
III. Analysis of common operations which do poorly on SGI machines
IV.  How to do these things fast on an SGI machine.
IV.  Proposed extensions for describing common operations at a high level


		  tV - A Network Transparent System for
	Interconnecting and Controlling Video Devices in Real Time
		Darren Leigh, Hewlett-Packard Laboratories

	Window systems, such as X, have enabled us to develop text and
graphical applications that are transparent to networked environments.  As
video technology becomes increasingly available in the computing
environment, we are going to see more applications which merge graphics
and text with real-time video.  Previously proposed models for merging
video and X have placed most of the video functionality into the X server.
We propose a more streamlined model that adds only the minimum necessary
functionality to the X server.

	Transparent Video (tV) is a separate server that provides an
application independant model for controlling specific devices (cameras,
recorders, effects boxes, etc.) as well as handling switching and routing.
The only video capabilities that need be implemented in the X server are
those which deal specifically with how the video is displayed and its
relation to the windows (clipping, hue and contrast control, etc.).

The presentation will cover:
	o The architecture of tV 
	o How tV interacts with X
	o Discussion of applications


	   ADEW - The Andrew Development Environment Workbench
	       Tom Neuendorffer, Carnegie Mellon University

	ADEW is a user interface management system designed to simplify
the creation of Andrew Toolkit applications, and for use in rapid
prototyping. It provides a extendable collection of widgets (buttons,
switches, thumbwheels, etc), tools for creating multi-media documents, and
a code generation program that takes care of the details of writing
dynamic objects. ADEW applications are created by copying components from
an object creation window (Arbcon), and pasting them into any desired
layout object. Once a prototype is thus created, a dynamically loadable
controller object can then be automatically generated and modified by the
user to create applications. ADEW has been distributed along with the
Andrew Toolkit.


		     An "XLib" for the Cedar Language
		       Christian Jacobi, Xerox PARC

	The Cedar language is a Mesa (Pascal) derivate.  It supports
separate modules, strong typing, compiler guaranteed runtime type safety
or read-only-ness, lightweight processes, exception mechanisms, and
garbage collection.  The Cedar environment runs in a shared address space
and allows dynamic loading of programs.  Each of these Cedar features has
substantial influence on how an "XLib" or a toolkit for Cedar should be
written.  Some features simply allow the interface to look simpler; other
features, like the lightweight processes, are a real challenge to
incorporate beneficially.  The use of a shared address space opens great
new possibilities like hidden and fast client-to-client communications bu
also opens the pandora box of gracefully cleaning up after terminating
windows or connections.  Since Cedar has been ported exclusively to
powerful workstations we tend to prefer caching over network traffic.
Finally, as a support for client debugging, we added watchdog features to
prevent deadlock through arbitrary grabs, at the same time still giving
the client programmer the illusion he had access to the complete reliable
stream protocol of the X Window System.


       Window Groups as an Extension to the Parent/Child Hierarchy
			 in the X11 Window System
	    Philip Gust, Multi-User Interface Project, HP Labs

	The parent/child hierarchies in X11 is inadequate to express a
number of useful relationships among windows.  Postits and drop shadows,
for example, are notoriously difficult to implement without requiring the
use of a special window manager to support them.  The purpose of this note
is to describe a useful relationship among windows called a 'group'.  Many
other user interface effects, some of which cannot be done using X, can be
expressed in terms of the group relationship.  We also suggest that in its
most general form, groups are a framework for describing even the existing
X capabilities in a more coherent way.


		     Implementing an X Server in Ada
		   Stu Lewin, Sanders Associates, Inc.

	Sanders is halfway through a two year project to implement an X
Window System server using the Ada programming language.  Our objectives
are to implement a production quality base windowing system suitable for
use in Ada-based real-time systems, and to examine Ada's applicability as
an implementation language for graphics software.  We currently have
running a partially-implemented server which dispatches on client
requests, performs basic windowing operations and executes basic graphics
functions.  This talk will explain why we chose to do an Ada
implementation, describe our implementation approach and server design,
relate a few lessons learned about using Ada in such an application, and
make some observations about using graphics processors with X.

		  ~ B I R D S   O F   A   F E A T H E R ~
If you are interested in sponsoring or co-sponsoring one of these BOFs,
send email to

Monday, January 23, 5:00 - 6:30 p.m.
	Image Processing and Display
	Documenting X Applications
	Xt-based Toolkits topics
	X & PCs	

Tuesday, January 24, 5:00 - 6:30 p.m.
	Window Managers, ICCCM, Session Managers
	X3D (PEX)
	Device Independent Color
	CLX and CLUE and CLOS

Tuesday, January 24, 8:30 - 10:00 pm
	XUG meeting

Wednesday, January 25, 4:00 - 5:30 p.m.
	End-User Applications
	Specification Languages & Tools for X-based User Interfaces
	Video (applications and server extensions)
	X & Ada	
	Server Implementors

		   ~ T U T O R I A L    P R O G R A M ~

All morning tutorials run concurrently.  All afternoon tutorials run
concurrently.  You may register for *one* morning tutorial and you may
register for *one* afternoon tutorial.   

	Choose one Morning 			Choose one Afternoon
	------------------			--------------------
	InterViews part 1			InterViews part 2
	Xlib part 1				Xlib part 2
	Andrew Toolkit part 1			Andrew Toolkit part 2
	Display PostScript part 1 		Display PostScript part 2
	Writing Widgets (novice)		Using Widgets (novice)
						Writing Widgets (advanced)

	    Programming User Interfaces in C++ with InterViews
		     Paul Calder, Stanford University

    In this tutorial we describe InterViews, a C++ toolkit for X that we have
developed at Stanford.  InterViews provides a true object-oriented programming
interface that supports the composition of interactive objects (such as scroll
bars and menus), text objects (such as words and whitespace), and graphics
objects (such as circles and polygons).  After a quick introduction to C++ and
InterViews basics, we will present three applications: a dialog box built from
interactive objects, a simple drawing editor using a hierarchy of graphical
objects, and a simple editor using a hierarchy of text objects.

    The morning session will cover C++, InterViews basics, and a simple
application.  Attendees should be familiar with C, X, and object-oriented
programming concepts.  Familiarity with C++ would be helpful, but is not

    The afternoon session will cover graphics and text applications in detail.
Attendees who are not at the morning session should be familiar with C++ and
basic InterViews concepts.


	Introduction to Programming the X Window System, Version 11
		    Oliver Jones, Apollo Computer, Inc.

    The proposed tutorial is at the Beginning level.  The X Window System is
a complex and comprehensive software package for controlling workstations.
Programmers, even those expert in computer graphics, must go up a substantial
learning curve in order to understand the issues and techniques involved in
designing and implementing application software to run on X Workstations.
This Beginning-level tutorial assumes no prior knowledge of X, and is intended
to shorten that learning curve.  This tutorial is for technical professionals
who are unfamiliar with Version 11 of the X Window System.  People preparing
to design and develop application software to run under X will find this
tutorial especially useful.  Attendees should be generally familiar with
graphics workstation technology and networks.  In addition, attendees should
be experienced with the C programming language.

    The purpose of this tutorial is to help turn X novices into reasonably
competent developers of X Window System application software.  The tutorial
addresses Xlib, the C language interface to X.  By covering low level X
requests, the tutorial lays the conceptual foundation for understanding and
applying the various high-level human interface toolkits and user interface
management systems available as layers on X.


	      The Andrew Toolkit (ATK): An Introduction
   Andrew J. Paley and Nathaniel S. Borenstein, Carnegie Mellon University

This tutorial is intended for experienced C programmers who know nothing
about programming with the Andrew Toolkit.  Some familiarity with the
concepts of object-oriented programming would be helpful, but is not
required.  The tutorial will explain enough about the ATK to allow such
people to begin serious application development using the ATK, if they are so
inclined.  Those with prior experience with the ATK are welcome to attend,
but should not expect extended discussion of advanced or esoteric ATK
features at this tutorial.

The Andrew Toolkit is a powerful set of tools for building complex user
interface programs in a window-system independent manner.  Besides providing
many basic building blocks for such interfaces, the ATK also provides
substantial facilities for object-oriented programming, which greatly
simplify the process of constructing new interfaces.  However, these
facilities require the programmer to approach his programs in ways that may
not be familiar to most C programmers.  In this tutorial, we will learn how
to use the Andrew Toolkit.  The primary emphasis will be on thinking like an
ATK programmer.  Within this conceptual framework, we will then study the
various components, or building blocks, that the ATK offers, and how they may
be put together to form complex applications.


			  Display PostScript
	      Adam Stock and Kim Stickney, Adobe Systems

The Display PostScript System(TM) is a graphics programming environment for
interactive displays based on the PostScript(R) programming language.  A
Display PostScript extension to X is being developed jointly by Adobe Systems
and Digital Equipment Corporation under the DECwindows(TM) program.

The PostScript language offers the developer a device and resolution
independent imaging model for addressing both color and black and white
displays and output devices.  It offers the end-user the same imaging model on
displays that is a standard on laser printers and typesetters for true WYSIWYG

This tutorial will cover what the application programmer needs to know to
write to the Display PostScript System.  The issues include the Display
PostScript extensions, the client library interface, and pswrap, a PostScript
to C preprocessor.

PostScript is the registered trademark of Adobe Systems.  Display PostScript
is a trademark of Adobe Systems.  DECwindows is a trademark of Digital
Equipment Corporation.


			    Using Widgets
	 Dany S. Guindi, SERC Georgia Institute of Technology

This tutorial will attempt to teach the experienced C programmer how to glue
together some of the existing widgets so as to create a user interface to an
application. It will be necessary to explore both the intrinsics as well as
the different widget sets available. The tutorial will use the Athena Widget
set for examples, but will also try to cover small examples from other widget
sets. This tutorial differs from the "Writing Widgets" tutorial in that we
will NOT attempt to explain how to expand the widget set nor how to slightly
modify existing widgets!


			  Writing Widgets (novice)
		Paul Asente, DEC Western Software Lab

This is an introduction to the Xt toolkit Intrinsics for would-be widget
writers.  We will go over complete implementations of three simple widgets,
label, pushbutton, and box, a simple composite widget.  Classing,
subclassing, inheritance, resources, and introductory translation
management will be covered.  Prerequisite: a basic familiarity with X11 and


			 Writing Widgets (advanced)
	  Ralph Swick and Mark Ackerman, MIT Project Athena

This covers more advanced topics in the Xt toolkit Intrinsics for widget
writers.  We will cover geometry management, constrained composite widgets,
resource converters, subresources, and advanced event handling.
Prerequisite: an understanding equivalent to that gained in the novice

		      ~ A C C O M M O D A T I O N S ~
Each person is responsible for making their own arrangements (this includes 
cancellations) and will be billed directly by the hotel.  Each individual 
should TELEPHONE THE HOTEL DIRECTLY and identify themselves as being part 
of the X WINDOW CONFERENCE*. ( Contacting the Hotels through the reservation 
telephone numbers listed below will allow you to obtain the proper conference
group rate.) 

NOTE: The hotels are listed in order of proximity to MIT's Kresge
Auditorium.   Kresge is the primary Conference building.

								  LAST DATE
--------------------------   --------------------   -----------   ------------

HYATT REGENCY		     10 min walk to Kresge  Single/       JAN. 2
575 Memorial Dr		     Free shuttle service   Double $95
Cambridge, MA		     to Kresge
617-492-1234 extension 201
PARKING: $8/night
Facilities at the Hyatt include a 75ft pool, 
health club, Jonah's Seafood Restaurant, 
and Sally Lings Chinese Resaurant.

BOSTON MARRIOTT/CAMBRIDGE    15 min walk thru 	    Single $95    JAN. 8
Two Cambridge Center	     campus to Kresge	    Double $105
Cambridge, MA
PARKING: $10/night

ROYAL SONESTA*		     25-30 min walk to 	    Single/       JAN. 3
5 Cambridge Pkwy	     Kresge. Free shuttle   Double $95
Cambridge, MA		     service to Kresge
*When reserving a room at the Royal Sonesta, state that you are reserving
under the conference block number (or group code) G7047 .  

listed above will be handled on a space and rate available basis. 

	     ~ C O N F E R E N C E   R E G I S T R A T I O N ~
Register FOR THE CONFERENCE by returning a completed registration form (See
registration form below).  Registration received without the required
information or sent to the wrong address has a high probability of being
completely ignored.  Registration will be on a first-come-first-serve basis;
if we cannot accommodate your request, you will be informed as soon as
possible.  RECEIPT WILL BE ACKNOWLEDGED within two weeks.

We would PREFER you to register for the conference via the network address:

If necessary, one can register by sending a completed copy of the 
registration form to our postal address:
	Michelle Leger
	MIT Laboratory for Computer Science
	545 Technology Square, Rm 217
	Cambridge, MA  02139
or, *only* if you do not have a network address, by sending a copy to
our FAX# (617-258-8682). 

ACCOMMODATION RESERVATIONS. (see the accommodation listings above for the
proper hotel reservation telephone numbers.)

If you specify > 1 tutorial for the morning or the afternoon, or if you 
fail to give your name, you will certainly NOT be registered.
--------cut here------------------------------------------------------------

	    3rd Annual X Technical Conference Registration Form
		   send to

Network address:
Morning Tutorial:
Afternoon Tutorial:
Postal Address:
Top 3 BOF choices:

			        About USENET

USENET (Users’ Network) was a bulletin board shared among many computer
systems around the world. USENET was a logical network, sitting on top
of several physical networks, among them UUCP, BLICN, BERKNET, X.25, and
the ARPANET. Sites on USENET included many universities, private companies
and research organizations. See USENET Archives.

		       SCO Files Lawsuit Against IBM

March 7, 2003 - The SCO Group filed legal action against IBM in the State 
Court of Utah for trade secrets misappropriation, tortious interference, 
unfair competition and breach of contract. The complaint alleges that IBM 
made concentrated efforts to improperly destroy the economic value of 
UNIX, particularly UNIX on Intel, to benefit IBM's Linux services 
business. See SCO v IBM.

The materials and information included in this website may only be used
for purposes such as criticism, review, private study, scholarship, or

Electronic mail:			       WorldWideWeb: