NetNews Usenet Archive 1992 #27/NN_1992_27.iso/spool/comp/org/usenix/1035

Internet Message Format | 1992-11-22 | 51.5 KB

Xref: sparky comp.org.usenix:1035 comp.org.sug:479 comp.org.uniforum:86 comp.org.acm:963 comp.org.ieee:561 comp.os.misc:923 comp.misc:4379 comp.unix.admin:6341
Path: sparky!uunet!usenix!carolyn
From: [e-mail] (Carolyn Carr)
Newsgroups: comp.org.usenix,comp.org.sug,comp.org.uniforum,comp.org.acm,comp.org.ieee,comp.os.misc,comp.misc,comp.unix.admin
Subject: USENIX Winter 1993 Technical Conference - Tutorial Program
Keywords: USENIX Association
Message-ID: <[e-mail]>
Date: 23 Nov 92 18:57:39 GMT
Organization: Usenix Association Office, Berkeley
Lines: 1174


                USENIX WINTER 1993 TECHNICAL CONFERENCE

                      SAN DIEGO, CALIFORNIA

 TUTORIAL PROGRAM: JANUARY 25 AND 26, 1993 -  MONDAY AND TUESDAY

The USENIX Association's well-respected tutorial program
offers you introductory as well as advanced, intensive yet
practical tutorials.  Courses are presented by skilled teachers
who are hands-on experts in their topic areas.  The USENIX
tutorial program has been developed to meet the needs of an
audience of computer professionals and technical managers.

Attend the tutorials at San Diego and benefit from this
opportunity for in-depth exploration and skill development in
essential areas of UNIX-related technology.  Combining the
two-day tutorial program with the three days of technical
sessions means you have the opportunity to learn from an
expert at a convenient time and at a reasonable cost.

The USENIX tutorial program continues to experience high
demand for its offerings.  Pre-registration is strongly
recommended.  Several tutorials sell out before pre-
registration closes.  On-site registration is possible ONLY if
space permits.

Special Note for Full-Time Students
Your Immediate Attention is Requested!
A limited amount of space in each tutorial has been reserved
for full-time students at a special fee.

MONDAY, JANUARY 25
9:00 AM - 5:00 PM (INCLUDES BOX LUNCH)

M1 - ESSENTIAL UNIX PROGRAMMING
M2 - OSF's DISTRIBUTED COMPUTING ENVIRONMENT
M3 - USING, MANAGING, AND IMPLEMENTING NFS
M4 - OSF/1 INTERNALS
M5 - PROGRAMMING WITH THE X WINDOW SYSTEM
M6 - SYMMETRIC MULTIPROCESSING AND CACHING IN UNIX
KERNELS
M7 - SVR4 INTERNALS  PART 1 P THE VFS AND PROCESS
SUBSYSTEMS
M8 - TOPICS IN UNIX SYSTEM SECURITY
M9 - ESSENTIALS OF PRACTICAL PERL PROGRAMMING
M10 - Topics in Advanced System Administration, 1993


FIRST TIME OFFERED!
M1
ESSENTIAL UNIX PROGRAMMING
Richard Stevens, Consultant

Intended Audience:  Programmers and system administrators
who want to learn more about the essentials of UNIX
programming.  Some programming experience in C is assumed.

This tutorial covers current UNIX programming concepts
required for systems programming.  It does not cover the
familiar basic functions (open(), lseek(), standard I/O, etc.),
rather it focuses on the poorly documented features that tend
to be least understood.  Current standards such as POSIX are
mentioned, however, the tutorial focuses on two real-world
implementations of the various standards: 4.4BSD and System
V Release 4.

The topics covered are: current UNIX standards, process control
(race conditions, sessions, job control), signals (POSIX.1 signal
handling, unreliable signals, interrupted system calls), record
locking, I/O multiplexing (select and poll), memory mapped
I/O, interprocess communication (comparison of various
methods), stream pipes, passing file descriptors, and pseudo
terminals.

Richard Stevens is author of the books Advanced Programming
in the UNIX Environment (1992) and UNIX Network Programming
(1990).  He received his Ph.D. in the area of image processing
from the University of Arizona.  From 1982 until 1990 he was
Vice-President of Research and Development with Health
Systems International.  Currently he is an author and
independent consultant residing in Tucson, Arizona.

FIRST TIME OFFERED!
M2
OSF's DISTRIBUTED COMPUTING ENVIRONMENT
David Chappell, Chappell and Associates

Intended Audience:  Those who need an introduction to DCE,
including those who must develop applications for, support,
market, plan for, or write about DCE or distributed systems in
general.  A general knowledge of networking fundamentals is
assumed.  Some background in a high-level programming
language will be helpful, but is not required.

Distributed Computing Environment was created by the Open
Software Foundation as a vendor-neutral infrastructure for
distributed computing. Running over any transport protocol,
DCE provides solutions for the key problems in creating
distributed systems.

The goal of this tutorial  is to give participants an
understanding of what services DCE provides and how.  The
tutorial introduces DCE via a description of each of its
component technologies, including:

%    a protocol for remote procedure call;
%    directory services;
%    a distributed file service; and
%    protocols for network security.

David Chappell is principal of Chappell & Associates, a training
and consulting firm focused on vendor-neutral networking.  He
has written and taught many courses on distributed computing
and related topics to clients in North America and Europe, and
has served as a consultant on numerous communications
projects.  Among his current projects, David is a consultant to
OSF involved with OSF's Distributed Computing Environment
and Distributed Management Environment.  His previous
experience includes software engineering positions with NCR
Corporation and Cray Research.  David holds an M.S. in Computer
Science from the University of Wisconsin-Madison.

M3
USING, MANAGING, AND IMPLEMENTING NFS
Ralph Droms, Bucknell University

