Fifth Annual International ColoradOS/2 Software Developers Conference

by Wayne Kovsky (Last updated December 25, 1996)

The Fifth Annual International ColoradOS/2 Software Developers Conference, the only OS/2-only, programmers-only conference in the world, was held the week of October 13 through 18, 1996, at Keystone Resort in Keystone, Colorado.

We had another super conference - it was great to see our old friends and to meet the many people new to ColoradOS/2 this year! Thank you all for coming and sharing your ideas, knowledge, and enthusiasm with the ever-growing ColoradOS/2 family.

About ColoradOS/2
In October of 1996, for the fifth consecutive year, an elite group of programmers, analysts, architects and innovators from around the world will gather in the Colorado Rocky Mountains to discuss, debate and challenge their software development platform of choice: OS/2.

As these professionals emerge from ColoradOS/2, putting their new insights and knowledge to work, they are poised to shape yet another generation of OS/2 software development.
 * The result? A metamorphosis.

Recognized worldwide for professional quality and value, ColoradOS/2 is characterized by its enriching, highly charged atmosphere of information exchange. Learning takes place with a no-holds-barred attitude. You'll see OS/2 from all sides, learning firsthand how to navigate through its challenges to produce exceptional results.
 * ColoradOS/2 is about answers.

ColoradOS/2 is synonymous with quality: we've gone to great lengths to design a program that would be the dream conference of any serious OS/2 programmer:
 * The best of the best.
 * a full-range of OS/2 software development topics
 * a faculty of movers, shakers and problem-solvers
 * flexible, self-mapped scheduling
 * the inspiring grandeur of the Colorado Rocky Mountains

Our goal is to promote and enhance the use of OS/2. Through our comprehensive program, support materials, speakers, venue and the attendees who return year after year, we strive to bring together the best of the best for an unparalleled experience. A word about our faculty. Our "faculty" is comprised of more than 45 OS/2 experts: people who were instrumental in the design and implementation of the OS/2 platform; people who have created substantial system architectures based on OS/2; people who know OS/2 inside out, upside down, backwards and forwards. Like you, all of these people live and work in the trenches with OS/2. They know what you're wrestling with, they know where you're coming from. Most of all, they are eager to share their knowledge with you.

Perhaps the best way to describe ColoradOS/2 is a "smorgasbord" -- as much as you want, of whatever you want, whenever you want it! From 8:00 a.m. to 9:00 p.m. (and typically beyond!) attendees roll up their sleeves to tackle the nuts and bolts of OS/2.
 * Conference Format

This year, we are pleased to have as our keynote speaker John W. Thompson, General Manager of IBM's Personal Software Products Division. Additional featured speakers include John Soyring, Vice President, Personal Software Products at IBM, and Joel Krautheim, President and co-founder of SPG Inc.
 * Featured Speakers

Our tutorial roster includes over 75 unique OS/2 related topics, each one offered three to five times throughout the week.
 * Tutorials

One very distinctive feature of ColoradOS/2 is self-mapped scheduling, permitting you to optimize your own personal schedule. Self-mapping allows individuals to achieve their goals for ColoradOS/2 at a reasonable pace across the span of five days. Advanced sign-up for tutorials is neither necessary nor available prior to your arrival at the conference.
 * Self-mapped Schedule

At most major conferences it can be difficult to interact with speakers or instructors; often they are available only during their appointed time for presentation. At ColoradOS/2, our speakers typically attend the entire conference, making themselves available throughout the week to participants.
 * Human Interface

Because we offer far more presentations than any single individual could attend, we make materials from every presentation available. A notebook containing a copy of the tutorial presentations is provided at registration to assist your schedule mapping. Each attendee receives a CD-ROM version of presentations and source code following the conference.
 * Documentation

FOCUS:	ColoradOS/2 is the only conference of its kind devoted exclusively to OS/2. RESULTS:	What you learn will have an immediate impact on the caliber of your work. QUALITY:	Conference materials and speakers are widely regarded as unsurpassed. ANSWERS:	You'll learn what's happening in OS/2 from the people making it happen. EXPERTISE:	Work side-by-side with experts in a hands-on, gloves-off environment. EXPOSURE:	You'll be networking with a global community of OS/2 professionals. SOLUTIONS:	Your new skills and knowledge will eliminate months of costly and trial and error. EXCHANGE:	Whether you are a new user or an OS/2 guru, you'll gain -- and contribute -- valuable programming insights. ENTHUSIASM:	You'll return infused with renewed vision, energy and perspective. "Far and away the best prize that life offers is the chance to work hard at work worth doing." --Theodore Roosevelt Go for the prize. Space is limited. Enroll today.
 * Why you -- and your company -- will be glad you came:

Featured Speakers & Tutorial Topics
Below is the list of topics we will be covering at this year's ColoradOS/2. Please check this site frequently, as any changes to the agenda will be listed here.

Conference Check-in
If you will be arriving early (more than half of our attendees usually do), you may check in for ColoradOS/2 on Saturday, October 12th between 12:00 noon and 4:00 p.m. You may also check in on Sunday, October 13th, between 10:00 a.m. and 5:00 p.m. When you check in you will be given all your conference materials, including a notebook with printed slides of the presentations and a schedule for the week. We will keep the registration desk open all week for late arrivals, but you may be asked to provide a written excuse from your mom for your tardiness.

Welcome Reception
Sunday evening we will be hosting a Welcome Reception from 7:00 to 9:00 p.m. This is a great opportunity to meet our speakers, find old friends and get to know new ones. If members of your family have accompanied you to Colorado, you are welcome to bring them along; we'd love to meet them too! The food is great, and you'll be among people just like yourself, OS/2's biggest fans (and some lovable geeks and geekstresses).

Schedule of Conference Sessions
Following is the schedule of the conference sessions for Monday through Friday. We begin each day with a Continental breakfast at 7:00 a.m., followed by a featured speaker at 8:00 a.m. The remainder of each day is divided into a series of 90-minute sessions, during which there will be nine tutorial topics running concurrently. Within each tutorial time period we have listed each speaker alphabetically and the topic that speaker will present. The last column (example: "1 of 3") indicates whether this represents the first, second, etc. occurrence of this particular topic and how many times it is being repeated during the week.

