PRELIMINARY TUTORIAL PROGRAM

Monday and Tuesday, September 14-15, 1998

MONDAY, SEPTEMBER 14

M1am
Database Programming with Tcl/Tk
Tom Poindexter, Talus Technologies, Inc.

M2am
Effective Tcl/Tk Programming 
Michael McLennan, Lucent Technologies, Inc.

M3am
Cross-Platform Development
Vicky A. Murphy, Computerized Processes Unlimited, Inc.

M4pm
CGI Scripting

M5pm
Building Client/Server Applications
Michael McLennan, Bell Labs Innovations for Lucent Technologies, Inc.

M6pm
The Dark Secrets of Tcl Development: Debugging, Testing and Packaging
Jeffrey Hobbs, Siemens AG

TUESDAY, SEPTEMBER 15

T1am
Tcl Extension Building and SWIG
David M. Beazley, University of Utah and Gerald W. Lester, Computerized Processes Unlimited, Inc.

T2am
Object-Oriented Programming with [incr Tcl]
Michael McLennan,  Bell Labs Innovations for Lucent Technologies, Inc.

T3am
New Features in Tcl 8.0 and Tcl 8.1
Brent Welch, Scriptics Corporation

T4am
Everything Your Mother Never Told You About ClientData: C Programming With Tcl/Tk
George Howlett, Bell Labs Innovations for Lucent Technologies, Inc.

T5pm
Building Mega-Widgets with [incr Tk]
Michael McLennan, Bell Labs Innovations for Lucent Technologies, Inc.

T6pm
Tcl and Java Programming: Practice and Pitfalls
John Reekie and Christopher Hylands, University of California, Berkeley

MONDAY, SEPTEMBER 14

M1am
Database Programming with Tcl/Tk
Tom Poindexter, Talus Technologies, Inc.

Who should attend: Programmers who are planning to develop database applications in Tcl/Tk.  Participants should already have a working knowledge of Tcl/Tk.  Experience with SQL and database systems is helpful, but not required.

This tutorial focuses on building database applications in Tcl/Tk by utilizing database extensions.  The Tcl database extensions Sybtcl and Oratcl are featured, representing extensions to two of the most popular relational databases from Sybase and Oracle.  Sybtcl and Oratcl are explored in detail, from simple query/insert/update/delete to using advanced features such as executing stored procedures and BLOBs (binary large objects.)
    Other topics covered include:

        * Requirements for using Tcl database extensions
        * Dealing with error situations and server feedback
        * Accessing meta data, data about result sets
        * Transaction semantics
        * Common Tcl/Tk programming patterns
        * Database administration scripts
        * Using Sybtcl/Oratcl sample programs, Wisqlite and Wosql
        * Compiling and building the Sybtcl/Oratcl extensions
        * Review of other Tcl database extensions
 
Tom Poindexter is President of Talus Technologies, Inc., a Denver based software consulting company.  Tom has authored and maintains the Sybtcl and Oratcl Tcl database extensions.   Tom has 18+ years experience in software design and programming and has been developing Tcl-based database applications for Denver area telecommunications clients since 1992.   He is also a contributing author of Tcl/Tk Tools, an upcoming title from O'Reilly & Associates.Tom also writes robot simulation games in C and Tcl.  Tom has earned an  MBA from Illinois State University.
 

M2am
Effective Tcl/Tk Programming 
Michael McLennan, Lucent Technologies, Inc.

Who should attend: Programmers and managers who are using Tcl/Tk to build real-world applications.  This tutorial assumes a working knowledge of Tcl/Tk, and goes beyond that to show how non-trivial Tcl/Tk programs are put together.

By taking advantage of the Tk canvas, and by organizing code into reusable libraries, you can build easily maintained Tcl/Tk applications with professional appearances. Some people claim that Tcl is a "toy" language, unsuitable for commercial applications. Sybase uses more than 1,000,000 lines of Tcl code to perform regression testing on their database product.  SCO uses Tcl to build the administration tools for their UNIX products. Web sites such as the Java Beans Directory, Java Solutions Online, and the Apple Developers Catalog are all powered by Tcl.