Intended Audience:  Well-suited to anyone who is designing or
specifying products that use NFS, managing networks that use
NFS, or seeking to understand the principles underlying the NFS
technology.

Sun Microsystem's Network File System* allows application
programs running on one machine to access files on remote
machines as if they were stored locally. Because NFS is an
open Internet standard protocol, it has been implemented on a
wide variety of hardware and software platforms. Sites can
use NFS to integrate computing systems from many different
vendors into a single distributed computing environment.

This tutorial will describe the technology and the
implementation of NFS from the viewpoint of the user, the
system administrator and the implementor.  Upon completion,
the attendee will be familiar with the basic components of
NFS, the concepts that underlie the design, and the impact of
NFS.  The attendee will understand how RPC and XDR are used
to implement NFS and how RPC and XDR can be used in other
distributed applications.

NFS is just one example of a distributed file system. Other
notable examples include Transarc's AFS, AT&T's RFS and
FTAM.  This tutorial will also provide an overview of these and
other distributed file systems to describe the design space in
which the designers must engineer these systems.

Ralph Droms is an associate professor of Computer Science at
Bucknell University. He is an active researcher in the areas of
file naming, remote file access and Internet communication
protocols.  As part of his research, he implemented the Tilde
file naming scheme using NFS as the remote file access
mechanism.  He is chairman of the Internet Engineering Task
Force Working Group on mobile host name and address binding
and a member of the Resource Discovery Internet Research
Group.  Professor Droms is also an editor of Internetworking:
Research and Experience.  Professor Droms holds a Ph.D. in
Computer Science from Purdue University.

M4
OSF/1 INTERNALS
Thomas W. Doeppner, Jr., Brown University

Intended Audience:  Individuals involved with porting or
supporting the OSF/1 operating system as well as those who
are simply interested in what the OSF/1 kernel is all about.  It
assumes a general knowledge of how UNIX systems are
organized and some previous exposure to UNIX internals (such
as a USENIX tutorial on UNIX internals).

OSF/1 is based on technology derived from Mach, Berkeley
UNIX, and others.  This tutorial will cover the most recent
release of OSF/1: Release 1.1.  It will discuss as well the
research versions of OSF/1 (OSF/1 MK and OSF/1 AD), in which
the UNIX functionality is provided by user-level processes
running on top of a Mach 3.0 microkernel.

This course will provide an overview of how the system is
organized.  It will then focus on the following areas:

%    Process model
        Multithreaded processes
        Multiprocessor support
        Scheduling
%    Virtual memory
        Address space representation
        Paging techniques
%    File System
        RVirtual File SystemS architecture
        Parallelization of the file system
%    Streams
        A new implementation of streams
        Transparent parallelization of streams components
%    OSF/1 MK and OSF/1 AD
        UNIX as a user-level application
        OSF/1 on a multicomputer

Thomas W. Doeppner, Jr. received his Ph.D. in Computer Science
from Princeton University.  He has been on the faculty at
Brown University since 1976. His research interests are in
operating systems and parallel programming. He has lectured
extensively on UNIX internals over the past seven years for the
Institute for Advanced Professional Studies and he authored
the multi-day OSF/1 internals course offered by OSF.

M5
PROGRAMMING WITH THE X WINDOW SYSTEM
Oliver Jones, PictureTel Corporation

Intended Audience:  Software developers and others interested
in UNIX-based graphical user interfaces who are beginning the
process of learning to program using the X Window System.  A
working knowledge of UNIX and the C programming language are
the only prerequisites.

This course will cover the fundamental mechanisms provided
by MIT's X Window System.  After completing this course,
attendees should be able to develop simple applications in X.
More importantly, attendees will learn enough of X to make
sense of the X Toolkit, OPEN LOOK, OSF/Motif and other higher-
level software for developing graphical user interfaces.

The course will emphasize software design considerations,
especially those which relate to the dogma, RMechanism, not
Policy.S  We will discuss how to exploit the various features
of X, and why they work the way they do.

The tutorial will examine the "how" and "why" of the following
parts of X:

%    Network connections
%    Windows or screen real-estate
%    Graphics
%    Exposures
%    Text
%    Color
%    Images
%    The X Protocol
%    X Events, solicitation and handling
%    Mouse and Keyboard input
%    Inter-application communication

Oliver Jones has been teaching the X Window System for
several years.  He is the author of Introduction to the X Window
System (1989), a textbook on the subject.  He is professionally
involved with the development of X-based user interfaces for
programming environments.

M6
SYMMETRIC MULTIPROCESSING AND CACHING IN UNIX KERNELS
Curt Schimmel, Silicon Graphics, Inc.

Intended Audience:  System programmers with 6 months or
more of UNIX kernel internals experience. It is ideal for those
who will be porting the UNIX kernel to a modern computer
architecture, those involved in the design of new computer
architectures that need to support UNIX, or anyone who wants
to learn more about operating systems and modern computer
architectures.

This intensive tutorial will examine the issues involved with
porting the UNIX operating system to modern computer
architectures. Attendees will gain an understanding of the
design considerations modern architectures present to the
operating system and will gain insight into the design of new
architectures intended to support the UNIX operating system.
Examples of modern RISC processors and the computer systems
built around them are used to illustrate the concepts.

In the first section of the tutorial we will investigate the
effects of various cache memory systems on the UNIX kernel.
An overview of cache system architecture will be presented.
Then four cache organizations which range from pure virtual to
pure physical caches are studied, including the tradeoffs of
each, their impact on the kernel, and how to modify the kernel
to control the cache properly.

The second section will explore tightly coupled, symmetric
multiprocessors.  This includes a discussion of mutual
exclusion, synchronization, race conditions, and deadlock
problems as they apply to the UNIX kernel.  Several strategies
for adapting the UNIX kernel to run on a multiprocessor are
then presented, ranging from master/slave to multithreaded
semaphore techniques, along with the tradeoffs of each
approach.

