Tcl/Tk Commercial Uses - Part 3: Training

This file contains brief descriptions of commercial training options for Tcl/Tk. If you have questions about specific postings, contact the person who made the submission directly. The purpose of this listing is to show that Tcl/Tk is being used in commercial products and to discuss that use.

Part 1 contains a complete index.

Index - Part 3 Only

T1. Training by Lucent Technologies: "Object Oriented Programming with [incr Tcl]"

T2. Training by Computerized Processes Unlimited, Inc: "Introduction to Programming in Tcl/Tk"

T3. Training by Computerized Processes Unlimited, Inc: "Building Graphical User Interfaces in Tk"

T4. Training by Computerized Processes Unlimited, Inc: "Extending Tcl via C"

T5. Training by NeoSoft: "Tcl and Tk: An Applications-Based Approach"

T6. Training by Data Kinetics Ltd.: "Tcl/Tk: What This Means For Your Organization"

T7. Training by Data Kinetics Ltd.: "Building X-Windows Interfaces with Tcl/Tk"

T8. Training by Enniskillen Consulting: "An Intensive Course in Tcl"

T9. Training by Enniskillen Consulting: "An Intensive Course in Tk"

T10. Training by Enniskillen Consulting: "A course in Tcl/Tk Extensions"

T11. Training by Computerized Processes Unlimited, Inc: "Introduction to Expect"

T12. Training by Lucent Technologies: "Building Applications with Tcl/Tk"

T13. Training by Lucent Technologies: "Effective Tcl/Tk Programming"

T14. Training by Net Mgmt. Solutions Inc: "Building Network Management Tools With Tcl/Tk"

T15. Training by Scriptics: "Building Applications with Tcl/Tk"

T16. Training by Scriptics: "Effective Tcl/Tk Programming"

T17. Training by Scriptics: "Object-Oriented Programming with [incr Tcl]"

Each posting is prefaced by a line with dashes so you can search to the beginning of the next message.

Please submit further postings to gwl@cpu.com

ENTRY T1. - Object Oriented Programming with [incr Tcl]

Usage: Training
Company: Bell Labs Innovations for Lucent Technologies
Contact: Michael J. McLennan
Email: mmclennan@lucent.com

COURSE INFORMATION

Course Title:
Object-Oriented Programming with [incr Tcl]

Course Length:
2 days

Course Format:
Lectures and hands-on programming activities

Prerequisites:
"Building Applications with Tcl/Tk" or familiarity with Tcl/Tk

Books Provided:
Bell Labs course notes

Course Description:
When Tcl/Tk scripts grow larger than a few hundred lines, the code complexity can be difficult to manage. [incr Tcl] provides a set of object-oriented extensions for the Tcl language, enabling programmers to write high-level building blocks that are more easily assembled into a finished application. This course describes object-oriented programming with [incr Tcl]. It describes fundamental concepts-- such as "is-a" versus "has-a" relationships and multiple inheritance-- in the context of [incr Tcl], and demonstrates how object-oriented programming can be used to develop Tcl/Tk applications.

COURSE OUTLINE:

DAY 1:

[incr Tcl] Basics

class definitions
protected data members
member functions (methods)
creating and using objects

Nifty Features

public data members
using "info" to query class information
designing access methods
common data members
common functions (procs)

Inheritance

inheritance ("is-a" relationships)
composition ("has-a" relationships)
inheritance/composition tradeoffs
object construction process
object destruction process
resolving name conflicts
using "isa" to validate objects
multiple inheritance

Namespaces

what is a namespace?
using "import" to connect namespaces
scoping commands and variables
creating well-packaged libraries

DAY 2:

[incr Widgets]

overview of the [incr Widgets] library
using mega-widgets to build applications
how mega-widget options get configured
using the "child-site" to customize mega-widgets

[incr Tk]

overview of [incr Tk] library
Widget example: text widget with an automatic scrollbar
using "itk_component" to register components
using "itk_option" to create new widget options
Toplevel example: info dialog box
mega-widgets with inheritance
mega-widgets with composition

Putting It All Together

using [incr Tcl] objects with [incr Tk] widgets
building a man page facility

Integrating C code

writing C handlers for methods/procs
registering C handlers
integrating C code into [incr Tcl] classes
accessing [incr Tcl] data members from C
accessing [incr Tcl] member functions from C

For pricing and availability information, please contact:

Michael J. McLennan
Bell Labs Innovations for Lucent Technologies
1247 S. Cedar Creast Blvd., Rm 2C-226
Allentown, PA 18103
Voice: (610)-712-2842
FAX: (610)-712-2773
E-Mail: mmclennan@lucent.com
URL: http://www.tcltk.com/training

ENTRY T2. - Introduction to Programming in Tcl/Tk

Usage: Training
Company: Computerized Processes Unlimited, Inc.
Contact: Gerald W. Lester
Email: gwl@cpu.com

Course Title:

Introduction to Programming in Tcl

Course Length:

Two (2) days

Course Format:

Course material is presented in a lecture format and through a hands-on laboratory using a network of X terminals connected to a RISC workstation.

Course Description:

This course introduces the participant to programming in Tcl/TclX.

Topics include:

Variables
Arrays
Lists
Keyed Lists
Syntax
Flow control
Procedures
- Creating
- Invoking
- Passing variables
- Passing arrays
- Passing lists
Running programs from Tcl
Communicating with child processes
Signal handling
Error processing
Accessing system facilities
Programming techniques
- Using autoloading procedures
- Proper use of quoting

Course Level:

Technical: Beginner to Intermediate

Prerequisites:

Use of vi or emacs editors; exposure to programming concepts; use of csh/ksh (not programming).

For pricing and availability information, please contact:

 Gerald W. Lester                        
 Computerized Processes Unlimited, Inc.
 4200 S. I-10 Service Road, Suite #205   
 Metairie, LA  70001

 Voice:  (504) 889-2784
 FAX:    (504) 889-2799
 E-Mail: gwl@cpu.com

ENTRY T3. - Building Graphical User Interfaces in Tk

Usage: Training
Company: Computerized Processes Unlimited, Inc.
Contact: Gerald W. Lester
Email: gwl@cpu.com

Course Title:

Building Graphical User Interfaces in Tk

Course Length:

2 Days

Course Format:

Course material is presented in a lecture format and re-enforced through a hands-on laboratory using a network of X terminals connected to a RISC workstation.

Course Description:

This course introduces the participant to building graphical user interfaces using Tcl/Tk.

Topics include:

Background Concepts
A tour of the widgets
Adding Bindings
Widget Class Bindings
Geometry Managers
Running programs from Tcl/Tk
Communicating with child processes
Writing widgets in Tcl/Tk
Programming techniques
- Proper use of quoting
Interface Builders for Tk

Course Level:

Technical: Beginner to Intermediate

Prerequisites:

CPU's "Introduction to Programming in Tcl" course or understanding and experience using Tcl

For pricing and availability information, please contact:

 Gerald W. Lester                        
 Computerized Processes Unlimited, Inc.
 4200 S. I-10 Service Road, Suite #205   
 Metairie, LA  70001

 Voice:  (504) 889-2784
 FAX:    (504) 889-2799
 E-Mail: gwl@cpu.com

ENTRY T4. - Extending Tcl via C

Usage: Training
Company: Computerized Processes Unlimited, Inc.
Contact: Gerald W. Lester
Email: gwl@cpu.com

Course Title:

Extending Tcl via C

Course Length:

1 Day

Course Format:

Course material is presented in a lecture format and through a hands-on laboratory using a network of X terminals connected to a RISC workstation.

Course Description:

This course teaches how to add new commands to Tcl via C.

Topics include:

Approaches to adding commands
- Action vs Object
New tcl/tk shell vs embedding
Creating a new Tcl Command
Returning Results
Creating a new shell
Conversion functions
Accessing Tcl variables
Mapping Tcl variables to C variables
Tracing Tcl variables
Executing Tcl commands from C
Embedding into an applications

Course Level:

Technical: Intermediate to Advanced

Prerequisites:

Use of vi or emacs editors; knowledge of Tcl; C programming experience.

For pricing and availability information, please contact:

 Gerald W. Lester                        
 Computerized Processes Unlimited, Inc.      
 4200 S. I-10 Service Road, Suite #205   
 Metairie, LA  70001

 Voice:  (504) 889-2784
 FAX:    (504) 889-2799
 E-Mail: gwl@cpu.com

ENTRY T5. - Tcl and Tk: An Applications-Based Approach

Usage: Training
Company: NeoSoft
Contact: Karl Lehenbauer
Email: sales@NeoSoft.com.

NeoSoft Tcl and Tk Training Information