The days are both long and full, with presentations scheduled from 8:00 a.m. to 9:30 p.m., and yet people always want more, More, More!!! We have had many comments that having to go to lunch is too great a sacrifice, taking precious time away from at least one of the sessions that our attendees want to see. Therefore, in an effort to accommodate the requests for more, More, More!!!, we will be providing box lunches this year. No one should have to miss a single session merely to sustain life. The conference will end on Friday after lunch at about 2:00 p.m.

Schedule Cross-Referenced by Speaker
In addition to the above schedules which are organized by date and time, we have also cross-referenced the schedule by speaker and topic.

Real-Time Support from the VisualAge C++ Team
The VisualAge C++ Service and Support Team will be here this year operating a walk-in technical support center. The team will be available throughout the week for demos, consultations, trouble-shooting, and just plain old talking about VisualAge C++.

Indelible Blue
Indelible Blue, an exclusive dealer of OS/2 software, will be on hand during the week with software available for purchase. If you order software during the conference, you can receive your purchase at the conference or have it shipped direct to your home.

A Look at OS/2's Hooks - Robert Mahoney (2Rud Software)
Ever wonder how hot-key-activated or key-stroke recorder programs work? They use hooks as a means to examine and/or act upon messages or events, intercepting them before an application receives them. Robert will teach you how to create programs that use hooks, and he will illustrate some uses for hooks. Sample source code that will demonstrate the usage of hooks (along with some undocumented features) will be provided on the ColoradOS/2 CD-ROM.

Adding Sound to Your OS/2 PM Application with MMPM - Robert Mahoney (2Rud Software)
Want to jazz up your application? Add sound to it! This session will teach you how to add sound to your PM application, using the OS/2 MMPM interface. Robert will lead you through an exploration of the MciPlay functions, the Mci string interface and Playlists. Sample source code for each of the methods will be provided on the ColoradOS/2 CD-ROM.

Developing Portable User Interfaces with VisualAge for C++ - Hiroshi Tsuji (IBM RTP)
IBM VisualAge for C++ allows you to develop applications for both the OS/2 and Windows platforms. The user interface classes of the Open Class Library enable you to write a modern GUI for both environments. In this tutorial, Hiroshi demonstrates techniques that can make writing a portable GUI easier, along the way pointing out techniques to avoid. Some of the topics he will cover include the trade-offs of using PM-compatible controls on Windows, coping with different coordinate systems, platform-specific resource files, and detecting non-portable code.

Advanced Use of Canvas Classes - Hiroshi Tsuji (IBM RTP)
The Open Class Library of VisualAge for C++ provides canvas classes for creating and managing complex layouts of controls. In this session Hiroshi guides you on a detailed tour of these classes while detailing the supporting architecture that can be found in the IWindow hierarchy. Topics include: working with multicell canvases, minimum sizes and caching minimum sizes, the IWindow::setLayoutDistorted function, combining canvases, performance considerations, and a peek at future enhancements.

Introduction to Visual Programming with IBM's VisualAge C++ - George DeCandio (IBM RTP)
The Visual Builder is one of the most powerful components of IBM's VisualAge C++ product. In this session, George will introduce the concepts of visual programming and program construction from parts, showing how the Visual Builder can be used to create sophisticated Presentation Manager applications. George will incorporate into his presentation a live demonstration of the Visual Builder in which a "real" application will be constructed from the ground up. Creating this application will demonstrate the power of the Visual Builder, and it will also showcase the newest features of VisualAge C++'s Open Class library. No prior experience with Visual Builder is required for this session.

Advanced Visual Programming with IBM's VisualAge C++ - George DeCandio (IBM RTP)
A follow-on to the introductory tutorial, this session covers some advanced topics and programming techniques within VisualAge C++'s Visual Builder. George will describe how and when to use factories, variables and feature promotion, and he will demonstrate all of these concepts with live demonstrations and examples. Along the way he will provide many helpful tips and techniques, and he will preview some upcoming Visual Builder features. This session assumes attendees have some prior knowledge of or experience with Visual Builder, or that they have attended George's "Introduction to Visual Programming with IBM's VisualAge C++" session.

An Introduction to Java Technology on OS/2 Warp - Mike Cowlishaw (IBM Hursley)
Java(TM) is a platform-independent programming language and run-time environment that is one of the hottest technologies for the Internet today. In this session Mike will introduce the Java programming language and its supporting environment (including a discussion of the security and performance issues raised by Java), and he will review Java's use within the World-Wide Web. After this introduction, Mike will describe the IBM port of Java to OS/2 Warp, and he will then share some new ideas on Rexx and Java.

NetRexx: A New Language for the Java Environment - Mike Cowlishaw (IBM Hursley)
This session will cover the details of a new programming language, called NetRexx, which combines the strengths of both Rexx and Java. This new language is as readable and as easy to use as Rexx, yet it can be used both to write and to make full use of Java classes. Initial measurements suggest that the NetRexx source for a typical class has approximately 35% fewer lexical tokens and requires 20% fewer keystrokes than the equivalent class in Java. This session assumes some knowledge of Rexx, and a knowledge of Java to the level covered in Mike's session "An Introduction to Java Technology on OS/2 Warp".

A Technical Comparison of OS/2 Warp and Windows NT - Paul Giangarra (IBM Austin)
Throughout 1993 and into 1994, the computer trade press was predicting that Windows NT would dominate the office desktop; then Windows NT shipped. Throughout 1994 and 1995, the computer trade press was predicting that Windows 95 would dominate the office desktop; then Windows 95 shipped. Now the trade press is again predicting that Windows NT will dominate the office desktop, and some companies are switching to NT with no more rational basis than those predictions. Paul will begin with a tutorial of the technical differences between NT and OS/2, addressing both workstation and server platforms. If there are specific topics/questions that you would like Paul to cover in this introductory tutorial, send them to ppgx@austin.ibm.com. The remainder of the session will be a Q&A session focused on these two Operating Systems.