Building upon the first two, the third section will examine
cache consistency in a multiprocessor system.  Problems of
cache consistency and their effects on the kernel are
investigated, followed by discussion of both hardware and
software cache consistency algorithms for different cache
organizations and multiprocessor kernel implementations.

The final section will address the differences between RISC
Memory Management Units and more traditional style MMU's.
This includes Translation Lookaside Buffer (TLB) management,
referenced and modified bit handling, and TLB flushing and
replacement techniques.  Emphasis is placed on the effects on
the kernel and the algorithmic changes needed.

This tutorial has been previously offered by the USENIX Association
with the title
RUNIX on Modern Architectures.S

Curt Schimmel is an Operating System Architect at Silicon
Graphics Inc.  He received his M.S. in Computer Science from
the Rensselaer Polytechnic Institute.  He has worked in many
areas of UNIX kernel development and computer architecture on
systems ranging from microprocessors to multiprocessor
supercomputers.  He has worked extensively in the areas of
multiprocessor systems, virtual memory, real-time, process
management, and the design of new CPU and cache system
architectures.

M7
SYSTEM V RELEASE 4.0 INTERNALS PART 1 P THE VFS AND
PROCESS SUBSYSTEMS
George Bittner and Steve Rago, ProLogic  Corporation

Intended Audience:  People who maintain, modify, or port the
UNIX system or who are interested in learning about its
internals.  Attendees should have a good working knowledge of
UNIX applications programming and the C language.  Those with
knowledge of UNIX internals will particularly benefit from the
focus on new features.

This course will present a broad view of system internals and
highlight those aspects of the system that are new to System
V Release 4.0.  Topics will include a discussion of system
goals and design principles, the system call interface, and
kernel subsystems.

Part I will concentrate on the following subsystems:

The Virtual File System (VFS) P provides an object-oriented
interface to heterogeneous file systems that may be
conventional disk, remote file systems, or may contain objects
vastly different from the traditional notion of file.  We will
present the VFS interface and its instantiation in real file
systems, especially the mechanisms involved in reading and
writing files.

Processes P The process model will be discussed, including
reliable signals, POSIX job control, session management, and
configurable real-time and time-sharing schedulers.

George Bittner is a Principal Member of Technical Staff at
ProLogic., where his work involves networking performance
improvements to System V.  As a consultant to IBM, he worked
to increase performance of NFS and other TCP/IP applications
on various experimental networks connecting workstation and
mainframe AIX systems.  Earlier, he was a Member of Technical
Staff at UNIX System Laboratories, doing kernel development
work on Remote File Sharing and other components of System
V, Release 4.0 and system engineering work toward future
releases.  As USL's representative to the POSIX P1003.8
committee, he helped architect the group's proposed standard
for distributed file systems.  George holds a M.S. degree in
Computer Science from the University of Connecticut.

Steve Rago is currently a Principal Member of Technical Staff
at ProLogic Corporation.  His current interests include network
performance improvements and new file system types.  Before
joining ProLogic, Steve was a Member of Technical Staff at
AT&T Bell Laboratories, where he worked on the development
of the STREAMS subsystem in UNIX System V Release 4.  His
post-SVR4 work included multiprocessor enhancements to
STREAMS, design of a new multithreaded kernel memory
allocator, and defining the multithreaded driver-kernel
interfaces.  Steve received  a M.S. degree in computer science
from Stevens Institute of Technology.  He has taught courses
on STREAM internals.

M8
TOPICS IN UNIX SYSTEM SECURITY
Instructor:    Matt Bishop, Dartmouth College

Intended Audience:  System administrators, system
programmers, and others who are interested in exploring some
topics of UNIX security in depth

This tutorial will examine three areas of security critical to
the functioning of UNIX systems:

User authentication provides the first line of defense against
attackers attempting to penetrate the system.  Among topics
to be discussed are how to crack passwords, including a
presentation of the way that most fast crypt(3)
implementations work, and how to defend against password
cracking.  Pitfalls of using a proactive password checker to
test proposed passwords for RguessabilityS or of having the
computer generate passwords will be discussed, as will the
use of an existing proactive password checker.  The
management of password files to avoid problems, the use of
shadow password files, and some of the complexities
introduced by them will also be analyzed.

The second topic area is management of privileges.  We will
discuss managing access to a superuser account, methods of
managing the superuser account to reduce need for its use, the
use of a program that implements group accounts, and the
writing of safe setuid  programs. (Implementation of the group
account program offers an example of the writing of safe
setuid  programs).  Following a quick review of basic security
practices against malicious logic and an overview of the
workings of the Internet worm of November 1988, we will
discuss techniques for detecting malicious logic and blocking
its effects.  The limitations of these techniques will be made
clear, so no false sense of security is given.

The third topic area, networking, will cover the security
mechanisms available in NIS, NFS, and, more briefly, in
privacy-enhanced electronic mail and Kerberos.  The Berkeley
Rtrusted hostsS mechanism will be described, as will Secure
RPC and the network daemons and calls used by Berkeley's
implementation of rlogin, rsh, and TCP/IP.  Finally, we will
discuss the security of both Honey DanBer and 4.3 BSD UUCP.

Matt Bishop has been working on issues of security in UNIX
since 1980.  After graduating from Purdue University, he
worked at the Research Institute for Advanced Computer
Science at NASA where he specialized in computer security.
Currently he is at Dartmouth College teaching operating
systems, computer security, cryptography, and software
engineering.  He is a member of the Privacy and Security
Research Group, which studies issues related to security on
the Internet.  He has chaired the last two USENIX Association
UNIX Security Workshops.