NeoSoft is perhaps the premier corporate contributor to the Tcl and Tk toolkit efforts. Our groundbreaking work in Tcl and Tk dates back to its first appearance in 1990, and is reflected by the copious amount of concepts and code taken from Extended Tcl for use in the Tcl baseline. We continue to collaborate with Dr. John Ousterhout, the author of baseline Tcl and Tk, on the forthcoming release of Tcl 7.0 and Extended Tcl 7.0.

NeoSoft's Tcl training efforts have been a natural outgrowth of our work with, and extensions of, Tcl.

The philosophy of the course is one of immediate, maximum impact by rapid immersion into hands-on building of X-windows graphical user interfaces and the Tcl programs that underly a number of useful applications. This approach grew out of our first-generation Tcl training course, where we discovered that students became very excited once the Tk toolkit was introduced and they could begin typing statements and interactively creating sophisticated X-windows interfaces.

This same philosophy is the backbone of a book we're writing, Tcl and Tk: An Applications-Based Approach, due to be published in the first quarter of 1994 by Prentice-Hall Technical Publications.

Training Options

We are flexible and can customize a course to your specific needs. We have found that almost everyone is content with one of a few options. The class lasts for two or three days, at your option. The class can be structured to support new Tcl and Tk users and/or users with significant prior experience. In either case, it is nice to allocate some unstructured time at the end of the class to talk about specific applications and issues that the students are interested in, including new users, approaches, tools, environments, and the future of Tcl itself.

Course Location and Times

The course can be taught at your company's facility, or at our training facility located in Houston, Texas. Enrollment is limited to ten people per class to provide a substantial amount of instructor attention to each student. If the course it to be held at your company's facility, there should be no less than one workstation per two students, if at all possible. The class can be taught over a weekend. Contact NeoSoft for pricing and availability.

Instructor

The class will be taught by Karl Lehenbauer, the co-author of Extended Tcl. Karl is an experienced trainer, having taught and/or developed previous courses on Unix, Unix system administration and Tcl/Tk.

Course Goals

Teach Tcl and Tk with the maximum impact by building real world applications in the classroom.

Site Prerequisites

Integrated copy of Tcl and Tk, including Extended Tcl, running on site.

Course Contents

Below is the list of basic sections of the class, beginning with the elementary things that we would teach to users without prior Tcl experience and ending with building several tools that are useful, real-world applications in their own right. We can work with you to tailor the course to your organization's specific needs.

Section 1 Hello, World

Concepts:
	Typing commands interactively into the interpreter.
	The most important command in Tcl: "proc"
	Passing arguments to Tcl procedures.
	The C "Hello, World" koan in a graphical context:
The button command
The pack command

Section 2 Making Choices with Buttons

Concepts:
	Variables and variable substitution
	Radiobuttons
	Checkbuttons
	More on the pack command

Section 3 A quartet of application launchers

Concepts:
	Launching applications
	Tcl Language elements:
		Variable assignment
		Conditional expressions
		Beginning file I/O
		Square-bracket substitution
		Generating window elements from data
		Accessing command line arguments

Section 4 Building a support library:  The dialog box

Concepts:
	The message widget
	Control structures:  if/else/endif
	Default values for procedure arguments
	First mention of Tk's event loop
	Subordinate toplevel windows
	'tkwait' to support sequential control
	
Section 5 Building pulldown and popup menus

Concepts:
	The menu widget
	Binding commands to keypress events

Section 6 A few simple but useful applications

Concepts:
	Intermediate file I/O
	Delayed execution with 'after'
	Temporal commands (getclock, fmtclock)
	Capturing a spawned command's output in a variable

Section 7 Building a support library: The file selector

Concepts:
	The listbox and scrollbar widgets
	The frame widget
	More about the packer

Section 8 Creating a text editor with the text widget

Concepts:
	The text widget
	Text widget tags
	More about key bindings
Integrating support library examples

Section 9 Creating a hypertext system with the text widget

Concepts:
	More about the text widget
	More about text widget tags
	Builds on the text editor



Section 10 X resource customizer

Concepts:
	Use of the "send" command to access another interpreter.
	More about text widget tags.
	Builds on the text editor to make a new tool.

Section 11 Introduction to the canvas widget

Concepts:
	Introduces the canvas widget.
	Tags and tag processing.
	More on list processing.
           Use of different canvas widget types.

Section 12 A second encounter with the canvas widget

