🚀 go-pugleaf

                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