Using Speech Effectively as a User Interface - Paul Giangarra (IBM Austin)
Merlin, the next version of OS/2, will include the most advanced speech capabilities yet shipped in the industry. In addition to continuous speech navigation, the discrete speech dictation works amazingly well without the need for training the system to each user's voice. Adding voice capabilities to an application requires technical programming know-how (the focus of Bill Schindler's "Using VoiceType with OS/2 Warp (and Merlin)" session), but it also requires a thorough understanding of voice technology. In this tutorial, Paul will focus on integrating voice support into the user experience of an application and the facilities that the speech-enabled application opens up to its users.

Introduction to Distributed Object Programming - Roger Sessions (ObjectWatch, Inc.)
Why are businesses so interested in distributed objects? Roger demonstrates the importance of distributed objects as he introduces the basic concepts of OO programming (inheritance, encapsulation, and polymorphism). He shows how objects are distributed across networks and discusses some basic frameworks used to coordinate distributed objects. This is an introductory overview, designed for programmers who have no experience in OO programming.

CORBA Programming with SOM 3.0 - Roger Sessions (ObjectWatch, Inc.)
This tutorial is designed for experienced OO programmers who want to learn how to do distributed OO programming ala CORBA. Roger will guide you through an examination of interface definitions in IDL, object implementations in languages with CORBA bindings, and the various CORBA services used to coordinate distributed objects. Although the medium is SOM 3.0, the focus is more general.

The CORBA Persistence Services - Roger Sessions (ObjectWatch, Inc.)
It's time to throw away your OO database! We will examine in detail the CORBA services related to Persistence. The Externalization Service allows objects to export their state; the Persistence Service allows that state to be stored into any compliant database; and the Transaction service allows persistence to be coordinated with the overall transactions in which objects participate. Together, these three services allow distributed CORBA objects to support a variety of styles of Object Persistence, and to be stored in formats ranging from optimized object dumps to formats compatible with existing legacy data.

Workplace Shell Programmer's Roadmap (with Tips to Stay on the Straight and Narrow) - Gregory Czaja (DevTech)
If you are new to Workplace Shell programming, you could not ask for a more qualified guide than Greg Czaja, author of DeskMan/2. In this session, Greg will introduce you to Workplace Shell programming, teaching you the skills you need to be able to return home and write WPS objects that both present and manipulate data. Instead of a broad survey of Workplace Shell programming, Greg will begin with a simple template for writing many Workplace Shell objects, focusing on what you really need to know to get started with Workplace Shell programming. You've probably heard that WPS programming is hard; Greg will show you how easy it can be.

Cracking the (Workplace) Shell - Gregory Czaja (DevTech)
Workplace Shell programs are usually implemented via SOM programming, but Greg will demonstrate that there is Another Way. In this session, Greg will show you how to create an IPC mechanism that allows non-SOM applications (e.g., C, C++, Rexx, etc.) to interface with the Workplace Shell via standard calling conventions. Greg will also explore certain myths and truths about the Workplace Shell that will be of value to all OS/2 programmers. Sample source code will be provided on the ColoradOS/2 CD-ROM.

Object Oriented Component Development with OpenDoc - Joseph McIntyre (IBM Austin)
Learn how OpenDoc can evolve your application development environment to benefit from object oriented advantages, including OO development techniques, application packaging and the use of frameworks. During this session Joseph will illustrate techniques for developing object oriented components, including using and extending the PartMeister tool, subclassing components, and designing and building a framework.

Cross-platform Application Development Using OpenDoc - Joseph McIntyre (IBM Austin)
The compelling promise of cross-platform technology is the ability to develop components on one platform and then merely recompile those components for use on other platforms. This session will show you how to use OpenDoc and related technologies, including IBM OpenClass, to build components on OS/2 and deliver them on multiple platforms.

Design for Testing - Charlie Parker (IBM Hawthorne)
Thinking of testing only after we design and code, and then relying heavily on debuggers, may have been adequate for yesterday's small console programs, but it is reckless for applications today. Programming "in the large", especially complex GUIs and multi-threaded applications, poses special problems. Some modules may become too large for debuggers; we are likely to require problem information from users and beta testers who cannot run debuggers for us; and some problems appear only intermittently. One solution is to consider the testing and debugging problem during design, and to build the appropriate facilities into our application. This tutorial will give you some techniques we've found very useful while developing IBM AntiVirus, a product that bumps into every conceivable machine configuration and anomaly.

Designing and Developing Cross-Platform Code for 32-Bit Operating Systems (OS/2, Windows NT, and Windows 95) - Rhonda Rosenbaum (IBM Hawthorne)
Anyone who thinks multi-platform programming is fairly easy with today's tools probably isn't thinking about GUI applications. Rhonda's work on the design and development of the user interface for the cross-platform IBM AntiVirus gives her a real-world perspective that she will share with you in this tutorial. She will describe developing GUI applications for multiple platforms, keeping about 70 percent of the user interface source common across all platform. Topics include how to use C++ with multiple inheritance, use of collection classes and common service functions. Attendees should be familiar with C++ programming.

Developing Applications in VisualAge for Smalltalk - Greg Hutchinson (Attractors Consulting Inc.)
The Visual Programming era has arrived! How will it impact you and the way you program? VisualAge for Smalltalk is a solid development environment that combines the best of a visual development paradigm with a robust Object Oriented tool set. The result is a truly productive environment that can produce workable industrial strength applications. However, the visual environment presents some interesting new problems that the application developer must consider. What should (and should not) be created visually? Can a full functioning visual program be read? What design and coding techniques need to be followed? Are there performance penalties? When and what should you think about for packaging your application? In general, what are the issues that one must now think about when designing applications in VisualAge for Smalltalk? Greg will answer these questions by creating and discussing several working examples taken from real applications created in VisualAge for Smalltalk.

Java Jumpstart - Introduction to Java - David Moskowitz (Productivity Solutions)
You've heard about Java - the platform-neutral way to create Web pages that are dynamic and interactive rather than static and passive. Let David give you a jump start toward writing Java appletts. Intended for people with no Java programming experience, this session will introduce you to the basics of writing Java code and put you on the fast track for writing Java applets.