Topics will include
* Building professional-looking and easily maintained Tcl/Tk applications
* Tips for writing Tcl/Tk code.
* How  to synthesize new widgets
* Using component libraries to improve the structure of Tcl code
* How to distribute libraries as Tcl packages
* Programming paradigms and coding techniques for successful Tcl/Tk projects

Michael McLennan has been a Tcl/Tk enthusiast since 1992, and is currently a Distinguished Member of Technical Staff at Bell Labs Innovations for Lucent Technologies. He has taught more than 60 Tcl/Tk courses, and is co-author of Effective Tcl/Tk Programming (Addison-Wesley, 1997) and Tcl/Tk Tools(O'Reilly &Associates, 1997).  He also developed [incr Tcl], an object-oriented extension of Tcl/Tk.  He has written and developed many extensions and applications, including [incr Tcl], the cover application for John Ousterhout's book Tcl and the Tk Toolkit (Addison-Wesley, 1994).  Michael received a Ph.D. in 1990 from Purdue University.
 

M3am
Cross-Platform Development
Vicky A. Murphy, Computerized Processes Unlimited, Inc.
 
Who should attend: Developers familiar with Tcl/Tk and multiple platforms, such as Unix and Windows 95/NT.
 
This tutorial will discuss the use of Tcl commands to deal with file systems in a platform-independent manner, including determining specifics of the OS, platform-specific packages, and platform-specific enhancements to regular commands. Participants will also explore Tk as it relates to the native look and feel of operating systems. Initiating Tcl programs in a platform-independent manner will also be covered.
 
Vicki A. Murphy has extensive training experience in a variety of educational settings. She currently teaches Tcl classes for Computerized Processes Unlimited, Inc., (CPU).She also teaches a series of customized Tcl classes worldwide for a third party software vendors. Vicki graduated Cum Laude with a BS in computer information systems from Tulane University and has a BS in business administration from Our Lady of Holy Cross College.
 

M4pm
CGI Scripting
Gerald W. Lester and Vicki A. Murphy, Computerized Processes Unlimited, Inc.
 
Who should Attend:  Programmers who need to learn Tcl scripting techniques for CGI-BIN scripting. Participants should be familiar with Tcl, HTML and CGI-BIN.
 
This tutorial will introduce participants to writing CGI-BIN scripts in Tcl using the de-facto standard package by Don Libes. It will cover retrieving information from forms including entry fields, check buttons, radio buttons and others. There will be discussion on  generating HTML from Tcl, debugging scripts, spawning processes and communicating with external programs, communicating with processes via sockets, and accessing other server information. Participants will learn how to migrate CGI scripts to scripts that run inside of the HTTP Tcl Daemon. After completing this course participants will have the skills needed to begin implementing web pages with CGI scripting in Tcl.

Gerald W. Lester founded the Training, Networking and Support  Department at Computerized Processes Unlimited, Inc. (CPU), and currently serves as the department manager where he teaches customized Tcl classes for a third party software vendors and classes on CPU's real-time Tcl extensions, called SCL(R). Having used Tcl since 1992, he chaired the Tcl User Group meeting in 1994 and served on the group's program committee in 1995 & 1997. Gerald has been in software development since 1979, he primarily designs real-time control systems. He holds a  BS computer science and physics, and a MS in computer science.

Vicki A. Murphy (For biography please see text in M3am)

M5pm
Building Client/Server Applications
Michael McLennan, Bell Labs Innovations for Lucent Technologies, Inc.

Who should attend:   Programmers and managers who need to use Tcl/Tk to build networked applications.  This tutorial assumes a working knowledge of Tcl/Tk, and goes beyond that to show how pipes and sockets can be used to create client/server applications.  Familiarity with HTML and Web-based applications is helpful but not required.

Creating networked applications used to be a difficult task that was better left to programming experts, requiring tricky operating system calls to create sockets and complex communication protocols built out of obscure byte codes.  Not any more.  With Tcl/Tk, you can write a simple client/server program with just 60 lines of code. Instead of exchanging byte codes, the client  and server can exchange Tcl commands, making the protocol easy to monitor and debug.

This tutorial shows how to create client/server applications with Tcl/Tk.  It shows how pipes and sockets are used as communication channels, how Tcl commands are exchanged and filtered through "safe" interpreters, and how networked applications are developed and debugged.  Attendees will see how the Tcl plug-in can be used to create client programs that run inside a Web browser.

Michael McLennan (For biography please see text in M2am)
 

M6pm
The Dark Secrets of Tcl Development: Debugging, Testing and Packaging
Jeffrey Hobbs, Siemens AG

Who should attend: Intermediate or advanced Tcl developers familiar with core Tcl/Tk as well as Tcl and C integration. Since Windows and Unix systems packaging will be shown, basic knowledge will be assumed, but is not required for single-platform developers.  Basic knowledge of debugging principles is also helpful, but not required.

Tcl/Tk is a simple, but powerful, interpreted language.  In just a matter of days you can build your first application.  In another week, one can build a spiffy graphical interface to go along with it. However, when one decides to build applications (large or small) that would be useful to others in their company or user community, the tasks of ensuring the software is bug-free, polished, packaged and distributed effortlessly can be daunting for an interpreted language.

This tutorial will discuss how to maximize the Tcl development process through useful techniques and available tools. Attendees will gain skills to more rapidly  develop clean Tcl code that can be packaged and distributed without major pitfalls.  We will examine the following processes in a multi-platform environment (UNIX and Windows95/NT), with both pure Tcl/Tk and Tcl/C applications:

* Debugging Tcl code
* Coverage testing for Tcl
* Interactive debugging of Tcl and Tk
* Coding for configurability
* Managing the interaction between Tcl and C
* Packaging a Tcl application

Jeffrey Hobbs has worked on Tcl projects ranging from 5 to 100,000 LOC at Siemens AG. He is author of TkCon and TkTable, among other Tcl utilities, and maintains the Tk Usage FAQ. Jeffrey received a BA and MS in computer science from the University of Oregon, where he taught classes on using Tcl/Tk.

TUESDAY, SEPTEMBER 15

T1am
Tcl Extension Building and SWIG
David M. Beazley, University of Utah and Gerald W. Lester, Computerized Processes Unlimited, Inc.
 
Who should attend:  Developers involved in building Tcl/Tk interfaces to C/C++ applications or building compiled extensions to Tcl, who need useful information about building extensions to Tcl 8.0 as well as tools for automating the extension-building process. Participants should be familiar with C, but no prior experience with Tcl extension building is required.

Participants will  explore several approaches to adding new commands and creating new shells in Tcl using C. The instructors will cover returning results and conversion functions. This tutorial will demonstrate the extensibility of Tcl and its strength as an embedded language.
 
Topics include:
 * Accessing Tcl variables
 * Mapping Tcl variables to C variables
 * Tracing Tcl variables
 * Executing Tcl commands from C
 * Embedding into an application
* Creating new Tcl/Tk shells vs. dynamic loading of extensions
* Action vs. object commands
 
The use of SWIG, a tool for automatically generating Tcl interfaces to C/C++ programs, will also be described. While the use of SWIG will be discussed, many of the topics also apply to other automated Tcl extension building tools.
Topics include:
* Building Tcl interfaces to C libraries
* Working with objects and C++
* Exception handling
* Compilation and linking issues
*  Interface building strategies, pitfalls, and tricks

Gerald W. Lester (For biography please see text in M4pm)
 
Dave Beazley is the developer of SWIG, a freely  available tool for building Tcl, Perl, and Python interfaces to C/C++ applications.  He has worked at Los Alamos National Laboratory and published a variety of articles on the use of scripting environments with high-performance scientific and engineering applications.  He is a PhD candidate at the University of Utah and will be joining the University of Chicago as an assistant professor in the Department of Computer Science.

T2am
Object-Oriented Programming with [incr Tcl]
Michael McLennan,  Bell Labs Innovations for Lucent Technologies, Inc.

Who should attend: Programmers and managers who are using Tcl/Tk to build large, real-world applications.  This tutorial assumes a working knowledge of Tcl/Tk. Some background in object-oriented programming is helpful, though not required.

Tcl/Tk programming is deceptively simple.  You can put together a "Hello, World!" program with just a few lines of code.  But when you start to develop serious applications that require a few thousand lines of code, things can get out of hand.

[incr Tcl] provides a set of object-oriented extensions for the Tcl language.  It helps organize code into high-level building blocks that are easy to develop and maintain.  [incr Tcl] has been around since 1993, so it has become the de facto standard for object-oriented Tcl programming.  It is currently used by thousands of developers and distributed in dozens of commercial applications world-wide.

This tutorial describes object-oriented programming in the context of [incr Tcl].  It presents fundamental concepts, including the class definition syntax, inheritance (is-a relationships), composition (has-a relationships), multiple inheritance, and public/protected/private member protection.  Attendees will gain an understanding of how [incr Tcl] works, and how it can be used to improve their Tcl/Tk programs.

Michael McLennan (For biography please see text in M2am)

T3am
New Features in Tcl 8.0 and Tcl 8.1
Brent Welch, Scriptics Corporation

Who should attend: Tcl script writers and programmers that write extensions for Tcl in C or C++. This course will allow you to take advantage of the new features available in Tcl/Tk 8.0 and Tcl/Tk 8.1, both in Tcl scripts and in C/C++ extensions for Tcl.  Participants are expected to have a basic knowledge of Tcl/Tk, but not necessarily of the latest version. Being familiar with extension writing is helpful, but not mandatory.

This course covers new features in Tcl 8.0 and Tcl 8.1 which affect the C programming APIs much more than the Tcl interface. The course materials will include code samples to illustrate the new features.
The topics covered by the course include:

[square bullet] Tcl scripting
* The namespace facility
* Working with binary data.
* Platform-independent font names and the new font command
* Native menus and the menu bar facility
* The impact of the byte code compiler on script writers

[square bullet] C programming
* The  Tcl 8.0 dual ported object model and the changes to the command
    procedure interface
* Defining a new data type manager
* The Tcl 8.1 internationalization features and the impact on string
    handling by extensions
* The Tcl 8.1 threading model and the impact of thread safety on extensions
 
Brent is a Senior Web Engineer at Scripts Corporation.  He is the author of Practical Programming in Tcl and Tk.  He has developed many applications in Tcl and Tk, including the exam email user interface, the TclHttpd web server, and the WebTk HTML editor.  Brent worked for Xerox PARC for five years and Sun Microsystems Laboratories for three years before joining Scriptics.  Brent received a BSin Aerospace Engineering from the University of Colorado, Boulder, and a PhDin Computer Science from the University of California, Berkeley.
 

T4am
Everything Your Mother Never Told You About ClientData: C Programming With Tcl/Tk
George Howlett, Bell Labs Innovations for Lucent Technologies, Inc.

Who should attend: Application developers and programmers interested in extending Tcl/Tk to better fit their product's needs.  Participants should already know Tcl and C or C++, but expertise is not required.
 
One of the best features of Tcl/Tk is the variety of ways in that you can interface it with your application's code.  Tcl commands and variables can directly link with your application's data.  It's easy to customize Tk to add new widgets or canvas items that better reflect the problem your application is solving.  This tutorial emphasizes advanced techniques for application developers to extend Tcl and Tk.

Topics covered include:
* Representing data through Tcl commands and variables
* Programming with namespaces
* Profiling/debugging Tcl commands
* Creating widgets and canvas items

After completing this tutorial, participants will be aware of many of the techniques used by application developers and Tcl/Tk extension writers to better interface their code with Tcl.
 
George Howlett is a Member of Technical Staff at Bell Laboratories, where he has been developing software for Electronic Computer-Aided Design (ECAD) tools.  He is an ardent fan of Tcl, having built  several CAD applications with it since 1989.  He is the author of the BLT toolkit and the chapter "The BLT Toolkit"  from the book Tcl/Tk Tools.
 
 

T5pm
Building Mega-Widgets with [incr Tk]
Michael McLennan, Bell Labs Innovations for Lucent Technologies, Inc.

Who should attend: Programmers and managers who are using Tcl/Tk to build large, real-world applications.  This tutorial assumes a working knowledge of Tcl/Tk and a basic understanding of [incr Tcl]. Experienced [incr Tcl] developers, and others who have just attended the [incr Tcl] tutorial (T2am), will learn how to create and customize mega-widgets in an object-oriented framework.

Tk widgets can be used to synthesize lots of user interface elements.  For example, with an entry and a few buttons, you can create a spinner component that adjusts the value of an integer. With a label and three sliders, you can build a color selector.
As you build more and more Tcl/Tk applications, you may find yourself building these components over and over for each new project.  Instead, it is better to build them once, encapsulate them, makes them easy to reuse, and store them in a library.

[incr Tk] provides an object-oriented framework for building new user interface components.  These components are called "mega-widgets" since they look and work like ordinary Tk widgets, but they are constructed by using other widgets as component parts.  Mega-widgets can be created without writing a single line of C code, so they are much easier to develop than conventional widgets.  The [incr Tk] framework was used to build the popular [incr Widgets] package which contains over 40 mega-widgets, including a tabbed notebook, an HTML viewer, a combo box, a spinner, and many others.

We will see how:
* Component widgets are tied together
* Configuration options are merged into a composite list
* Mega-widgets can be used to build other mega-widgets: inheritance and composition

Michael McLennan (For biography please see text in M2am)

T6pm
Tcl and Java Programming: Practice and Pitfalls
John Reekie and Christopher Hylands, University of California, Berkeley

Who should attend: Tcl programmers interested in interfacing Tcl scripts to Java, and Java programmers interested in adding high-level scripting to their Java applications. Participants should have some exposure to Tcl, the basic principles of object-oriented programming, and be confident enough to "pick up" new syntax as needed.

Tcl Blend and Jacl are interfaces that allow Tcl scripts and Java classes to communicate. Tcl Blend uses the Java Native Interface and is written in C, while Jacl is a Tcl interpreter written in Java. This tutorial will show how, when, and why to effectively use these interfaces. After completing this tutorial, participants will understand the strengths and weakness of the two interfaces, the relative strengths of Tcl and Java, and will have the knowledge to evaluate them for their own applications.
Topics covered include:
[square] Basics:
* Overview of Tcl Blend and Jacl
* How to create and call Java objects from Tcl: variable lifetime issues
[square] Applications:
* Writing Tcl extensions in Java
* Tcl JavaBean
* Tcl test scripts for Java packages
* Adding Tcl front-ends to Java subsystems
[square] Practical hints and tricks:
 * Sing System.out.println
 * Printing the Java stack trace from Tcl
 * Exception handling
[square] Pitfalls:
* JDK1.2 issues
* Type system limitations
* Problems using Jacl in applets
 
Participants should visit the tutorial web page at
https://ptolemy.eecs.berkeley.edu/~johnr/tutorials/tcljava98/
We will be making notes and examples available before the conference.

John Reekie is a post-doctoral researcher for the Ptolemy Project at UC Berkeley, and Christopher Hylands is the software manager.  They are two of the principal authors of Tycho, a Tcl/Tk user interface for the Ptolemy simulator project, and are currently involved in the design and development of the Java version of Ptolemy.  Christopher was also one of the primary outside testers of the Tcl Blend/Jacl release.