Concepts:
	Commands and options within the canvas widget.
	Combining items with actions.
	A new application launcher.

Section 13 Creating a drawing tool with the canvas widget

Concepts:
	Traversing items within a canvas widget.

Section 14 Sysadmin tool:  New user creator

Section 15 Sysadmin tool:  ttytab editor

Section 16 Developer tool:  The proc browser

Concepts:
	More on using "send" to access another interpreter.
	Using "info" to find variables and procedures.
           Using entry widgets.

Section 17 Color editor

Concepts:
	Slider widget
	Performing math with the "expr" command

To set up a support contract, or if you need more information, please contact us at +1 713 684 5969 9-4 M-F, or send email to sales@NeoSoft.com.

Tcl/Tk: What This Means For Your Organization

Usage: Training
Company: Data Kinetics Ltd.
Contact: Education Services
E-mail: education@dkl.com

Course Title:

Tcl/Tk: What This Means For Your Organization

Course Length:

One (1) day

Course Format:

Course material is presented in a lecture format.

Course Description:

This seminar is intended for managers, programmers and system engineers who wish to gain a quick understanding of Tcl/Tk. The focus of the seminar is on the practical, not the theoretical. The aim of the seminar is to provide an intensive introduction to the language and the tool kit and to describe how the use of Tcl/Tk can benefit your organization, how other development organizations are using Tcl/Tk, how you can use the products to reduce the time to deliver X-windows applications, what resources are available for the Tcl/Tk developer. Seminar materials include a diskette containing sample applications built with the products as well as reference cards to help you get started.

Course can be customized to meet specific needs of clients.

Topics include:

An Overview of Tcl
Comparison with other languages
The parser
Built-in functions
Utility functions
Extensibility interface
The language and its syntax
Procedures

The Tk Toolkit
What is it
Widgets
Geometry managers
Creating interfaces with Tk

Tk Applications
Wish scripts
Presentation package
CASE tool
Computational fluid dynamics
SCADA
System administration
Network monitoring
Database administration
XF
Graphical application builder

Sources of Tcl/Tk
Internet
Other sources

Other Tcl/Tk Resources
Literature
Training
Consulting

For pricing and availability information, please contact:

Education Services
Data Kinetics Ltd.
2460 Lancaster Road
Ottawa, ON K1B 4S5
Canada

Voice: (613)-523-5500
Fax: (613)-523-5533
E-mail: education@dkl.com

Building X-Windows Interfaces with Tcl/Tk

Usage: Training
Company: Data Kinetics Ltd.
Contact: Education Services
E-mail: education@dkl.com

Course Title:

Building X-Windows Interfaces with Tcl/Tk

Course Length:

Three (3) days

Course Format:

Course material is presented in a lecture format and through extensive hands-on experience where each student works through the class exercises at his individual UNIX workstation..

Course Description:

This seminar is intended for programmers and system engineers who wish to build applications using the X-Windows interface. Class size is limited to ten students to allow for substantial student-instructor interaction. Materials provided include a workbook, a diskette containing sample applications and reference cards.

Course can be customized to meet specific needs of clients.

Topics include:

"Hello World"
Typing interactive commands into the interpreter
The button command
The (elementary) pack command
Widget configuration
The "proc" the heart of Tcl/Tk

Using Buttons to Make Choices
Variables and variable substitution
Radiobuttons
Checkbuttons
The (intermediate) pack command

Launching Applications
How to launch an application from Tcl/Tk
Tcl language elements
- Variables, creation, assignment, destruction
- Conditional expressions
- Square bracket substitution
- Generating window elements from data
- Command line arguments
- Entry level file I/O
The Dialog Box
The message widget
Control structures if/else
Default values for arguments
Tk's event loop
Sub-ordinate windows
Sequential application control with tkwait

Menus
Menu widget
Pulldown and Popup
Binding commands to interface elements

The File Selector
Listbox and scrollbar widgets
Frame widget
The (advanced) pack command

A Text Editor
The text widget
Text "tags"
Key bindings
Hypertext

Creating a Drawing Tool with the Canvas Widget
The canvas widget
"tags" and tag processing
List processing
Canvas widget options
Traversing items within a canvas

A Color Editor
The slider widget
Math with "expr"

Developer's Tools
Browsing procs
The "send" command
"info" command to find variables and processes
Entry widgets

A Tcl Debugger

For pricing and availability information, please contact:

Education Services
Data Kinetics Ltd.
2460 Lancaster Road
Ottawa, ON K1B 4S5
Canada

Voice: (613)-523-5500
Fax: (613)-523-5533
E-mail: education@dkl.com

ENTRY T8. - An Intensive Course in Tcl

Usage: Quick start to programming in Tcl for experienced programmers.
Company: Enniskillen Consulting, 3396 Enniskillen Circle, Mississauga,
Ontario, Canada, L5C 2N1.
Contact: Paul Wujek
Email: wujek@inforamp.net
Voice: (905) 279-5885

A 1 day course for experienced programmers covering Tcl language, syntax, usage and programming of 'C' language extensions to Tcl.

This course is customizable, given on site, at customer premises.

ENTRY T9. - An Intensive Course in Tk

Usage: Quick start to progamming in Tk for programmers experienced with GUI
concepts.
Company: Enniskillen Consulting, 3396 Enniskillen Circle, Mississauga,
Ontario, Canada, L5C 2N1.
Contact: Paul Wujek
Email: wujek@inforamp.net
Voice: (905) 279-5885

A 2 day course for experienced GUI programmers covering Tk concepts, and usage.

This course is customizable, given on site, at customer premises.

ENTRY T10. - A course in Tcl/Tk Extensions

Usage: A course covering the standard extensions to Tcl, and Tk
Company: Enniskillen Consulting, 3396 Enniskillen Circle, Mississauga,
Ontario, Canada, L5C 2N1.
Contact: Paul Wujek
Email: wujek@inforamp.net
Voice: (905) 279-5885

A 1 day course that examines some of the standard extensions to Tcl/Tk: TclX - standard file handling extensions, etc Tcl-dp - distributed processing, TCP/IP, RPC oratcl - Oracle database extensions sybtcl - Sybase database extensions Tix - Motif style GUI for Tk blt - Graphics extensions

ENTRY T11. Introduction to Expect

Computerized Processes Unlimited, Inc. (CPU) offers a course in Expect, an extension to the Tcl/Tk technology. Our course can be presented at either CPU's training facility or at the client site. CPU's training facility is located in the New Orleans area. While CPU has a standard course, the course can be customized to suit your needs.

Course Length
Three (3) days if proficient in Tcl, five (5) days if not

Course Format
Course material is presented in a lecture format and reinforced through hands-on laboratory using a network of X Window System terminals connected to a RISC workstation.

Course Description
This course introduces you to programming in Expect. The following topics are covered:

Background concepts
Automating processes
- Partial and full automation
Sending and receiving data and commands
Pattern matching
- Techniques and timing
Debugging scripts
Spawning processes
Communicating with multiple processes
Communicating with a process and a user
Signal handling
Background processing

Course Level
Technical--intermediate to advanced

Prerequisites
Use of vi or emacs editors
Knowledge of Tcl
Knowledge of UNIX
Experience with C-language programming helpful

For pricing and availability information, please contact:

 Gerald W. Lester                        
 Computerized Processes Unlimited, Inc.
 4200 S. I-10 Service Road, Suite 205   
 Metairie, LA  70001

 Voice:  (504) 889-2784
 FAX:    (504) 889-2799
 E-Mail: gwlester@cpu.com

ENTRY T12. - Building Applications with Tcl/Tk

Usage: Training
Company: Bell Labs Innovations for Lucent Technologies
Contact: Michael J. McLennan
Email: mmclennan@lucent.com

COURSE INFORMATION

Course Title: Building Applications with Tcl/Tk

Course Length: 3 days

Course Format: Lectures and hands-on programming activities

Prerequisites: familiarity with Unix and some programming language

Books Provided: John Ousterhout's "Tcl and the Tk Toolkit" (Addison-Wesley) and Bell Labs course notes

Course Description:

Applications with short development cycles have the best chance for success in today's marketplace. Tcl/Tk provides an interactive development environment for building Graphical User Interface (GUI) applications with incredible speed. Tcl/Tk applications look like they were constructed with the Motif toolkit, but they can be written in a fraction of the time. This is due, in part, to the high-level programming interface that the Tcl language provides. It is also due to the interpretive nature of the environment; changes made to a Tcl/Tk application can be seen immediately, without waiting for the usual compile/link/run cycle. Developers can prototype new ideas, review them with customers, and deliver a finished product within a span of several weeks. This course provides a hands-on introduction to Tcl/Tk. It teaches fundamental concepts like how to create widgets, how to "pack" them together, and how to "bind" new behaviors to events. It shows how real applications, like a Solitaire card game, can be built a little at a time, and gradually improved to production quality. It illustrates some of the finer points of the Tcl language in the context of real applications. It even includes tips and techniques for Tcl masters.

