USENIX tutorials aim to provide the critical information you need.
Delivered by experts with hands-on experience, tutorials are practical, intensive, and essential to your professional development.
Our guarantee: If you feel a tutorial does not meet the high standards you have come to expect from USENIX, let us know by the first break and we will either change you to any available tutorial immediately or arrange for you to attend another tutorial at another USENIX event without paying
another fee.
Register now to guarantee your first choice. Seating is limited.
M1am Designing Concurrent Object-Oriented Programs in Java (Part 1)
David Holmes, Microsoft Research Institute, Macquarie University;
Doug Lea, SUNY Oswego
Who should attend: Anyone involved, or planning to get involved, in the development of concurrent OO applications. Basic familiarity with the Java is a prerequisite.
Concurrent programming has mostly been the domain of systems
programmers rather than application developers. Concurrent
object-oriented programming has seen a resurgence recently, due mainly
to the widespread acceptance of the Java programming language. Java's
support for concurrent programming has enticed many developers to try
their hand at concurrent applications. Yet the use of concurrency
within a Java application poses many traps for the unwary.
This tutorial demonstrates various design patterns and techniques for
constructing concurrent object-oriented applications in Java and for
managing that concurrency in an effective way. On the language side we
look at what Java provides to support concurrent programming. On the
design side we look at object structures and design rules that can
successfully resolve the competing forces (safety, liveness, efficiency,
coordination, reusability) present in concurrent software design
problems.
This morning tutorial includes:
- Java concurrency mechanisms and classes (threads, locks, monitors)
- Design for multithreaded safety and liveness
- Locking, containment, controlling access and mutability
- Examples from selected Java library components
- Designing and implementing state dependent actions (waiting, notification, exceptions, retries)
- Dealing with Java scheduling and run-time properties (creating your own notification-based constructions)
Although focusing on Java, most of the patterns and techniques
discussed are applicable in other language environments. For
those interested in Java, you will get a detailed working knowledge of its concurrency mechanisms. More broadly, you will be exposed to a variety of design strategies for managing concurrency within applications.
M2am Understanding COM and MTS
David Chappell, Chappell & Associates
Who should attend: Architects and developers familiar with
general object-oriented design and programming techniques and who need to understand the basics of these key Microsoft technologies. Knowledge of a specific programming language, such as C++, is not required - this is not a programming course.
The Component Object Model (COM), introduced in 1993, has become fundamental to software development in the Windows and Windows NT environment. More recently, the COM-based Microsoft Transaction Server (MTS) has been released. MTS supports the creation of scalable, transaction-oriented servers by combining the relatively new notion of component software with familiar concepts from transaction processing monitors.
This tutorial provides an introduction to COM and MTS, with an emphasis
on MTS. The topics will include:
- Defining COM: Interfaces, classes, life cycle, and more
- How MTS adds automatic support for transactions to COM
- How MTS adds scalability to COM servers
- Comparing MTS components and Enterprise JavaBeans
M3am Building Distributed CORBA Applications In C++
Steve Vinoski, IONA Technologies, Inc.
Who should attend: Experienced C++ developers who want to understand the fundamentals of CORBA-based programming in C++ to develop practical distributed object systems. A good understanding of C++ is required, but no CORBA experience is necessary.
This tutorial provides the basics that developers need to begin writing
industrial-strength systems based on CORBA technology.
You will learn about the basics of the Object Management
Group's (OMG) Object Management Architecture (OMA), and the fundamentals of the CORBA component of the OMA. C++ examples will demonstrate how to develop simple clients and servers
based on static stubs and skeletons. All server examples in the
tutorial are based on the new Portable Object Adapter (POA) recently
added to CORBA. Details concerning use of the Dynamic
Invocation Interface (DII) are provided.
The second half of the tutorial introduces a number of
CORBA services, including Naming, Events, and Trading, and through the
use of more C++ examples, shows how they can be used in real
applications. The tutorial concludes with a brief description
of some of the other work currently in progress within the OMG.
This tutorial presents a significant amount of working C++ code, along with detailed handouts that afterwards can serve as a CORBA C++
programming reference.
M4pm Designing Concurrent Object-Oriented Programs in Java (Part 2)
David Holmes, Microsoft Research Institute, Macquarie University;
Doug Lea, SUNY Oswego
This is a continuation of the tutorial M1am. You may also take this tutorial if you have equivalent concurrent Java programming experience.
This afternoon tutorial covers:
- Introducing concurrency into Java applications (Threads, message passing, cancellation)
- Concurrent application architectures (DataFlow, demand-driven services, groups)
- Abstracting concurrency control into reusable support classes
- (Locks, conditions, channels)
- Documenting concurrent components and programs (Guidelines, checklists)
M5pm Designing with Patterns
John Vlissides, IBM Research
Who should attend: Software developers, architects, and programmers.
You should be well-grounded in object technology and should
be familiar with the design patterns in Design Patterns: Elements
of Reusable Object-Oriented Software by Gamma, et al.
Design patterns are making the transition from curiosity to
familiarity. Now that many people know what they are, they want
to knowhow best to apply them. You will learn how to
leverage patterns in the software design process and the
thinking behind pattern application---including when not to use a
seemingly applicable pattern. You will learn how the right patterns can
improve a design and how the wrong patterns can degrade one, allowing
you to apply design patterns to maximum benefit.
You will gain experience in learning how to apply design patterns to your own OO systems, solving real problems.
Topics covered include:
- Designing a file system
- Structure
- Symbolic links
- Open-ended functionality
- Single-user protection
- Multi-user protection
- Notification
- Summary, observations, references
M6pm Distributed COM and MTS: The Programming Model, the Protocol and the Runtime Architecture
Don Box, DevelopMentor
Who should attend: Developers of distributed object systems who need to understand how COM and MTS work and why. David Chappell's tutorial (M2am) is recommended but not strictly necessary.
The goal of this tutorial is to demystify many of the common misconceptions surrounding COM and MTS by examining the core service model of the COM and MTS runtime architecture.
This session offers an intensive view of the COM and MTS programming
models from a developer's perspective. Topics will include the
core semantics of COM and MTS, COM/MTS architectural overview,
interface-based development, COM and MTS activation models, advanced
lifecycle management, concurrency under COM and MTS, the role of
context, security, the impact of transactions on state management. There will also be a discussion of future extensions to the COM/MTS architecture namely, COM+.
T1am Framework and Component Modeling for Java with UML Catalysis
Desmond F. D'Souza, Icon Computing, Inc.
Who should attend: Programmers using or intending to use patterns, component-based design, UML or Fusion, and who are seeking clearly defined techniques of models, composition, and refinement; programmers looking for design methods suited for newer languages like Java. You should be familiar with Java, with object modeling and programming, and design patterns as defined by Gamma et al. Familiarity with OO language
features vs. abstract system models is a plus.
OO design is about the division and delegation of responsibilities, and the specification of collaboration patterns between objects, from the system/use-case level down to code. Frameworks are
themselves compositions of partial collaborations, and using frameworks
is greatly aided by a clear description of the underlying collaboration
patterns. Java offers some unique support for higher-level models and
design, including interfaces, packages, reflection, and the
composition-friendly component model of Java Beans.
This tutorial describes advanced techniques to effectively model and design Java components and frameworks. It is not just another UML tutorial
Serious modeling and composition of Java components and frameworks in
the UML is not trivial. In this tutorial, you will learn about a set of modeling tools with precise notions of interface, type, class, collaboration, role, frameworks, package, and composition, from the UML-based Catalysis method. The instructor will use these to capture key aspects of design patterns, frameworks, and components in a way which is both abstract and precise. For more information on the Catalysis method, see
http://www.iconcomp.com/catalysis
Topics will include:
- Interfaces as types
- Type modeling
- Collaborations as design patterns
- Specifying properties and events
- Components and composition
- Component architectures
- Packages in Modeling and Java
- Refinement in Modeling and Java
- Frameworks
T2am Distributed Computing with Java Remote Method Invocation
Jim Waldo and Ann Wollrath, Sun Microsystems, Inc.
Who should attend: Programmers and developers who understand the basics of programming in Java and have some familiarity with distributed systems.
One of the major enhancements added to Java at the 1.1 release is the Remote Method Invocation (RMI) facility. RMI allows calls to be made between Java objects in different virtual machines, perhaps on different physical machines. Unlike most previous distributed computing infrastructures, RMI was designed to be language-centric. This allows RMI programming to be done entirely in Java, utilizing such language features as the rich Java type system and garbage collection. Coupled with the code portability of the Java platform, this language specificity simplifies distributed programming and also allows the passing of objects by value as well as by reference.
This tutorial will introduce the design of RMI, show how to build distributed applications using the facility, and discuss the new functions being added to the system in the next release of the JDK. The tutorial will be about evenly divided between theory and practice, and will include discussions of the garbage collection mechanisms, code loading and polymorphism in distributed systems as well as working through a number of examples of actual code implementing RMI-based distributed programs.
You will gain an understanding of the basic mechanisms used in Java RMI, why the system was designed the way it was, and the new features to expect in JDK1.2. At the end of the tutorial, you should be able to design your own RMI-based applications.
T3am High Performance C++ Programming
Scott Meyers, Software Development Consultant
Who should attend: Systems designers, programmers, and technical managers involved in the design, implementation, and maintenance of production libraries and applications using C++. Participants should already know the basic features of C++ (e.g., classes, inheritance, virtual functions, templates), but expertise is not required. Whether you have learned C++ recently or have been programming in C++ for some time, you will come away from this seminar with useful, practical, proven information. Recommended reading: much of the material in this seminar is taken from Scott's books, Effective C++ and More Effective C++.
This tutorial will give you a detailed examination of the factors that
affect the performance of C++ software. Whether your primary concern is
high system speed, small system size, fast recompilation, or a combination
of these, you will get the information necessary to come up with C++ software systems that offer maximum performance.
The reasons for bottlenecks in C++ programs can be surprising. Contrary to popular belief, virtual functions usually exact a negligible performance
cost, while unexpected calls to constructors and destructors frequently
hamstring applications. In this tutorial, you will learn what is really
important if you want to deliver high performance, and you will take away
the techniques you need to achieve it.
Topics covered include the following:
- General approaches to efficiency:
- Choosing suitable algorithms and data structures
- The 80-20 rule and program profiling
- Lazy evaluation and reference counting
- Prefetching and caching
- Strategies specific to C++:
- Avoiding superfluous calls to constructors and destructors
- Eliminating unnecessary temporary objects
- Facilitating the return value optimization
- Mastering inlining
- Minimizing compilation dependencies
T4pm Java/RMI, DCOM, and CORBA Interworking
Keith Moore, Hewlett-Packard Laboratories
Who should attend: Systems integrators trying to compare COM and CORBA technologies or faced with the challenge of building scalable heterogeneous systems out of a mixture of COM and CORBA components. Familiarity with C++ and OO programming is assumed. Attendees should be familiar at least one remote object invocation system (e.g., COM/ActiveX, CORBA, or Java RMI).
While the popular press may enjoy writing about the Object Wars
system integrators are faced with the issue of how to build systems
out of these disparate components, particularly in systems that
span heterogeneous platforms. This tutorial focuses on the
interworking between two distributed object models: OMG CORBA and
Microsoft COM/ActiveX.
Although these systems have many similarities, they differ principally
in their notions of object identity, type system expressiveness,
interface composition and navigation, and their intrinsic services
(such as object life cycle, security and transactions). In this tutorial,
you will learn details of the OMG COM/CORBA interworking specification. Examples will show the COM/Automation view of CORBA objects as well as the CORBA view of COM/Automation objects. By the end of the tutorial, you should be able to map concepts from one object
system to the other and have a good understanding of what will map well
(and what doesn't) when building systems out of COM and CORBA components.
T5pm Three Cool Things in C++
Scott Meyers, Software Development Consultant
Who should attend: Systems designers and software developers involved in the design, implementation, and maintenance of challenging applications using C++. Participants should be quite comfortable with the fundamental features of C++ (e.g., classes, inheritance, virtual functions, templates), but
expertise is not required.
Over the years, Scott Meyers has amassed a gallery of novel ways to use
C++. Each "cool" technique demonstrates how C++ language features can be combined in unusual ways to produce elegant solutions to real problems. The material in this tutorial is not found in any of Scott's books on C++. In this tutorial, youÕll learn the following:
1. Barton and NackmanÕs Template-Based Approach to Dimensional Analysis
Long before the STL showed that templates were for more than just
type-safe containers, Barton and Nackman demonstrated that templates
could be employed to add strong typing to problems that otherwise
defied it. Their technique is worth knowing, not just because it helps
solve problems that are otherwise intractable, but because the runtime
cost of their approach -- in both space and speed -- is zero.
2. Various Views of the GOF Visitor Pattern
The Visitor Pattern gets its name from the way it supports iteration over heterogeneous data structures without requiring downcasts. That's a boon for class clients. But Visitor helps class authors too, because it offers a way
to add virtual-acting functions without requiring any changes to header
files. This talk describes both views of Visitor, plus various
embellishments that can be used to improve it.
3. Adding Trap Doors to Classes
Under normal circumstances, classes specify who has access to their encapsulated parts by explicitly listing their member and friend functions. For some problems, this isn't good enough. It's interesting that it's possible to add "trap doors" to classes so that anybody who knows about the secret entrances can create functions that
have the access privileges of a friend. It's perhaps most interesting if your classes provide such trap doors without your realizing it.
T6pm Java Beans
Prithvi Rao, KiwiLabs
Who should attend: Programmers with an interest in Java programming and component models. Knowledge of the concepts of OO programming and the Java language are required.
Component-based application development has gained prominence because
it promotes code reusability. Java Beans provide a mechanism to develop
sophisticated applications based on reusable software components.
Java Beans are Java classes which have some or all of the following properties which make it possible to compose entire programs or Beans using other Beans as components.
- It must publish its interfaces so other beans can interact with it.
- It must be able to save its internal state (persistence) so that it may be used in different ways by other Beans.
Beans also generally have the ability to handle and generate events as another mode of interaction with their environment. They usually have a visual representation and can be manipulated by tools for building applications.
Beginning with AWT components and the event model in Java, this
tutorial will discuss the properties of Java Beans by developing
examples that highlight them, paying particular attention to Event
Adapters and Properties.
We will also discuss the ActiveX Bridge which makes it possible to embed
a Java Bean into an OLE/ActiveX control.
Need help? Use our Contacts page.
Conference Index