M9
ESSENTIALS OF PRACTICAL PERL PROGRAMMING
Tom Christiansen, CONVEX Computer Corporation

Intended Audience:  Users, programmers, and administrators
who find themselves writing short- and medium-length
programs or scripts, particularly in heterogeneous
environments.  Attendees should be familiar with regular
expressions (as in sed, vi, or grep) and a procedure-oriented
programming language such as C.

Attendees will learn to write basic Perl programs and to read
moderately complex ones.  Attendees will also understand the
tasks for which Perl is particularly well suited.

This tutorial differs from USENIX's previously offered
tutorials in Perl Programming in that its focus will be on the
essential points rather than the more advanced and esoteric
aspects. This tutorial will include many coding examples.

Perl is a publicly available and highly portable interpreted
programming language whose syntax and features resemble C
combined with the best parts of sh, csh, sed, awk, and several
other powerful UNIX tools.  Perl is rich enough for many
general programming problems since its execution is efficient
and its power is expressive enough to tackle many day-to-day
tasks.  Many sites have already begun using Perl for their
system management scripts.  Perl programs are often clearer
and cleaner than equivalent shell scripts and are usually more
efficient.

Topics of this tutorial will include a detailed description of
the syntax and semantics of Perl, its data types, operators,
control flow, regular expressions, and I/O facilities.  The
tutorial will discuss debugging strategies, issues of style,
efficiency, and traps and pitfalls of the language.  Complete
programs and numerous smaller examples are provided and
reviewed.

Tom Christiansen earned  a M.S. in Computer Science from the
University of Wisconsin at Madison.  In 1987 he joined CONVEX
Computer Corporation where his duties have included customer
support, training, systems administration, UNIX utilities and
kernel development, C2 security, and creation of software
tools.  Tom has been teaching courses in UNIX programming and
systems administration for 9 years.

FIRST TIME OFFERED!
M10
TOPICS IN ADVANCED SYSTEM ADMINISTRATION, 1993
Trent Hein, XOR Computer Systems, Rob Kolstad, Berkeley Software
Design, Inc., and Evi Nemeth, University of Colorado, Boulder

Intended Audience:  System administrators who have a year or
more experience and wish to learn state-of-the-art
information within the broad area of administration.

The 1993 RTopics in Advanced System AdministrationS
tutorial will include the following new topics:

%    Organization of filesystem hierarchies for big shops
The organization of a filesystem hierarchy can ease or
complicate the placement of multiple binaries, shared root
images, and commercial packages.  This session will
explain some of the issues and present one solution to the
layout problem.
%    Quick configuration & installation of workstations
Cloning workstation configurations is one way for quick and
easy configuration and installation.  This session will
discuss easy cloning methods and cite some of the features
and drawbacks.
%    Accounting
Process, login, and other accounting is almost a lost art at
many UNIX sites.  We will discuss the raw programs and
presents some perl scripts for summaries.
%    rdist, track
Updating of large sets of distributed files (e.g., system
programs) is much easier when using programs like rdist.
The problems and some solutions will be considered.
%    Source Tree Management for multiple architectures
Laying out the source trees for multiple architectures makes a
big differences in the maintenance costs.  We will address
the issues and offer some solutions.
%    Daemons for having non-root admins
Evi Nemeth's sudo program is one example of a program which
hands out super-user privileges to non-privileged users.
This section will explore the theory and implementation of
these kinds of programs.
%    Trouble management systems
Trouble management systems track problems that users
encounter.  This session will discuss criteria for using
them and name some available solutions.
%    Previewers
Previewing troff and other text processing output can save
tremendous amounts of paper.  This sesson will discuss
some of the available troff previewers and WYSIWYG
editors.
%    Console concentrators
Console concentrators enable one sysadmin to monitor many
different computers.  This session will discuss them and
their implementation.
%    NNTP
NNTP enables users to access a single repository of news from
any of a set of networked computers.  This session will
discuss the program and its installation and configuration.
%    Maintaining large mail gateways
Problems encountered with large mail gateways will be
discussed and solved.
%    Privacy of E-Mail
E-Mail privacy is an issue that continues to gain attention in
many different venues.  Here we will consider the issues
and offer some insight.

Trent Hein is a consultant with XOR Computer Systems, a
Colorado-based firm specializing in network engineering and
system administration.  He is a card-carrying member of the
System Administration mafia from the University of Colorado.
In the past, he spent a summer with CSRG at Berkeley.  Trent
has taught a number of tutorials at past USENIX conferences.
He holds a B.S. in Computer Science.

Dr. Rob Kolstad teaches system management in a wide set of
venues in addition to writing the Daemons & Dragons column
for Unix Review.  He is past-Secretary of the USENIX
association and editor of its newsletter, ;login:.  Rob currently
manages the software development program at Berkeley
Software Design, Inc., a startup company marketing operating
systems based on the work of Berkeley's Computer Systems
Research Group.

Dr. Evi Nemeth, teaches Computer Science at the University of
Colorado, Boulder, and has managed UNIX systems for the past
15 years.  She is co-author of the best-selling UNIX System
Administration Handbook (1989) and has taught numerous
system administration tutorials. She is a member of the Board
of Directors of USENIX.

TUESDAY, JANUARY 26
9:00 AM - 5:00 PM (INCLUDES BOX LUNCH)

T1 - UNIX NETWORK PROGRAMMING
T2 - OSFUS DISTRIBUTED MANAGEMENT ENVIRONMENT
T3 - DISTRIBUTED FILE SYSTEM ADMINISTRATION WITH DCE/DFS
T4 - 4.4BSD KERNEL INTERNALS
T5 - TCL AND TK
T6 - MICRO-KERNEL TECHNOLOGY
T7 - SVR4 INTERNALS  PART 2 P THE VM AND I/O SUBSYSTEMS
T8 - NETWORK SECURITY
T9 - INTRODUCTION TO THREADS AND THREADS PROGRAMMING
T10 (1/2 day) - MORE Topics in Advanced System
Administration
T11 (1/2 day) - Managing the Domain Name System