COURSE OUTLINE

DAY 1:

Tcl/Tk Basics

using "wish"
"Hello World" GUI example
anatomy of a Tk widget
configuration options

Making Widgets Work Together

variables
checkbuttons, radiobuttons, listboxes and scrollbars
understanding the event loop
using images
quoting rules
procedures
local versus global scope

Understanding the "pack" Facility

filling the cavity
pack options
handling resizable windows
make your packing job simple
widget hierarchy

Understanding the "grid" Facility

putting widgets in rows and columns
making grids resizable

DAY 2:

A Closer Look at Tcl

building and manipulating lists
defining and using arrays
conditionals and looping *
style

Simple Applications

manipulating images
procedures with optional arguments
procedures with variable argument lists
tracing down errors

Tapping into Events

how events work
using the "bind" command
overview of the "canvas" widget
simple sketch pad program
rubberbanding on the canvas Menu Bars
creating menu bars
cascade menus
menu accelerators

Dialogs

dialog boxes
using "grab" to implement modal dialogs
centering dialogs on the screen

DAY 3:

Building Text Displays

overview of the "text" widget
setting tab stops
using tags to apply text styles

Managing Files and Processes

overview of file-related commands
opening and closing files
reading and writing files
using "scan" and "regexp" for parsing input
using "catch" to handle errors
using "exec" to execute other Unix processes
using "open" to open pipes

Adding Extensions in C

software architecture
popular extensions: [incr Tcl], BLT, TclX
writing a command-handling procedure
creating a customized "wish"
mix and match with other extensions
trade-offs

For pricing and availability information, please contact:

ENTRY T13. - Effective Tcl/Tk Programming

 Usage: Training
 Company: Bell Labs Innovations for Lucent Technologies
 Contact: Michael J. McLennan
 Email: mmclennan@lucent.com

COURSE INFORMATION

Course Title:
Effective Tcl/Tk Programming

Course Length:
2 days

Course Format:
Lectures and hands-on programming activities

Prerequisites:
"Building Applications with Tcl/Tk" or familiarity with Tcl/Tk

Books Provided:
"Effective Tcl/Tk Programming" (Addison-Wesley) and Bell Labs course notes

Course Description:
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. This course draws on the lessons learned from writing many thousands of lines of Tcl/Tk code. It describes design paradigms and coding techniques that make it easier to build Tcl/Tk applications. In particular, it shows how to:

Handle data structures in Tcl
Package Tcl/Tk code into reusable libraries
Use bindings and bind tags
Create interactive displays with the "canvas" widget
Create customized editors with the "text" widget
Create new geometry managers like a tabbed notebook or a paned window
Implement client/server architectures
Protect your applications with "safe" interpreters
Deliver Tcl/Tk applications that are easy to configure and install

More than anything else, this course shows the techniques that will help make your Tcl/Tk projects a success.

For pricing and availability information, please contact:

ENTRY T14. - Building Network Management Tools With Tcl/Tk

 Usage: Training
 Company: Net Mgmt Solutions Inc. 
 Contact: Jerry Puoplo 
 Email: info@net-mgmt-solutions.com 
 Web: http://www.net-mgmt-solutions.com/training.htm
 Phone: 617-975-2010

Net Mgmt Solutions Inc. offers training, sample applications, and custom tool development help to network managers on how to build network management tools using Tcl with SNMP. The focus of our company is to help network managers and system engineers better meet their network management needs. We have observed that most companies fail to manage multi-vendor environments effectively because they overlooked the importance of customized management tools.

Custom tools built using Tcl with SNMP extensions are ideal for network managers and system engineers. Without being programmers, they can extend and build many useful management tools this way. Marshall Rose and Keith McCloghrie wrote a book about this back in 1995, so the idea is not new. What is new is that there are now shrink-wrap versions of Tcl with SNMP extensions for both UNIX and WIN/NT. With the availability of SNMP Research's shrink-wrap TickleMan/Lite product and the upcoming shrink-wrap version of Scotty for NT, deploying a custom tools strategy around Tcl has gotten even easier for network managers and system engineers.