Developing Java Applications - David Moskowitz (Productivity Solutions)
This session is designed to be an extension of the "Java Jumpstart" tutorial and therefore assumes familiarity with the Java language. From this base, David covers the basics of writing simple Java applets, animations and threads. Java and OS/2 were made for each other; this is an opportunity to learn how to exploit Java in an OS/2 environment.

OS/2 Consulting - David Moskowitz (Productivity Solutions)
Consulting is not a profession! It is a way to identify needs and provide services. Whether you work for yourself or for someone else, this session is designed for people who want to understand how to apply the skills of a consultant. It covers the myths and realities of consulting (whether for yourself or someone else).

OS/2 Warp Unleashed (Updated for Merlin) - David Moskowitz (Productivity Solutions)
This session is intended for anyone running OS/2. It covers the tricks and tips that will help save time and improve productivity using our favorite operating system. It will also highlight common problems and show how to avoid them.

So You Want To Be an Author - David Moskowitz (Productivity Solutions)
At ColoradOS/2 in 1993, Steve Mastrianni and David were literally surrounded by conference participants as they led an impromptu discussion of what it takes to be a successful author specializing in OS/2. This proved to be so popular that they agreed to repeat it as a planned seminar in 1994, then again in 1995, and David will do it again in 1996. Drawing on his own experiences as a successful author and magazine columnist, he offers some very practical advice about how to get started, what to expect, working with publishers and editors, etc. This is a rare opportunity to learn from a well-known author who has "been there, done that".

The State of the OS/2 Marketplace - David Moskowitz (Productivity Solutions)
OS/2 isn't dead!! - but, what is the real state of OS/2 development, the marketplace and the channel? This session provides up to the minute information, from independent sources, that can help you understand the OS/2 marketplace.

RTMIDI, the OS/2 Real-Time MIDI Subsystem - Timur Tabi (IBM Austin)
The OS/2 real-time MIDI subsystem (RTMIDI) provides real-time playback, recording, and processing of MIDI events. Using an object oriented paradigm, an application can not only play and record MIDI data with millisecond accuracy, but it can also configure the subsystem to handle all of its real-time processing needs. With RTMIDI, OS/2 provides MIDI support superior to Windows. This tutorial describes the architecture of RTMIDI and shows how to develop applications and device drivers to take advantage of all of RTMIDI's capabilities.

Developing Object Oriented OS/2 Device Drivers in C++ - Timur Tabi (IBM Austin)
Object oriented programming techniques are not just for application developers any more - you can use them in your OS/2 device drivers as well. Learn how to implement advanced C++ constructs to improve code reuse and to make it easier to implement some of the more complex features of OS/2 device drivers. This tutorial will focus on audio physical device drivers, but the techniques are applicable to any OS/2 driver.

Developing the Plug-in Modules for the ColorWorks API - Anthony Serpico (SPG Inc.)
Developing Plug-in Modules for the ColorWorks API The SPG ColorWorks products have plug-in interfaces that third-party developers can use to extend the functionality of the program, with image acquisition, image export and effect modules. This session will focus on how to use the SPG Plug-in Developers Kit to craft ColorWorks plug-in modules. The ColorWorks API represents an excellent business opportunity for both individual programmers and established software vendors. For an individual programmer or smaller firm, developing ColorWorks plug-in modules is an excellent opportunity to "get on the playing field" with a limited scope/rapid development project and get recognized for your talents. For commercial developers, the ColorWorks API offers an opportunity to build upon your market presence, again with relatively quick-to-market and limited-scope projects.

Lotus SmartSuite Update - Rick McGuire (Lotus Development Corporation)
Straight from the guy who has "been there, done that, got the team T-shirt": hear details on the Lotus SmartSuite 97 for OS/2, including new product functions and Lotus' plans for OS/2 application interoperability via OLE.

Developing Portable Windows and OS/2 Applications - Rick McGuire (Lotus Development Corporation)
Focusing heavily on lessons learned porting Lotus SmartSuite applications to OS/2, Rick reveals how to achieve single-source commonality between Windows and OS/2 applications. The issues involved include: Windows APIs vs. OS/2 APIs vs. the Developer's API Extensions (DAPIE); MFC vs. Open Class; OLE vs. OpenDoc; Multimedia; Visual C++ vs. VisualAge C++ (for both OS/2 and Windows); and the OS/2 Visual Builder. Particular emphasis will be placed on designing applications for portability from the beginning.

Direct-to-SOM Programming with VisualAge C++ - Joel Troster (IBM Canada Lab)
The VisualAge C++ products for both OS/2 and 32-bit Windows have a feature called "Direct to SOM" (DTS) that allows a programmer to develop SOM Objects and use them as ordinary C++ objects. DTS hides a lot of the details of SOM under the covers and allows your C++ SOM code to look like ordinary C++ code. In this tutorial Joel will introduce you to implementing objects and client programs using the DTS feature of VisualAge C++. He will demonstrate the power of DTS by first building a DTS Object and a batch client program to access it; next he will build a visual interface to the object using the VisualAge C++ Visual Builder; finally he will demonstrate how to distribute the object and access it using DSOM.

Distributed Applications Using NetFinity - Noel Bergman (DevTech)
NetFinity is the core of SystemView, IBM's standard framework for developing distributed system management applications, but NetFinity's use extends far beyond that genre. NetFinity provides a messaging layer and core set of services that are operating system independent. We will focus on building a new distributed application, illustrating how to build User Interface and Service components. We will show how NetFinity can connect the UI and Service components for the user, and how the UI component can use the NetFinity services to dynamically locate and connect with Service components. Sample source code will be provided on the ColoradOS/2 CD-ROM.

Running a Virtual Office Using Lotus Notes - Noel Bergman (DevTech)
Learn how you can use Lotus Notes right out of the box, and where you can go from there, from someone who has been there, done that. Development Technologies, Inc. has staff in four states and two countries, plus outside contractors for technical writing, graphics arts, and PR. How do we keep things coordinated? With Lotus Notes: The Virtual Office Suite! Noel will share DevTech's real experiences using Lotus Notes to coordinate these geographically dispersed activities, and he will offer recommendations for running your own business efficiently with Lotus Notes.