T1
UNIX NETWORK PROGRAMMING
Richard Stevens, Consultant

Intended Audience:  UNIX/C programmers interested in learning
how to write programs that communicate across a network.  A
basic familiarity with networking concepts and the TCP/IP
protocols is assumed.

The goal of the tutorial is to provide the programmer with the
knowledge required to write network programs and to develop
and examine actual examples.

The tutorial will cover the following material:
%    Introduction (5%).  The big picture, standards, UNIX process
handling,connections and associations.
%    Berkeley sockets (80%).  All the socket functions, TCP and
UDP client-server examples, reserved ports, stream pipes,
passing file descriptors, multiplexed I/O, out-of-band data,
raw sockets (ping and traceroute programs), broadcasting,
inetd  superserver, constructing Internet addresses, and
possible socket changes with 4.4BSD.
%    Remote procedure calls (15%).  Sun RPC, comparison with
HP/Apollo RPC.

Richard Stevens is author of the books Advanced Programming
in the UNIX Environment (1992) and  UNIX Network
Programming (1990).  He received his Ph.D. in the area of image
processing from the University of Arizona.  From 1982 until
1990 he was Vice-President of Research and Development with
Health Systems International.  Currently he is an author and
independent consultant residing in Tucson, Arizona.

FIRST TIME OFFERED!
T2
OSFUS DISTRIBUTED MANAGEMENT ENVIRONMENT
David Chappell, Chappell and Associates

Intended Audience:  Anyone needing an introduction to DME,
including those who must one day use, support, develop
applications for, market, plan for, or write about DME.  The
tutorial assumes a general knowledge of networking
fundamentals.  Some background in systems and/or network
management and in DCE will be helpful but is not required.

Distributed Management Environment will be the next
technology released by the Open Software Foundation.  Intended
to provide a vendor-neutral solution for managing distributed
environments, it addresses a broad range of related problems.

The goal of the tutorial is to give participants an
understanding of what DME will include when it is released by
OSF in late 1993.  This tutorial will provide an overview of
DME and an introduction to its component technologies.

Among the technologies included in DME and described in the
tutorial are:

%    a traditional framework for management applications,
based on SNMP and CMIP;
%    an object-oriented framework for management
applications, based on the Object Management Group's
Common Object Request Broker Architecture;
%    a network print service;
%    a network license service; and
%    services for distributing and installing software in a
networked environment.

David Chappell is principal of Chappell & Associates, a training
and consulting firm focused on vendor-neutral networking.  He
has written and taught many courses on distributed computing
and related topics to clients in North America and Europe, and
has served as a consultant on numerous communications
projects.  Among his current projects, David is a consultant to
OSF involved with OSF's Distributed Computing Environment
and Distributed Management Environment.  His previous
experience includes software engineering positions with NCR
Corporation and Cray Research.  David holds an M.S. in Computer
Science from the University of Wisconsin-Madison.

T3
DISTRIBUTED FILE SYSTEM ADMINISTRATION WITH DCE/DFS
Phil Hirsch, Transarc Corporation

Intended Audience: UNIX system administrators who are
interested in the management and administrative aspects of
the DCE Distributed File Service.  Prior exposure to distributed
computing concepts would be helpful but is not strictly
necessary.

DCE/DFS is the Distributed File Service component of the OSF's
Distributed Computing Environment.  It provides a uniform
global namespace for the files which it holds, allows files and
system databases to be replicated for load balancing and high
availability, and includes a fast-restarting log-based physical
file system for use on server machines.  Because of the
uniform namespace, replication techniques, aggressive caching
on DFS client machines, and the capabilities of the DCE
Security Service, DFS provides a scalable, secure distributed
file system that presents users with the familiar semantics of
a UNIX filesystem.

This tutorial will examine DFS from a system administrator's
perspective and, to a lesser extent, from a user's perspective.
Since DFS is a Rtop-levelS component of the DCE, it relies on
several other DCE components to provide lower-level services.
Relevant interactions between DFS and these other DCE
modules will be discussed throughout the tutorial, although
the main focus is on administration of DFS.  The tutorial will
begin with a discussion of distributed computing in general,
followed by an overview of the DCE.  Next, the overall
architecture of DFS is examined.

The remainder of the tutorial will be devoted to detailed
descriptions of the administrative features of DFS, including
privileged users and groups, administrative domains, access
control lists, configuration and operation of DFS client and
server machines, fileset manipulation and replication, and the
backup system.

Phil Hirsch is an instructor in the Technical Training
Department at Transarc Corporation. He designed a course on
DCE Application Programming which he currently teaches.
Prior to joining the Training Department, Mr. Hirsch was a
member of the Testing/Quality Assurance group for DCE DFS at
Transarc. He has 9 years experience in UNIX programming and
system administration.  Mr. Hirsch holds a M.S. degree  in
Applied Mathematics from Virginia Tech.

FIRST TIME OFFERED!
T4
4.4BSD KERNEL INTERNALS
Marshall Kirk McKusick, University of California, Berkeley and
Michael J. Karels, Berkeley Software Design,
Inc.

Intended Audience:  Systems programmers who have taken a
course on 4.3BSD internals or who have had at least a year of
experience working on the 4.3BSD kernel or BSD-derived
kernels such as SunOS, System V Release 4, or Ultrix.  No
source license is required.