We have several sample management applications that we built using TickleMan/Lite, a product developed by SNMP Research International which we resell with our applications. Our company also plans to release what we call Toolchest 1.0 in May. Toolchest 1.0 will consist of a set of powerful diagnostic and configuration tools all again written using TickleMan. By using Tcl, we can build the tools quicker and our customers can customize them if they are so inclined.

Entry T15 - Building Applications with Tcl/Tk

Usage: Training
Company: Scriptics
Contact: Lee F. Bernhard
Email: lee.bernhard@scriptics.com

Course Description

This course provides a hands-on introduction to Tcl/Tk. Our approach teaches the Tcl language syntax while building GUI applications, an approach that is both exciting and practical. Students learn fundamental GUI concepts like how to create widgets, how to lay them out, and how to "bind" new behaviors to events. The course shows how real applications, like a Solitaire card game, can be built a little at a time, and gradually improved to production quality. Such examples illustrate some of the finer points of the Tcl language in the context of real, graphical applications.

Course Outline

Day 1

Tcl/Tk Basics
- using wish
"Hello World" GUI example
- anatomy of a Tk widget
- configuration options
Making Widgets Work Together
- variables
- checkbuttons, radiobuttons, listboxes and scrollbars
- understanding the event loop
- using images
- quoting rules
- procedures
- local versus global scope
Understanding the pack Facility
- filling the cavity
- pack options
- handling resizable windows
- make your packing job simple
- widget hierarchy
Understanding the grid Facility
- putting widgets in rows and columns
- making grids resizable

Day 2

A Closer Look at Tcl
- building and manipulating lists
- defining and using arrays
- conditionals and looping
- coding style
Simple Applications
- manipulating images
- procedures with optional arguments
- procedures with variable argument lists
- tracing down errors
Tapping into Events
- how events work
- using the bind command
- overview of the canvas widget
- simple sketch pad program
- rubberbanding on the canvas
Menu Bars
- creating menu bars
- cascade menus
- menu accelerators
Dialogs
- dialog boxes
- using grab to implement modal dialogs
- centering dialogs on the screen

Day 3

Building Text Displays
- overview of the text widget
- setting tab stops
- using tags to apply text styles
Managing Files and Processes
- overview of file-related commands
- opening and closing files
- reading and writing files
- using scan and regexp for parsing input
- using catch to handle errors
- using exec to execute other Unix processes
- using open to open pipes
Adding Extensions in C
- software architecture
- popular extensions: [incr Tcl], BLT, TclX
- writing a command-handling procedure
- creating a customized wish
- mix and match with other extensions
- trade-offs

For pricing and availability information, please contact:

Lee F. Bernhard
Scriptics Corporation
2275 E. Bayshore Rd. Ste 101
Palo Alto, CA 94303
Voice: (650)-843-6914
FAX: (650)-843-6909
E-Mail: lee.bernhard@scriptics.com
URL: http://www.scriptics.com/training

Entry T16 - Effective Tcl/Tk Programming

Usage: Training
Company: Scriptics
Contact: Lee F. Bernhard
Email: lee.bernhard@scriptics.com

Course Description

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.

This course draws on the lessons learned from writing many thousands of lines of Tcl/Tk code. It describes design paradigms and coding techniques that make it easier to build Tcl/Tk applications. In particular, it shows how to:

Create interactive displays with the canvas widget
Create new geometry managers like a tabbed notebook
Communicate with other programs by using pipes and sockets
Use "safe" interpreters to add security to your applications
Create client/server applications
Handle data structures in Tcl
Package Tcl/Tk code into reusable libraries
Use binding tags to add and remove widget behaviors
Create web-based applications

More than anything else, this course shows the techniques that will help make your Tcl/Tk projects a success.

Course Outline

Day 1

Canvas: Interactive Displays
- canvas items
- tagging items with symbolic names
- binding to the canvas as a whole
- binding to canvas items
- interactive drawing editor
Canvas: Handling Size Changes
- scrolling model
- zoom feature
- screen coordinates vs. canvas coordinates
- bindings that handle size changes
- bounding box calculations
Communicating with Other Programs
- using exec to execute other programs
- read pipes and asynchronous file handling
- write pipes
- bidirectional pipes
- solving buffering problems
Safe Interpreters
- using Tcl commands as a communication protocol
- security issues
- using safe interpreters
- command aliases
- assembling multiline messages
Network Programming with Sockets
- client/server interaction
- example: network math server
- testing the math server
- example: network math client
- using the client with the server