"Documentation Challenged" OS/2 - Aidon Jennery (IBM Austin)
The OS/2 operating system has more than a few surprises in store - especially in areas where the documentation may be confusing or incomplete. This tutorial discusses some important interfaces and valuable techniques, along with other "good to know" programming information and where to look for more! Discussion topics include: the formats of OS/2 resources, the legendary PSTAT API, secrets from a VDM, rebooting, hooks, device monitors, getting DLLs loaded at boot time and various interesting 32-bit and 16-bit APIs. Sample source code in C will be provided on the ColoradOS/2 CD-ROM.

Writing OS/2 DLLs - Aidon Jennery (IBM Austin)
What exactly is a Dynamic Link Library? What does it do and where does it live? Aidon will discuss the creation of OS/2 DLLs from the smallest sample to complete subsystems. This tutorial provides a look at the anatomy of a DLL; threads, processes and DLLs; global and instance data in DLLs; exports and imports of code and data; DLL initialization and termination; multi-process DLLs; and OS/2 DLL interfaces including hooks, SOM, WPS, and 16-Bit I/O subsystem registration. Sample source code in C will be provided on the ColoradOS/2 CD-ROM.

DSOM and Lotus Notes Programming - Steve Gardner (CyberWorks Corporation)
By wrapping the Lotus Notes APIs with DSOM, you can provide Notes database access to a wide variety of platforms - even to clients that don't have Notes installed on their machines. This tutorial will teach the basics of writing DSOM classes using the IBM VisualAge C++ Direct to SOM (DTS) compiler to wrap the Notes APIs. Attendees should have a working knowledge of C++ programming, familiarity with SOM/DSOM and a basic understanding of Lotus Notes. Sample source code will be provided on the ColoradOS/2 CD-ROM.

Programming DCE Security Services (Kerberos/DSS) - Steve Gardner (CyberWorks Corporation)
Security and access control are crucial elements of today's distributed computing environments. The Kerberos Security Service in DCE is powerful, flexible and reliable - and it is now available in the IBM Warp Server DSS product. This tutorial session will teach you what services are available and the basics of how to program these services. Attendees should have a working knowledge of C++ programming. Sample source code will be provided on the ColoradOS/2 CD-ROM.

DSOM Objects for the Workplace Shell - Randall McClure (CyberWorks Corporation)
Here is a little-known secret: DSOM objects can provide the same look and feel as the WPS, without any of the programming headaches. By using DSOM objects to create WPS objects, programmers can remove the interdependencies between their application code and that of the Workplace Shell. Randall will show you how to use this technique, which also shifts the debugging environment from the WPS to a working environment that is much more manageable.

Lotus Notes APIs, Some C++ Wrapper Examples - Randall McClure (CyberWorks Corporation)
In this session, Randall will provide example C++ wrappers for selected Lotus Notes APIs, accompanied by a thorough discussion of the code. He will cover Notes initialization and database access in particular. Some knowledge of C++ is assumed.

Using the Rexx APIs to Extend Your Applications - Bryan Walker (Williams-Sonoma)
One of OS/2's many advantages is that it is not necessary to create your own macro/scripting language. Instead, Rexx can be used as the macro language for both new and existing applications, providing all the features desired of a macro language and more. This tutorial focuses on using Rexx as the scripting language of choice on OS/2, not on programming with Rexx. Bryan will familiarize you with the RexxStart API, Rexx function handlers, and the remaining tools from this rich set of functions. Learn firsthand how Bryan used the Rexx APIs to design a flexible, easily extendable, powerful yet small installation program.

Extended Attributes: Untangling the Interface - Bryan Walker (Williams-Sonoma)
The Extended Attributes API demystified: this tutorial details the workings of this very important but little understood and frequently avoided API, and additionally provides some functions that simplify its use. You'll learn why extended attributes are designed as they are and how their design relates to existing standards, a design that can help make your objects network ready.

HPFS Internals: An Introduction - Doug Azzarito (IBM Austin)
This session will take you through an introductory tour of the OS/2 High Performance File system (HPFS). The features, limitations, cache options, and a brief tour of the data structures will be presented. This information will enable the attendee to tune individual HPFS parameters, and use sector-editor tools to find and recover lost files on an HPFS drive.

HPFS Internals: Advanced Topics - Doug Azzarito (IBM Austin)
This session will take you inside the structure of the High Performance File System (HPFS). All disk structures used by HPFS will be discussed byte by byte. After attending this session, a programmer should be able to develop utilities to view and manipulate HPFS partitions. Attendees should already be familiar with HPFS (familiarity with the information presented in the session, "Introduction to HPFS Internals" is recommended), and be ready for a fast-paced, in-depth presentation.

Recovering from Disk Problems - Doug Azzarito (IBM Austin)
Use data recovery tools to restore files from damaged hard drives. FAT, HPFS and partition table problems are covered. You'll leave this session knowing how to rescue your files in the event of a system failure.

HTML and OS/2 - Mike Kaply (IBM Austin)
In this tutorial Mike will introduce you to the Hypertext Markup Language (HTML) and show you how to use it to create viewable documents, focusing on how HTML relates to OS/2 and HTML's use within OS/2 for help systems. Topics include: creating HTML documents; methods for publishing information on the Internet; HTML extensions that are specifically for OS/2 and OS/2 applications; and the relationship between HTML and OS/2's future help systems.

Programming TCP/IP under OS/2 - Mike Kaply (IBM Austin)
Ever wonder how to write an application that works across the Internet? This tutorial will give the basics of developing an application that uses TCP/IP sockets under OS/2. Topics include a basic introduction to TCP/IP, WinSock, and OS/2 sockets.