This tutorial is a major update of the previous USENIX
Association tutorial, R4.4BSD Preview: Kernel Internals.S  It
will present an overview of the kernel architecture of 4.4BSD
and provide a detailed description of the changes in the kernel
structure since the 4.3BSD-Reno distribution and the Second
BSD Networking release.  The major changes in the kernel are:
the replacement of the virtual memory system with one
derived from Mach; a structural reorganization of the per-
process data structures; and structural changes in the
filesystem layers.  In addition, a number of system interface
changes have been made.  Most of these changes are in the
recent 4.4BSD Alpha release.

The tutorial will begin with an overview of the kernel
subsystems and organization.  The kernel layering is described,
along with an overview of the internal interfaces.  System
interface changes are also summarized.

The virtual filesystem interface has been changed to allow
filesystem stacking and unioning and for the expansion of the
operations vectors of individual filesystems.  We will describe
how these mechanisms work and provide examples of stackable
components such as the umap filesystem that provides uid/gid
mapping for filesystems mounted from sites outside the local
password domain. The fast filesystem has been split into data-
storage independent semantics (name lookup, rename, mkdir,
rmdir, etc) and a flat filesystem store (allocate, deallocate,
grow, shrink). We will give a brief overview of the three file-
store strategies: traditional fast filesystem, log-structured
filesystem, and memory-based filesystem.

The 4.4BSD virtual memory system is derived from the Mach
virtual memory system but has several architectural
differences including a BSD mmap interface.  We will describe
the layering of the VM system, including the data structures
for an address space, a VM object, and the page cache.

The new BSD process management is substantially different
than previous systems.  The tutorial will detail the new
process structure and its substructures, which allow greater
flexibility and sharing across processes.  They directly support
the POSIX session and process model. The user structure has
nearly vanished and is no longer known as the "u-dot.''

A description of the machine-dependent code, which has been
reorganized for greater portability, will be included.  A new
machine-independent autoconfiguration framework allows
additional flexibility and supports a machine-independent SCSI
layer.

Dr. McKusick received a Ph.D. in the area of programming
languages from the University of California, Berkeley.  While
at Berkeley he implemented the 4.2BSD fast file system and
was involved in implementing the Berkeley Pascal system.  He
currently is the Research Computer Scientist at the Berkeley
Computer Systems Research Group, continuing the development
of future versions of Berkeley UNIX.  He is a past President of
the USENIX Association and a member of ACM and IEEE.

Michael J. Karels is the System Architect at Berkeley Software
Design, Inc.  He spent eight years as the Principal Programmer
of the Computer Systems Research Group at the University of
California, Berkeley, as the system architect for 4.3BSD.
Michael Karels received his B.S. in Microbiology at the
University of Notre Dame.  He is a member of the ACM, the IEEE,
the Internet Engineering Task force and several POSIX working
groups.

McKusick and Karels are co-authors of the book The Design and
Implementation of the 4.3BSD UNIX Operating System (1989).

FIRST TIME OFFERED!
T5
TCL AND TK: A NEW APPROACH TO X11 AND GUI PROGRAMMING
John Ousterhout, University of California, Berkeley

Intended Audience:  People who would like to learn how to
write scripts for existing applications built with Tcl and Tk or
who would like to build new graphical-user-interface
applications based on Tcl and Tk.  Prior experience with Tcl
and Tk nor any X toolkit is not necessary.  Attendees should be
familiar with the C programming language and should have
basic knowledge about the X Window System.

Creating graphical user interfaces for the X Window System
with traditional tools requires you to read thousands of pages
of documentation and write thousands of lines of code.  Tcl (a
shell-like scripting language) and Tk (an X11 toolkit and Motif-
like widget set based on Tcl) offer an alternative.  With Tcl
and Tk, you program GUI applications in a high-level scripting
language with a much simpler model of the X world.
Applications can be built with less learning time and an order
of magnitude less code than with other toolkits.  The Tcl
language is interpretive so you can also program and extend
applications at run-time.  Different applications can issue Tcl
commands to each other in order to work together in
interesting ways.  This gives Tcl and Tk great power and
flexibility.  Lastly, you can extend the facilities of Tcl and Tk
by writing C code where it is needed, so there is no loss of
functionality or performance.

The course will provide a complete Rtop to bottomS
introduction to Tcl and Tk.  First, we will provide an overview
of Tcl and Tk and the benefits they provide.  Then, we will
describe the Tcl scripting language in detail, including its
syntax and the most commonly used commands.  The third
section of the course will discuss how to program the Tk
toolkit using Tcl scripts.  It will cover the major features
provided by Tk, including widgets, geometry managers, and
communication between applications.  Following, we will
describe how to write C code that interfaces to Tcl, and in
particular how to build new Tcl commands with C procedures.
The last part will describe how to build new widgets and
geometry managers by writing C code that interfaces to Tk.
The course will offer numerous examples of scripts and C
programs to illustrate the capabilities of the system.

John Ousterhout is a Professor in the Department of Electrical
Engineering and Computer Sciences at the University of
California , Berkeley, and the author of both Tcl and Tk.  His
interests include user interfaces, operating systems, and
distributed systems.  Ousterhout is a recipient of the ACM
Grace Murray Hopper Award, the National Science Foundation
Presidential Young Investigator Award, the National Academy
of Sciences Award for Initiatives in Research, the IEEE
Browder J. Thompson Award, and the U.C. Berkeley
Distinguished Teaching Award.  He received a Ph.D. in Computer
Science from Carnegie Mellon University.

FIRST TIME OFFERED!
T6
MICRO-KERNEL TECHNOLOGY
Lori Grob and Marc Rozier, Chorus systemes

Intended Audience:  People who are interested in learning about
microkernels and distributed systems technology.  A prior
knowledge of distributed systems or of UNIX internals Is not
assumed, though a minimal knowledge of UNIX and operating
system concepts is.

Topics will include:

%Introduction
    Motivation underlying Micro-Kernels
    Influential Micro-Kernel Projects (e.g. Mach, Chorus, V,
Ameoba, ...)
%Basic Concepts and Terms
    Resource Encapsulation
    Execution
    Scheduling:  real-time; synchronization
    Communication
    Memory Management
%Examples from Chorus, Mach, Ameoba and V
%Subsystems: What do the users see?
    UNIX Subsystems
        Mach/OSF:  monoprocessor; multiprocessor
        Chorus/MiX (V3.2,V4.0)
        Examples
    V
    Amoeba
    Benefits
    Costs
%Object Oriented Subsystems
%Influential Newcomers P NT
%Summary

Lori Grob has been with Chorus systmes since 1989.  She is a
senior system engineer and the Manager of Technical Support,
Training and Tutorials.  She was Co-Chair of the 1988 USENIX
Workshop on UNIX and Supercomputers, Program Chair of the
1991 Winter USENIX Technical Conference, and Program Chair
of the 1992 USENIX Workshop on Microkernels and Other Kernel
Architectures.

Marc Rozier is the head of the CHORUS distributed micro-kernel
development team within Chorus systmes.  He joined INRIA in
1982 as a researcher in the CHORUS distributed operating
system project. He worked on both the design and
implementation of two versions of CHORUS.  In 1987, he became
one of the founders of Chorus systmes.

Both Ms. Grob and Mr. Rozier have extensive teaching
experience before and at Chorus systmes, where they
frequently teach CHORUS tutorials.

T7
SYSTEM V RELEASE 4.0 INTERNALS PART 2 P THE VM AND I/O
SUBSYSTEMS
Steve Rago and George Bittner, ProLogic Corporation

Intended Audience:  People who maintain, modify, or port the
UNIX system or who are interested in learning about its
internals with a focus on new features.  Part 1 (M7) on Monday
is not prerequisite for Part 2.  Attendees should have a good
working knowledge of UNIX applications programming and the C
language.

This course will present a broad view of system internals and
highlights those aspects of the system that are new to System
V Release 4.  Topics will include a discussion of system goals
and design principles, the system call interface, and kernel
subsystems.  Part II will concentrate on the following
subsystems:

The Virtual Memory (VM) subsystem P unifies the handling of
main memory and backing store, supplementing traditional,
file-oriented I/O with memory-mapped, fault-driven
interfaces.  We will present the VM interface and
implementation, along with examples of its use in the kernel
and at user-level.

I/O P The block and character I/O subsystems will be
discussed, including the buffer cache, device access via the
SPECFS internal file system, and the STREAMS subsystem.  The
STREAMS subsystem provides a unified environment for the
development of modular character device drivers.  As such, it
is the framework on which all network services are built in
SVR4.

Steve Rago is currently a Principal Member of Technical Staff
at ProLogic Corporation.  His current interests include network
performance improvements and new file system types.  Before
joining ProLogic, Steve was a Member of Technical Staff at
AT&T Bell Laboratories, where he worked on the development
of the STREAMS subsystem in UNIX System V Release 4.  His
post-SVR4 work included multiprocessor enhancements to
STREAMS, design of a new multithreaded kernel memory
allocator, and defining the multithreaded driver-kernel
interfaces.  Steve received  a M.S. degree in computer science
from Stevens Institute of Technology.  He has taught courses
on STREAM internals.

George Bittner is a Principal Member of Technical Staff at
ProLogic., where his work involves networking performance
improvements to System V.  As a consultant to IBM, he worked
to increase performance of NFS and other TCP/IP applications
on various experimental networks connecting workstation and
mainframe AIX systems.  Earlier, he was a Member of Technical
Staff at UNIX System Laboratories, doing kernel development
work on Remote File Sharing and other components of System
V, Release 4.0 and system engineering work toward future
releases.  As USL's representative to the POSIX P1003.8
committee, he helped architect the group's proposed standard
for distributed file systems.  George holds an M.S. degree in
Computer Science from the University of Connecticut.

T8
NETWORK SECURITY: THE KERBEROS APPROACH
Dan Geer, Geer Zolot Associates and Jon A. Rochlis, MIT

Intended Audience:  Systems developers responsible for
networked workstation environments, particularly those
whose environments include networks which are not physically
secure (i.e. Ropen networksS), systems administrators
concerned about the inherent lack of security and
accountability in conventional UNIX network environments, and
technical managers in enterprises where the accountable flow
of electronic information is the core of that enterprise.

We will focus on the challenges of providing security for the
cooperative electronic workplace, ones that aspire to location
and scale independence in the client-server idiom.   We will
begin by describing network security from a general point of
view, including the kinds of threats which result from
operating in an open environment.  We will then describe
effective approaches to meeting these threats, moving from
the theoretical to the practical.  We will focus on the Kerberos
network security system developed at MIT, as well as
providing in-depth treatment of public-key techniques, the
X.509 authentication model and the Internet's Privacy Enhanced
Mail (PEM).  Kerberos is the core of the Open Software
Foundation's Distributed Computing Environment (OSF/DCE),
and we will thoroughly discuss the DCE extensions and
enhancements to Kerberos that made it into the de facto
standard for network security.  We will close with the nuts-
and-bolts of administration and integration of this technology
with existing environments.

Daniel E. Geer, Jr., recently a member of the Technical Staff of
Digital Equipment CorporationUs External Research Program, is
now at Geer Zolot Associates.  For the previous 5 years, he was
the Manager of Systems Development for MITUs Project Athena
where he oversaw the creation of the Athena distributed
computing environment, including the work that forms the
basis for this tutorial. He holds a Sc.D. in Biostatistics from
Harvard University.

Jon A. Rochlis is a Technical Supervisor for MIT Distributed
Computing and Network Services which runs MITnet and the
Athena computing environment (including its Kerberos realm).
Previously he worked on development of the Amber and Multics
operating systems.  Mr. Rochlis received his B.S. in Computer
Science and Engineering from MIT.