Day 2

Component Libraries
- structure of reusable components
- creating data structures
- writing library procedures
- setting up autoloading
- setting up packages
Advanced Packing Techniques
- notebook component
- packing and unpacking pages
- computing widget sizes
- using the after command
Advanced Canvas Techniques
- tabnotebook component
- "eventually redraw" technique
- inventing component resources
- using tags to identify items
- binding for selection
- invisible sensors
Binding Tags
- binding model
- using the bindtags command
- using binding tags to change widget modes
- using break to interrupt event processing
- entry validation
- binding to top-level windows
Balloon Help
- balloon help facility
- unmanaged windows
- adding balloon help to an application
- balloon help on the Help menu

Appendix
Web-Based Applications
- creating Tcl/Tk applets
- client/server applications
- example: chat applet
- using Tcl to write CGI scripts

For pricing and availability information, please contact:

Entry T17 - Object-Oriented Programming with [incr Tcl]

Usage: Training
Company: Scriptics
Contact: Lee F. Bernhard
Email: lee.bernhard@scriptics.com

Course Description

When Tcl/Tk scripts grow larger than a few hundred lines, the code complexity can be difficult to manage. [incr Tcl] provides a set of object-oriented extensions for the Tcl language, enabling programmers to write high-level building blocks that are more easily assembled into a finished application. This course describes object-oriented programming with [incr Tcl]. It describes fundamental concepts-- such as "is-a" versus "has-a" relationships and multiple inheritance-- in the context of [incr Tcl], and demonstrates how object-oriented programming can be used to develop Tcl/Tk applications.

Course Outline

Day 1

[incr Tcl] Basics
- class definitions
- protected data members
- member functions (methods)
- creating and using objects
Nifty Features
- public data members
- using "info" to query class information
- designing access methods
- common data members
- common functions (procs)
Inheritance
- inheritance ("is-a" relationships)
- composition ("has-a" relationships)
- inheritance/composition tradeoffs
- object construction process
- object destruction process
- resolving name conflicts
- using "isa" to validate objects
- multiple inheritance
Namespaces
- what is a namespace?
- using "import" to connect namespaces
- scoping commands and variables
- creating well-packaged libraries

Day 2

[incr Widgets]
- overview of the [incr Widgets] library
- using mega-widgets to build applications
- how mega-widget options get configured
- using the "child-site" to customize mega-widgets
[incr Tk]
- overview of [incr Tk] library
- Widget example: text widget with an automatic scrollbar
- using "itk_component" to register components
- using "itk_option" to create new widget options
- Toplevel example: info dialog box
- mega-widgets with inheritance
- mega-widgets with composition
Putting It All Together
- using [incr Tcl] objects with [incr Tk] widgets
- building a man page facility
Integrating C code
- writing C handlers for methods/procs
- registering C handlers
- integrating C code into [incr Tcl] classes
- accessing [incr Tcl] data members from C
- accessing [incr Tcl] member functions from C

For pricing and availability information, please contact:

Please send posts, comments and queries to gwlester@cpu.com.
Computerized Processes Unlimited Home

Tcl/Tk Commercial Uses - Part 3: Training

Index - Part 3 Only

NeoSoft Tcl and Tk Training Information

Training Options

Course Location and Times

Instructor

Course Goals

Site Prerequisites

Course Contents

Course Title:

Tcl/Tk: What This Means For Your Organization

Course Length:

One (1) day

Course Format:

Course material is presented in a lecture format.

Course Description:

Topics include:

An Overview of Tcl

The Tk Toolkit

Tk Applications

Sources of Tcl/Tk

Other Tcl/Tk Resources

For pricing and availability information, please contact:

Course Title:

Building X-Windows Interfaces with Tcl/Tk

Course Length:

Three (3) days

Course Format:

Course material is presented in a lecture format and through extensive hands-on experience where each student works through the class exercises at his individual UNIX workstation..

Course Description:

Topics include:

"Hello World"

Using Buttons to Make Choices

Launching Applications

The Dialog Box

Menus

The File Selector

A Text Editor

Creating a Drawing Tool with the Canvas Widget

A Color Editor

Developer's Tools

A Tcl Debugger

For pricing and availability information, please contact:

Course Description

Course Outline

Day 1

Day 2

Day 3

Course Description

Course Outline

Day 1

Day 2

Course Description

Course Outline

Day 1

Day 2