Introduction to OS/2 Multi-Threaded Programming - Kimberly Bobrow (Optimum Consulting, Inc.)
One of OS/2's most powerful capabilities for creating "Wow, I gotta have that!" programs is its preemptive multi-threading. Kimberly will present the "hows" and "whys" of skillful multi-threading, including the use of semaphores - which are vital for proper thread management. You will also learn how thread priorities can be used and how and when to adjust them. PM programs have certain special requirements when multi-threading, which Kimberly will also cover.

Introduction to OS/2 Inter-Process Communication - Kimberly Bobrow (Optimum Consulting, Inc.)
When writing programs for an operating system that can have multiple processes, you will inevitably need to communicate between processes. In this session we will discuss the various IPC mechanisms available in OS/2, including named and unnamed pipes, queues, shared memory and PM messaging. We will include an introduction to semaphores and an introduction to Dynamic Data Exchange (DDE). This session will be especially beneficial to attendees who already have a basic knowledge of OS/2 programming, and who wish to understand and learn to use the various IPC mechanisms in the operating system.

Introduction to OS/2 PM Programming - Guy Scharf (Software Architects Inc.)
What does it take to write your first Presentation Manager application? We'll look at the basic principles of the OS/2 Presentation Manager and examine the OS/2 PM API. In addition to introducing you to the mechanics of PM programming, Guy will discuss key issues in designing successful, maintainable, and reusable PM components. You'll see the same program written in C, in IBM VisualAge C++ using the ICLUI class library, and in a higher-level language using a GUI development tool.

Selecting a GUI Development System - Guy Scharf (Software Architects Inc.)
Which GUI development system is best for you? This session will examine criteria for selecting a development system. In addition to comparing features, we'll look at the critical issues of usage style and the applicability of different GUI development systems to different environments. Some of the products we will look at include IBM's Visual Builder; VisPro; VX-Rexx; Guidelines; Gpf; and Prominare Designer. We'll demonstrate some of the products that aren't scheduled for other sessions.

Introduction to Programming Lotus Notes - Jens-Christian Fischer (ABB Turbo Systems AG)
To introduce you to programming Lotus Notes, this tutorial examines a variety of programming modes and models, beginning with simple customizations and continuing through @Macros, to LotusScript and the Notes API (supporting C, C++, Smalltalk and Rexx). You will learn from real-world examples what to use where, and where to look for more information. The session will conclude with a more detailed look at LotusScript, showing you where and how to add simple scripts to Notes applications. A basic understanding of the Basic language will enable participants to get the most out of this session.

Programming Lotus Notes with LotusScript - Jens-Christian Fischer (ABB Turbo Systems AG)
This tutorial delves more deeply into the details of integrating LotusScript with Lotus Notes, covering both LotusScript's object oriented extensions and the Notes class library. We will evaluate some examples of advanced techniques, both on the Notes and the Script side. We recommend that attendees have some knowledge of Lotus Notes (see Jens-Christian Fischer's "Introduction to Programming Lotus Notes"), an understanding of the Basic language and familiarity with OO concepts.

Introduction to the IBM VisualAge C++ Open Class Collection Classes - Heinz Graalfs (IBM Germany)
The IBM OpenClass Collection Classes are designed to manipulate collections of objects in a group. Collections are used to store and manage elements (or objects) of a particular user-defined type. Each type of Collection has different internal structures and different access methods that are optimized for efficient storage and retrieval of objects of that type. This tutorial describes the types of Collections provided by the library, and introduces the classes that make up the Collection Class Library.

Introduction to the IBM VisualAge C++ Data Access Builder - Mike Polan (IBM Toronto)
Data Access Builder, a component of IBM's VisualAge C++ for OS/2, connects relational data with object oriented applications using a code generation tool and supporting services in a class library. Data Access Builder visually maps a relational table to an object oriented class, a column to an attribute and individual rows to an instance of that class. Code generated by the Data Access Builder can be used directly in C++ or IDL programs, or as parts in the Visual Builder.

Mike will show you how to use the Data Access Builder to generate code that is tailored to the database. He will construct a complete database application for retrieving, adding, updating and deleting data, using Data Access and the Visual Builder. He will demonstrate that you can do this without writing any code or even knowing SQL, while preserving the performance benefits of embedded SQL. Mike will show how Data Access Builder can be used to customize the mapping for additional flexibility in accessing the database, and discuss other relational to object oriented mapping issues. Functions and features of DABE (an early incremental beta of the next release) will be presented and demonstrated. Design direction for the next release will be discussed. Suggestions and feedback are encouraged.

Memory Management Part I: Using the VisualAge C++ Memory Management Components - Jay Benayon (IBM Toronto)
Efficient memory management is critical to good OS/2 programming. This first of two related sessions provides an overview of basic memory routines and of debugging common memory management problems. Jay will explore the use of the debug memory APIs and run-time routines to identify and solve memory errors. He will examine the most common errors, how they are caused, how to catch them, and their side effects. He will also teach you how to detect and resolve memory leaks, and demonstrate using IPMD to debug heap problems. This session is intended for C/C++ programmers, especially novices. Very experienced programmers may wish to skip Part 1 and attend only Part 2.

Memory Management Part II: Heaps, Shared Memory and Application Performance in C/C++ - Jay Benayon (IBM Toronto)
In this follow-on to Part 1, Jay covers defining user heaps for regular, tiled, and shared memory; fixed heaps versus expanding heaps; transparent usage of shared memory within the application; debugging multiple heap errors; leak detection; and increasing application performance through the use of multiple heaps. This session is intended for experienced C/C++ developers who are interested in the use of multiple heaps and shared memory to improve the performance of their applications. Familiarity with the basic concepts of Part I of these two sessions is assumed.

New Features of the IBM VisualAge C++ Open Class Library - Andrei Malacinski (IBM RTP)
This session provides an opportunity for you to hear about the latest new features under development for future releases of IBM's VisualAge C++ Open Class Library. Participants will be among the first to preview these new features, hearing up-to-the-minute information straight from a member of the development team. Andrei will begin with an overview, then he will demonstrate these new features, using sample programs to show you how you can best exploit them.