T9
INTRODUCTION TO THREADS AND THREADS PROGRAMMING
Nawaf Bitar, Kubota Pacific Computer

Intended Audience:  Developers interested in learning about
threads, particularly those who know what a thread is but do
not necessarily understand the threads models they may have
come across.  Developers working with the evolving POSIX
pthreads standard, both at the application and implementation
levels, will also benefit.

Multiple threads of control within a process can be effectively
used to express parallelism inherent in many applications and
environments such as window systems and networked or
distributed systems.  On multiprocessor architectures they
also provide for concurrent execution.  The tutorial will begin
with a brief introduction to threads and the circumstances
under which they are useful.  Discussion of popular threads
models will follow.  In particular, the Rlight-weightS and
Rvariable-weightS process models will be covered as part of a
discussion on parallelism granularity.  The tutorial will then
cover various threads implementation architectures P user
space, kernel, and multiplexed (two-level schedulers) P as used
in DEC CMA, OSF/1, and Solaris 2.0.

The tutorial will continue with a presentation of threads
programming techniques including master/slave, client/server
and workcrew models.  Short example programs will be
presented in order to ensure that the models are well
understood.  Next will be a presentation of the POSIX 1003.4a
pthreads interface and the issues at the interface level when
introducing threads to UNIX.  Problems that arise when fork()
and signals are used in the presence of threads will be
discussed in detail.

A discussion of how fine-grain parallelism can be supported
will conclude the tutorial.  This support is required primarily
by compilers that wish to perform automatic parallel
decomposition of programs.  An indication as to why the
pthreads interface is inadequate for this support, the required
characteristics of an implementation supporting fine-grain
parallelism, and a new compiler-visible interface and
implementation architecture will be offered.

Nawaf Bitar is a Member of the Technical Staff at Kubota
Pacific Computer.  He is currently working on developing a
threads model and implementation suitable for applications
requiring very fine grain parallelism granularity.  Prior to
joining KPC he worked on Mach-based systems at HP, OSF and
Apollo.

T10 P 1/2 day:  9 am P 12:30 pm (includes lunch at 12:30 pm)
MORE TOPICS IN ADVANCED SYSTEM ADMINISTRATION
Trent Hein, XOR Computer Systems, Rob Kolstad, Berkeley
Software Design, Inc., and Evi Nemeth,
University of Colorado, Boulder

Intended Audience:  System administrators who have a year or
more experience and wish to learn state-of-the-art
information within the broad area of administration.

This tutorial will cover the following topics:

%    Automounters
Larger shops can spend far too much time reconfiguring their
mount tables unless they use automounters.  This session
will motivate the design for automounters and show you
how to use them effectively.
%    Free Software
Acquiring freely redistributable software is one of the
mainstays of survival in the systems administration
world.  We will discuss how to find it and list some of the
more useful packages available.
%    IDA Sendmail
Configuring sendmail is easy with IDA sendmail.  This session
will discuss its acquisition (it's free) and how to use it.
%    Ethics
System administration does not have the long history that,
say, the medical profession enjoys.  Administrators
encouter ethical problems with regularity.  We discuss
some of the events that happen and how to deal with them.

Trent Hein is a consultant with XOR Computer Systems, a
Colorado-based firm specializing in network engineering and
system administration.  He is a card-carrying member of the
System Administration mafia from the University of Colorado.
In the past, he spent a summer with CSRG at Berkeley.  Trent
has taught a number of tutorials at past USENIX conferences.
He holds a B.S. in Computer Science.

Dr. Rob Kolstad teaches system management in a wide set of
venues in addition to writing the Daemons & Dragons column
for Unix Review.  He is past-Secretary of the USENIX
association and editor of its newsletter, ;login:.  Rob currently
manages the software development program at Berkeley
Software Design, Inc., a startup company marketing operating
systems based on the work of Berkeley's Computer Systems
Research Group.

Dr. Evi Nemeth, teaches Computer Science at the University of
Colorado, Boulder, and has managed UNIX systems for the past
15 years.  She is co-author of the best-selling UNIX System
Administration Handbook (1989) and has taught numerous
system administration tutorials. She is a member of the Board
of Directors of USENIX.

T11 P 1/2 day:  1:30 pm - 5 pm (includes lunch at 12:30 pm)
MANAGING THE DOMAIN NAME SYSTEM
William LeFebvre, Northwestern University

Intended Audience:  Internet network managers who need to
grasp the intricacies of managing the Domain Name System
(DNS). Those who attend should have a basic understanding of
Internet Protocols and a user's understanding of DNS.
Attendees should also be familiar with number bases, bits,
bytes, and machine representations of integers, but need not be
sophisticated programmers.

This half-day tutorial will explain how to administer the
Internet Domain Name System on a UNIX machine.  It will detail
the operation of named and the resolver library, primary and
secondary servers, the format of DNS zone files, installation
of the entire bind package, and configuration and control of the
named daemon.  Time will be made for a question-and-answer
session.

William LeFebvre received his  M.S., from Rice University.  He
is currently the manager and analyst for the computing
facilities of the Electrical Engineering and Computer Science
Department at Northwestern University.  William serves as a
director for the Sun User Group.  He is also well known in the
network community for moderating the electronic digest Sun-
Spots from 1987 to 1989, and for founding the electronic
mailing list Sun-managers (which he still maintains).

USENIX Tutorial Review Committee

Dan Geer, Geer Zolot Associates
Lori Grob, Chorus systmes
Peter Honeyman, CITI, University of Michigan
David Taylor, SunWorld Magazine

Daniel V. Klein, Tutorial Coordinator, USENIX
Ellie Young, Executive Director, USENIX