Thread View: comp.org.usenix
1 messages
1 total messages
Started by Jim Duncan
Tue, 19 Apr 1994 02:41
UPDATED ABSTRACTS: USENIX UNIX Applications Development Symposium
Author: Jim Duncan
Date: Tue, 19 Apr 1994 02:41
Date: Tue, 19 Apr 1994 02:41
612 lines
27535 bytes
27535 bytes
Here are the abstracts for all of the papers in the upcoming Applications
Development Symposium to be held in Toronto, Ontario, Canada, the week of
April 25-28, 1994. For more information, contact me or send mail to
<conference@usenix.org>.
Unlike my previous posting, this one is complete, and even includes notes
for the keynote address by Robert Adams and the invited talk by David
Tilbrook. The abstracts and notes are posted here in the same order as
they will be presented.
Jim Duncan, symposium co-chair
___________
KEYNOTE ADDRESS
Quelling Riots, Earthquakes, and Godzilla;
Porting SimCity to X11
Robert Adams, Dux Software
boba@dux.com
Robert Adams is President of Dux Software, Los Altos,
California, producers of X11 SimCity, the premier simulation of
city design; Xplot, a plotting package for Suns; Mobile Mail,
for accessing UNIX mail remotely from MicroSoft Windows; TaDah',
a business graphics and slide presentation package; and two
other games: Ishido and Solitaire Royale. Previously, he was
national sales manager for Frame Technologies, makers of a
well-known WYSIWYG editor, during their startup period.
He is a former NFL football player -- eight years with the
Steelers, Patriots, and 49ers -- a graduate of the University of
the Pacific, and national spokesperson and a member of the board
of directors of Narconon, the world's leading drug education and
rehabilitation program.
He will be discussing the various obstacles and issues that were
conquered during the several redesigns of the port of SimCity to
X11 on UNIX, with an emphasis on the windowing technologies.
***************
Wrapping DCE/OSF Client/Server Applications
Israel Gold and Uri Shani
Haifa Research Laboratory
IBM Israel Science and Technology
Matam -- Advanced Technology Center
Haifa 31905, Israel
E-mail: igold@vnet.ibm.com, shani@vnet.ibm.com
Abstract. DCE is a comprehensive RPC-based sol-
ution for client/server applications across net-
works of heterogeneous machines. Unfortunately,
DCE is hard to learn and use. The fact is, that
even simple DCE applications may have a rather
complicated structure, requiring a good under-
standing of the elaborate DCE technology. This
paper presents GLUEGEN -- an automatic tool for
"wrapping" plain C code to become part of a dis-
tributed application. The approach taken sepa-
rates DCE-specific from DCE-independent elements
of the application, via a high-level specification
language. This language provides an easy and
flexible way to describe the distributed applica-
tion topology, and frees the programmer from
having to get into the gory details of the DCE
run-time.
Using GLUEGEN, the development of simple DCE
applications remains a rather simple task, requir-
ing very little knowledge of DCE, and of the DCE
run-time. The tool is particularly useful for
splitting existing monolithic programs into
clients and servers, with almost no change to the
original application code. Complex DCE applica-
tions which do not neatly fit splitting are sup-
ported as well.
***************
Dagger: A Tool to Generate Program Graphs
Yih-Farn Chen
AT&T Bell Laboratories
600 Mountain Avenue
Murray Hill, NJ 07974
chen@research.att.com
Dagger is a tool that generates program graphs to selectively
visualize a software structure. The design of dagger achieves a
strong degree of language independence by exploiting the duality
between a class of entity-relationship databases and attributed
directed graphs. This paper describes the C and C++ versions of
dagger, which map a selected subset of relationships stored in a
program database to a graph specification, decorate the graph with
display attributes, and then pass it to layout tools or interactive
graph browsers. Dagger takes output from database queries to generate
a large variety of interesting program graphs, including header file
hierarchy, module binding, and type inheritance graphs. This paper
describes the graph generation process surrounding dagger and a sample
of tools involved in the process. In particular, we describe how a
closure operator works in tandem with dagger to control graph
complexity by generating reachability graphs where sub-structures are
selectively ignored or expanded. Our experience in applying dagger to
several software projects has demonstrated its capability in
abstracting and visualizing complex software structures without much
overhead. All program graphs presented in this paper are tagged with
timing statistics.
***************
Developing Applications with a UIMS
Daniel Klein
LoneWolf Systems
133 Lanford Drive
Pittsburgh PA 15235-1856
dvk@lonewolf.com
A User Interface Management System (UIMS) is a collection of programs
and libraries that enables an application to be partitioned into
functionally distinct component parts. This partitioning recognizes
that any application is comprised of three types of components, each
encompassing a separate domain of expertise. These are the application
domain, the display technology domain, and the user interface domain.
By separating the application into dialogue utilizing a collection of
agents, development time is reduced and maintainability is enhanced.
Because the dialogue views the agents as black boxes, the benefits of
parallel development and independent maintenance and upgrade are
realized. Display technology agents can be easily reused, enabling a
corporate look-and-feel. Further, an application agent can be reused
with different user interfaces, creating systems tailored to different
classes of users. We describe the general features of the Alpha UIMS,
and show how a complete application can be developed using such a User
Interface Management System.
***************
SPP - Low Tech, Practical, UNIX Software Portability
John Sellens -- jmsellens@uwaterloo.ca
University of Waterloo, Waterloo, Ontario, N2L 3G1 Canada
The great number of UNIX variants and the huge amount
of good, freely available software makes simple software
portability a very worthwhile and useful goal. Portability
has traditionally been obtained with software package specific
solutions, configuration scripts, #ifdef's and so on. This
paper describes SPP, a small collection of include files,
library routines and utilities that can be installed once and
utilized by many, different software packages. SPP does not
require that a software author change his or her programming
style or techniques, and frees the author from worrying
about the variations among machines, allowing him or her to
concentrate on the program instead of the operating system.
*********************
CREATING A CONFIGURABLE COMPILER DRIVER FOR SYSTEM V RELEASE 4
John F. Dooley
Vince Guarna
Motorola Computer Group
1101 E. University Avenue
Urbana, Illinois 61801
jdooley@urbana.mcd.mot.com
vguarna@urbana.mcd.mot.com
This paper discusses the design and application of
the configurable C compiler driver component of
System V Release 4. The configurable compiler
driver is a table-driven cc command that allows
users to define include file, library, and tool
paths as well as command line option translations
and defaults.
The configurable driver presents several
advantages over more traditional compiler drivers.
The resulting compilation system allows many
compilers with differing command line interfaces
to be used in large system builds with no makefile
changes. It allows the user to easily switch
among several different C compilers, while
presenting the user with a single command line
interface. By allowing changes to compiler
component paths, it makes the development of
cross-compilers easier. Finally, it allows easy
user configuration for the inclusion of default
options.
We discuss the motivation for the project, the
architectural design, and applications of the
driver, including experiences with using the
driver for System V Release 4 system builds.
*********************
Jam - Make(1) Redux
Christopher Seiwald
INGRES Corporation
Seiwald@Ingres.Com
March 11, 1994
Despite the progress of UNIX, the basic mechanism by which
developers build their programs - make(1) - has remained at
its core unimproved since its inception. Most notably, the
make language has seen few improvements. Jam is a make re-
placement that uses an extensible, expressive language for
describing ways in which files relate. This new language sim-
plifies the description of systems, both small and large, and
renders extending Jam's functionality not only possible but
easy.
Jam exists now and runs on many UNIX platforms, VMS, and NT.
It is freely available in the comp.sources.unix archives. As
proof of concept, it has been used to build a very large com-
mercial product, generating in a single invocation 1,000
deliverable files from 12,000 source files.
*******************
INVITED TALK
Church's Lemma and Funkenhauser's Rebuttal;
Designing a Model of the Software Process
David Tilbrook, Mortice Kern Systems
dt@mks.com
A statistic that should surprise few who worry about how software
is produced is that 85 percent of the D.O.D. suppliers who were
subjected to the S.E.I. Capability Maturity Model survey were
deemed to be level one, now called the ``Initial'' Level, but
previously more correctly called ``Chaotic''. Another useful
statistic is that 60 percent of the software acquired by the
D.O.D. is never deployed, primarily due to the software's failure
to meet the required needs. Finally, according to studies done by
big blue bean counters, 65 percent of the bugs in software are
introduced during bug fixing.
``Makes a fella proud to be a programmer'', does it not?
These hard statistics and hundreds of other undocumented and
documented failures to deliver effective software effectively lead
one to believe that ``professional programmer'' is an oxymoron.
Yes, indeed, this is yet another one of Tilbrook's harangues on
``there is no magic bullet, but ...''
There is no magic bullet but, by evaluating aspects of the
software process within an organization and making relatively
painless changes, big improvements can be attained.
The theme of this presentation is to examine and understand the
activities and processes that convert programmer efforts into
delivered product.
An abstract model of the software process is developed.
This model is then used to identify common failures and problem
areas.
Methods to determine the effectiveness of your organization's
process and its effectiveness are discussed.
Suggestions as to how to improve your process are given.
Finally the model is used to evaluate Church's Lemma and
Funkenhauser's Rebuttal.
*******************
Writing, Supporting, and Evaluating Tripwire:
A Publically Available Security Tool
Gene H. Kim* and Eugene H. Spafford
COAST Laboratory
Department of Computer Sciences
Purdue University
West Lafayette, IN 47907-1398
12 March 1994
Tripwire is an integrity checking program written for the Unix
environment that gives system administrators the ability to
monitor file systems for added, deleted, and modified files. First
released in November of 1992, Tripwire has undergone several
updates and is in current use at thousands of machines worldwide.
This paper begins with a brief overview of what Tripwire does
and how it works. We discuss how certain implementation
decisions affected the course of Tripwire development. We also
present other applications that have been found for Tripwire.
These unanticipated uses guided the demands of some users, and
we describe how we addressed some of these demands without
compromising the ability of Tripwire to serve as a useful security
tool.
We also discuss the process of releasing, and then supporting,
a widely available and widely used tool across the Internet, and
how meeting users' high expectations affects this process. How
these issues affected Tripwire, done as as an independent study by
an undergraduate, is also discussed. Software tools that were used
in developing and maintaining Tripwire are presented. Finally, we
discuss problems that remain unresolved and some possible
solutions.
(*)Gene Kim is currently at the University of Arizona.
***********************
Design, Distribution and Management of Object-Oriented Software
Arindam Banerji, David Cohn, Dinesh Kulkarni
Distributed Computing Research Laboratory
University of Notre Dame
Notre Dame, IN 46556
axb@cse.nd.edu
The promise of object-oriented software has been somewhat dimmed by the
continuing need for source code familiarity to realize the goals of
code-reuse and manageability. Software design has been hampered by the
infeasibility of predicting all possible circumstances of use. Composing
applications out of reusable components has remained a myth, primarily
due to limitations of the simplistic shared library model. This paper
proposes a three-pronged attack on these limitations of object-oriented
software in the context of C++. A flexibility framework which
facilitates the extension and modification of software without
recompilations or source-code familiarity is described. Partially
resolved loadable subclasses that may be distributed as reusable units
for type-safe application composition. Specific programming guidelines
which allow implementors to create software that may be fine-tuned at
run-time according to application characteristics is described. Thus,
the paper proposes a set of tools, techniques and guidelines that can
facilitate the construction of application frameworks.
*********************
Better Widget Design:
A Practitioner's Approach
Ed Lycklama, Vice President R&D, KL Group Inc.
260 King St. E, Third Floor,
Toronto, Ontario, Canada M5A 1K3
Ph: (416) 594-1026 x724
Email: eal@klg.com
Programming in Motif employs a powerful object-oriented concept
based on widgets. This paper discusses the Motif widget model,
showing how they are used and briefly discusses how to create a
new widget class. Issues involved in designing new high-quality
widget classes are discussed, drawing from the author's experience
in implementing several commercial Motif widgets.
*********************
Implementing A Generalized Drag-and-Drop in X
Cui-Qing Yang and Shrinand Desai
Department of Computer Science
University of North Texas
Denton, TX 76203-3886
cqyang@cs.unt.edu
Tel: (817) 565-2822
Abstract
Drag-and-drop operation is a well-recognized and widely
applied mechanism in the development of graphical user
interfaces (GUIs). Most of current approaches in design and
implementation of such a operation are limited to some
specific objects (such as icons or drag-and-drop widgets),
and are usually complex, system-dependent, and time-
consuming. This paper proposes a generalized semantic and
protocol for drag-and-drop that makes the draggable and
droppable as intrinsic properties of any GUI objects (just
like the colors and other appearance of an object) and
allows each object to customize its own semantic of drag-
and-drop. Therefore, the drag-and-drop feature is
integrated as an inherent part of a GUI window system and
all details and complexities of its implementation can be
hidden from end users. The framework of generalized drag-
and-drop could be applied to any GUI system. A prototype
implementation in the Xt Athena widget set of X11R5 on a
Unix system is reported in the paper.
******************
The Xt Intrinsics as a General Purpose
Application Development Platform
or
A User Interface Toolkit with Optional Users
Jordan M. Hayes
Heuristicrats Research, Inc.
jordan@Heuristicrat.COM
Charles A. Ocheret
Investment Management Services, Inc.
chuck@IMSI.COM
Many graphical user interface (GUI) toolkits provide an event-driven
framework which dispatches control to specific pieces of code based on
an event stream, such as mouse clicks or keystrokes. These toolkits
have incorporated utilities into their main loops for dealing with
synthetic timers, I/O multiplexing, and idle procedures. Other real
world problems fit this event-driven model quite well; database
servers, communications line handlers, and interpreter front ends, to
name a few. With only a few exceptions, weUve found the Xt Intrinsics
to be an ideal platform for building a distributed real-time market
data system, especially the non-GUI portions, despite the fact that
this toolkit was principally designed to be used as a GUI
toolkit. This paper describes our success with this approach and the
limitations we encountered.
******************
Bridging the Technology Generation Gap:
Upgrading a Network Management Application to a
New Technology Base
Jay S. Lark
Teknekron Communication Systems, Inc.
jlark@tcs.com
NMCS is a network management system which has been developed to manage
dedicated fractional-T1 networks, allowing end-users such as banks and
government agencies the ability to dynamically manage the allocation
of their dedicated communication facilities. The first version of NMCS
was delivered on a PC platform; it was a successful product but could
not adapt to meet new customer demands.
NMCS II is a significant upgrade to the first NMCS product. In
addition to extending its functional capabilities, NMCS II is built on
a different technology base from its predecessor: the hardware and
operating system, application architecture, user interface, and
database have all been upgraded to a new technology generation. It is
the most sophisticated application of its kind in commercial
deployment.
NMCS II is now installed and operational at several customer sites
throughout Canada. While the product has passed its formal acceptance,
a number of acceptability issues were present in its initial
release. Many of these issues derive from the changes to the
technology base, which we call the "technology generation gap."
This paper describes the NMCS II system at a high-level, and lists the
technology generations which changed in moving to NMCS II. It then
examines several of the acceptability issues which were raised by
customers, how these issues relate to the technology generation gap,
and how they are being addressed going forward. The paper concludes
with a discussion of lessons learned, in order to help others avoid
falling into the "gap" in the future.
******************
Porting and Maintaining with X and Motif:
A Retrospective View
by Paul Davey
User Interface Technologies Ltd.
17-21 Sturton Street
Cambridge
CB1 2SN
England
email: pd@uit.co.uk
In 1989 I accepted a job with IXI Ltd. in Cambridge, England, a small
software house specializing in the X Window System. The flagship
product, X.desktop, was then moving into its third major version
(2.0), the first based on Motif.
Initially IXI was establishing X.desktop, and the concept of desktop
software for Unix and X, but as time went the initial issues of rapid
portability and flexibility, were replaced by other factors as the
company, market and product all grew larger and more complex.
Maturing code, increasing numbers of programmers and staff turnover
all played their part in making the management of the ongoing project
more and more challenging. When overseeing the porting and maintenance
of X.desktop in 1992, I found myself dealing concurrently with three
major versions (2.0, 3.0 and 3.5), existing on over 30 platforms (with
more than 50 active configurations).
After successfully streamlining the porting and maintenance process I
was then asked to organize the Motif toolkit team along similar lines
in August 1993. This was subtlety different from the X.desktop work
since the code originated externally (from the Open Software
Foundation), and had to meet open as opposed to proprietary standards.
Keen competition in the market providing Motif development libraries
on Sun meant that high quality and ease of use was highly important.
As with X.desktop a rapid response to customer problems was another
important factor in keeping customers satisfied.
This talk will examine some of the lessons learned about the
development of multi-platform applications and toolkits over the
software life cycle of X.desktop. Some additional examples are taken
from the work porting and enhancing the Motif toolkit.
Although a premier X application X.desktop code was only partly X
based, much of it being either Unix system related or just plain data
manipulation. The uses (and abuses) of standard Unix software tools
such as yacc, lex and SCCS will be illustrated. The parallel
development of a problem and bug tracking systems will be described as
it resulted in the customized internal tool in use at the end of 1993.
****************
Software Design for Installability
Steve Simmons
Inland Sea
In classic software design, little or no con-
sideration is given to the issue of
installing the resulting package on the cus-
tomer machine(s). This is complicated by the
rich variety of administrative policies and
styles used in UNIX1 installations. This
paper will not attempt to prescribe a spe-
cific method for software installation.
Instead, it will focus on (a) issues which
make a package installable into highly cus-
tomized sites such that the package can be
installed with minimal disruption to both the
site and the package and (b) the reprogram-
ming of system configurations in a style
designed to minimize the impact of that
reprogramming.
****************
PANEL SESSION
"Are We Doing the Right Thing?"
Moderated by Dan Klein
Guaranteed to provoke an interesting discussion, a panel
of experts will consider if UNIX is the right platform for
application development or whether some other platform is
better.
Panelists to include Robert Adams and David Tilbrook.
--
Jim Duncan <jim@math.psu.edu> Penn State Math Dept Systems Administrator
"[A computer is] like an Old Testament god, with a lot of rules and no mercy."
Joseph Campbell
Thread Navigation
This is a paginated view of messages in the thread with full content displayed inline.
Messages are displayed in chronological order, with the original post highlighted in green.
Use pagination controls to navigate through all messages in large threads.
Back to All Threads