Programming the Container Classes of the IBM VisualAge C++ Open Class Library - Andrei Malacinski (IBM RTP)
This session will explain the basics of programming the Presentation Manager container control using the VisualAge C++ Open Class Library. Opening with a brief overview of containers, Andrei will focus primarily on the container classes and their uses, through examples with sample code. This sample source code will be provided on the ColoradOS/2 CD-ROM.

OpenGL Introduction and Programming on OS/2 Warp - Suzy Deffeyes (IBM Austin)
OpenGL is a 3D API which is included in the latest release of OS/2 Warp. It provides high precision rendering functions for applications which need top-quality 3D rendering. Available on most operating systems, OpenGL provides for specification of objects in 3D, transformation and clipping, lighting, fogging, texture mapping, transparency, and much more. Suzy will begin with a very brief introduction to OpenGL, followed by an examination of OpenGL programming concepts. Time and machinery permitting, some live demos will be included.

OS/2 Graphics Programming Part I - The Building Blocks - Kelvin Lawrence (IBM Austin)
In this introductory tutorial participants will develop competency with the fundamental building blocks of OS/2 Presentation Manager graphics programming as we introduce and explore the capabilities of the Graphical Programming Interface (GPI). The focus areas include: presentation spaces; attributes; bundles; lines and boxes; areas, paths and regions; polygons; curves and arcs; and Bezier splines. Examples used in this session are relevant to everyday programming requirements, such as adding business graphics to an application. For each aspect of the GPI that we explore, we will look at the concepts behind the particular task at hand, run a sample program, and then walk through the relevant parts of the source code to that sample program. All of the sample programs are written in C and cover far more than just the issues discussed in this session. Sample source code will be provided on the ColoradOS/2 CD-ROM.

OS/2 Graphics Programming Part II - Advanced Topics - Kelvin Lawrence (IBM Austin)
More advanced OS/2 graphics programming topics are the focus of this tutorial, covering some key aspects of graphics programming that often cause confusion, whereas mastering these topics can greatly enhance your application. We will focus on: constructing and drawing wide lines; coordinate spaces and transforms; clipping; multi-threaded graphics programming; working with fonts; using timers in graphics applications; techniques for smooth text scrolling; new technologies (3D graphics, etc.); and performance issues. It will be useful, but not essential, to have a basic understanding of the topics covered in Kelvin's "Building Blocks" session before attending this one. Sample source code will be provided on the ColoradOS/2 CD-ROM.

OS/2 Graphics Programming Part III - Working with Bitmaps - Kelvin Lawrence (IBM Austin)
Kelvin created this tutorial as a direct response to numerous requests from ColoradOS/2 attendees for more information about creating and using bitmaps in OS/2 graphics programs. Topics covered include: drawing to a memory bitmap and displaying it on the screen; creating a tiled image of a bitmap; loading a bitmap from a resource and displaying it; "The anatomy of the OS/2 bitmap" - a detailed look at the OS/2 bitmap file format and how to parse it; loading a bitmap from a disk (.BMP) file; building a bitmap dumper program; saving a bitmap to disk as a .BMP file; loading a bitmap and displaying it with the correct palette; creating user defined patterns; creating textures; and what's coming in the latest OS/2 release relative to bitmaps. Sample source code will be provided on the ColoradOS/2 CD-ROM.

OS/2 Exceptions, C Signals, and C++ Exceptions under VisualAge for C++ - Roger Pett (IBM Toronto)
Often the distinction between a merely good and a great program is in how well (or even whether) unexpected events are handled. In this tutorial, Roger will begin by describing the model that OS/2 uses to handle exceptions. Next he will cover the method whereby VisualAge C++ creates and handles C signals using this model, including the extensions to the ANSI C standard that permit use of signals in multi-threaded programs. Roger will also describe C++ exceptions, which are a different extension of the OS/2 Exception model. He will define and illustrate with examples the required coding techniques for all three exception handlers, discussing interactions between the handlers, and showing ways to use them together.

Programming with the OS/2 Warp DIVE Graphics Interface - Mike Brown
Explore the powerful DIVE interface built into OS/2 Warp. DIVE is a set of APIs that provides high speed graphics output and color space conversion to any Presentation Manager application that needs fast animation or extensive color space support. Central to the session will be the experience gained adding DIVE support to the shareware PMMPEG program and writing a high-speed bitmap viewer. Extensive source code will be provided on the ColoradOS/2 CD-ROM.

Rexx Extensions & Extensions with Rexx - Joe Wyatt (NSite - Full Computer Solutions)
The end-user of your application can utilize Rexx for customization, automation of repetitive tasks, and the creation of powerful macros. In this tutorial Joe guides you through creating an OS/2 DLL to extend the Rexx language, designing your application so that it can use Rexx macros, and defining and using a subcommand interface handler in your application. He will demonstrate these techniques with example source code that is designed to aid you in providing these Rexx extensions; this source code will be included on the ColoradOS/2 CD-ROM.

Workplace Shell Programming for a Multi-User Environment - Joe Wyatt (NSite - Full Computer Solutions)
Desktop environments in many businesses today are plagued by three things: paranoia about security; machines that are used by more than one person, with each person needing their own special settings; and traveling users who expect their desktop settings to follow them from machine to machine. WPS programming in this environment can be especially tricky. Joe describes and analyzes some techniques for solving these problems, including desktop passwords, screen locking mechanisms, central object storage, and central management of the desktop.

The Programmer's Guide to SOM - Simon Nash (IBM Austin)
You've heard about SOM, and you're familiar with its concepts; now you're ready to give it a try. With Direct-To-SOM support in VisualAge C++, SOM programming is now easier than it's ever been. And SOM is cross-language, so you can use it from C, Smalltalk, Object Rexx, and OO COBOL. They're all covered in this talk, so come along and find out how to break the language barrier with SOM! Note: some familiarity with SOM is assumed. The session "Introduction to Distributed Object Programming" by Roger Sessions would serve as a good introduction to SOM concepts.

SOM and Java - Simon Nash (IBM Austin)
Something exciting is happening to SOM ... we're adding support for Java. Come to this session and see a technology demonstration of how SOM classes can be used from Java and implemented in Java. Simon will also cover the benefits that SOM brings to Java.

Source Code Debugging with the New Remote ICAT Debugger - Chris Matthews (IBM Austin)
In this technology demo, the participants will learn about the features, function and use of the new ICAT remote source code debugger. The demo will demonstrate debugging techniques of source debugging for Device Drivers, IFS, subsystems and applications for 16- and 32-bit C, C++, and assembler code. It will also include the new features and fixes to the debugging environment that were added as a result of ICAT enhancements.

Snares and Snags in C/C++ Programming - Jim Gimpel (Gimpel Software)
Though efficient and powerful, the C/C++ language nonetheless offers numerous traps for the unwary. Perfectly legal and innocent looking code constructs can become debugging nightmares, or present unexpected portability or performance problems. The C++ enhancements to the C language have paved over some of C's programming potholes, only to have created new ones in the process. The sheer complexity of C++ only magnifies the problem. James will guide you through a number of specific coding examples that illustrate a variety of pitfalls, while suggesting some defensive strategies.

Using the Kernel Debugger - James Taylor (IBM Austin)
The kernel debugger is a very powerful tool that enables an application programmer to determine exactly what is going on inside the system when things are not going as expected. In this tutorial, James will describe and demonstrate both fundamental and advanced techniques for using the kernel debugger. You will learn how to configure and use the kernel debugger to maximum advantage for debugging your OS/2 applications, while James reveals many tips and tricks that are not covered in the kernel debugger documentation. In this session James will particularly focus on debugging Presentation Manager application hangs.

The Evolving OS/2 User Interface: Merlin and Beyond - James Taylor (IBM Austin)
In this session, James will discuss the Merlin user interface, as part of the continuing evolution of the OS/2 system. You'll hear James describe some of the future directions the OS/2 user interface might take. Be sure to take advantage of this rare opportunity to learn from and provide direct feedback to the person with responsibility for the future look and feel of one of the most important components of OS/2, its user interface.

The VisualAge C++ Linker & Librarian - Jim Lemke (IBM Toronto)
ILINK and ILIB have many improvements over their earlier counterparts, both in performance and features. This session will describe the new features and how to use them. An overview of linker operation will discuss strong and weak symbols, how their DEFs and REFs affect library searching, and how sections are assigned to segments. Issues relating to executable size and load/paging time are also discussed. Some poorly understood options are explained, as well as how to use the map file. Next, several common problems and solutions are examined. These include: segment ordering, DosGetMessage and MSGBIND failures, warnings about "forwarders", and "frame-relative fixup" warnings.

Using VoiceType with OS/2 Warp (and Merlin) - Bill Schindler (The Groovy Corporation)
IBM has announced that Merlin (the next version of OS/2) will include speech recognition capabilities. Making an application speech-aware obviously requires technical know-how, but it also requires a shift in design considerations. In this session Bill will be your guide for an in-depth look at the VoiceType Dictation APIs, giving particular attention to problems and issues with design, performance, threading, and debugging a VoiceType-enabled application.

VisualAge Goes Java* ... with a Demo Too! - Bill Sarantakos (IBM Toronto Lab)
Come and hear about IBM's plans for a VisualAge for Java* product. After a brief discussion of what our plans are, you will be shown a technology demo showcasing our visual tools working with Java. You'll see the Visual Builder in action generating the user interface for your Java applet or application. You'll see the Data Access Builder generating Java class code to access your database tables. Finally, you'll see how our latest visual tool, the Distributed Application Development Tool (DADT) can be used to distribute your application across a network.

Writing High Performance OS/2 Applications in C and C++ - Ian Ameline (Alias Research)
In this session, you will learn to identify and fix performance problems in OS/2 applications. Ian will discuss methods for finding slow execution "hot spots," memory hogs and leaks, as well as techniques for solving these problems. In the process, you will become familiar with tools including EXTRA (the Execution tracer provided with C Set++), and SPM/2 (System Performance Monitor). Ian will also present methods for page tuning (which can dramatically reduce working set memory), and discuss I/O performance issues.

Register Early to Win an IBM Thinkpad 760CD!
Register for ColoradOS/2 before August 12, 1996, and in addition to the substantial early registration discount you will receive, you will be entered in our Early Registration Drawing for an IBM ThinkPad 760CD, carefully configured to be a great OS/2 machine. We will have a special drawing for this prize Monday evening, October 14th, to enable the winner to have use of this ThinkPad all week. To be eligible, you must have registered and paid for your registration before August 12, 1996, and you must be present to win. All tax liabilities will be the responsibility of the winner.

Real-Time support from the VisualAge C++ team!
They're back! The VisualAge C++ Service and Support Team will be here this year, once again operating a walk-in technical support center for the entire week of ColoradOS/2. In addition to presenting several regular tutorial sessions, the team will be available throughout the week for demos, consultations, troubleshooting, and just plain old talking about VisualAge C++.

Indelible Blue
Indelible Blue, an exclusive dealer of OS/2 software, will be on hand again this year to help you spend your OS/2 software dollars. Any software you order during the conference, can be shipped to you at Keystone Resort or your home.

ColoradOS/2 Drawing
Each year we hold a drawing for many valuable products that are of particular interest to OS/2 software developers. Each ColoradOS/2 attendee is eligible to participate in this drawing (to be held Thursday evening), and you must be present to win.

ColoradOS/2 After Hours!
Activities at ColoradOS/2 don't stop just because the sun goes down. The technical sessions often extend into the night, but if you want something just a bit less "structured," we offer the Unofficial ColoradOS/2 Party Guide."

If past conferences are any indication, the after-hours activity at ColoradOS/2 will include:
 * Beer tasting
 * Fine Dining
 * Celebrity impersonations
 * Video Games (bring your Playstation CDs!)
 * Classic Movies (if Tonya Harding's wedding video can be considered "classic")
 * Stimulating reading material

Sound intersting? We hope so. Once you arrive at ColoradOS/2, keep your web browser pointed at this page so you'll have the latest news, including:
 * Maps and Directions so you can find the parties!
 * Party Schedules
 * Pictures, stories and casualty lists from past parties