Advanced Magic Cap Programming

Course Description

Advanced Magic Cap Programming is a three day compantion to Magic Cap Programming. This course extends the introductory course to include advanced programming techniques and the most common questions asked by commercial package developers.. Students use hands-on programming exercises to explore the run-time behavior of Magic Cap and integrate a package tightly into the Magic Cap system.

Target Audience

Programmers with prior Magic Cap programming experience and/or training who seek to create commercial-grade packages. Students will complete hands-on exercises so all should be prepared for modifying Magic Cap software and examining Magic Cap code . Class size is limited to 12 students; class may be canceled if fewer than 8 students register.

Course Outline

• Development and Debugging tools
• User Interface techniques
  • Additional UI classes
  • Building re-usable components
  • Choosing the right interface for your code
• Building quality packages
  • Package installation
  • Programmatic memory management
  • Error handling
  • Debugging
  • Performance Tuning
  • Designing for compatibility
• Communications
  • Using built-in communications: email, printing, faxing, beaming
  • Low-level communications: direct control over the serial port, modem, IR Beam, MagicBus

Prerequisites

At least 1 year of C and object-oriented programming experience are required in order to complete this programming course successfully. You also must complete the Magic Cap programming course. We recommend familiar ity with Macintosh™ and Code Warrior™ .

Price

Open-enrollment courses	$1200 per student
On-site courses (USA)	$15,000 for 10 students or fewer (*) $1300 for each additional student
On-site courses (International)	$17,000 for 10 students or fewer (*) $1300 for each additional student
Dedicated courses	$12,000 for 10 students or fewer $1200 for each additional student

(*) includes instructor travel expenses

Sections and objectives

Development & Debugging Review

This section provides a review of the latest Macintosh-hosted development tools for Magic Cap. It also explains using these tools to help you develop Magic Cap packages in the face of incomplete or missing information.

This section also includes a brief overview of the debugging tools available to Magic Cap developers and gives a demonstration of the source-level debugger.

At the end of this section, you should be able to:

• Build and run a pre-written package in Code Warrior Magic
• Locate the "extra" scripts in Code Warrior Magic
• Given a Magic Cap scene in the simulator:
• Locate its key classes
• Locate those classes, and their operations, in Bowser Pro
• Locate those classes, and their descriptions, in the on-line documentation
• Describe when to use one of the following tools for debugging:
• MC Debug
• MacsBug
• Telebug

Debugging

You may have learned the basics of Magic Cap debugging in the Magic Cap Programming course, but are you an expert? Can you guarantee your package will run onder a variety of conditions? This section concentrates on building debugging code into an application, careful testing of new packages, and low-level debugging using MacsBug.

At the end of this section, you should be able to:

• Describe the difference between "Debug" and "Non-Debug" versions of Magic Cap
• Incorporate debugging macros and assertions into your code
• Add package validation tools to your code
• Test your code using a variety of data types
• Test your application's ability to tolerate resets and power cycles
• Find common problems using MacsBug

User Interface Programming, Part 1

This section discusses some of the common user models built into Magic Cap and how to select which one is appropriate to your package. It also gives you the inside information on drawing viewables, and explains how to use wincows and announcements in your own package.

Some of this material is based on similiar material in the Magic Cap Programming course. We have expanded on those parts to give you a more comprensive view of Magic Cap development.

At the end of this section, you should be able to:

• Given a Magic Cap package's source code:
• Add an announcement to the code containing some text
• Create an object which has a custom Draw method
• Create packages which incorporate stacks of cards
• Select a type of scene that would be appropriate for a new package you wish to create.

Memory Management

Memory management is one of the most critical areas to understand when developing Magic Cap packages. Unlike a desktop machine which has mass storage, Magic Cap keeps a user's information in RAM at all times. This means that package developers have to be very careful with how they use memory. Also, information in RAM is often more vulnerable to corruption than information on a hard disk. Magic Cap provides some protection mechanisms for the user's data in RAM; package developers need to understand how these mechanisms work to make the most efficient packages.

At the end of this section, you should be able to:

• Describe the issues surrounding Copy, Destroy, and shared objects
• Describe how Copy can be used to improve the quality of an object's API
• Describe what happens during a cleanup and how to avoid cleanup-related problems
• Describe how to recover when transient memory is erased
• Describe how to locate and fix memory leaks in your own package

Installation

The Magic Cap Programming course introduced you to the basic concepts behind package installation, namely the Install and Receiver lists. This section goes beyond that basic introduction to introduce:

• How to install objects outdside your package
• Initializing classes and objects at load time
• Allowing your objects to be removed cleanly

At the end of this section you should be able to:

• Choose a location to install your own packages
• List the steps of the process to load Magic Cap packages
• Override the installation process to do custom installation
• Design package objects which can be removed cleanly by Magic Cap
• Create a Scene Additions object which adds commands to the Magic Lamp

Error Handling Using Exceptions

Magic Cap employs a style of error handling known as "Exceptions." This section explains Magic Cap's unique form of exception handling and how you should employ it in your own code.

At the end of this section, you should be able to:

• Define Exception, Try, Catch, and Fail (as used in Magic Cap development)
• Write your own exception handlers
• Define unique exception codes in your own packages
• Describe when to use Try and when to use Catch in designining your own object classes

User Interface Programming, Part 2

This section focuses on building re-usable Human Interface components, or parts that you can use in many different packages. This practice not only saves you time when developing new code but also makes your packages more reliable. Using re-usable interface components reduces the dependancies between your package's code and the human interface which makes packages easier to debug.

At the end of this section, you should be able to:

• Name several re-usabe interface classes which are built into Magic Cap
• Implement a Viewable object which polls another object
• Implement a Viewable object which uses Observe-Notify
• Explain the difference between the Touch, Tap, Press, and Action methods
• Name the three standard mdels that Magic Cap uses for collecting input from the user

Compatibility

Magic Cap is an evolving platform, yet evolving systems in the computer industry often lead to broken applications. This section describes how to write code that will remain compatible as General Magic continues to revise Magic Cap and looks at one specific revision &endash; the transition from Magic Cap 1.0 to 1.5.

At the end of this section, you should be able to:

• Decide whether you wish to use "lowest common denominator" or "test for features"
• compatibility in your package
• Design code which runs correctly on multiple Magic Cap versions (on the same
• processor)
• Describe at least three general changes between versions 1.0 and 1.5 of Magic Cap
• Decribe the issues to watch out for in preparing for Magic Cap 2.0

Performance Tuning

Customers judge the success or failure of a computer partially based on its apparent speed. Magic Cap package developers can improve everybody's chances for success (their own and General Magic's) by avoiding common practices which slow down their code.

This section provides some guidelines for improving a package's performance under Magic Cap.

At the end of this section, you should be able to:

• Describe at least two programming practices which can slow down the execution of a
• Magic Cap package
• Describe workarounds for the problems you named above
• Describe the options for analyzing your code's run-time performance

Connecting Between Packages

Magic Cap is an "open" system where packages can use system resources and interact with other packages. This section explains how your package can interact with other packages and describes the performance implications of this practice.

This is another section which builds on the introductory Magic Cap Programming course. We have added extra details and are allowing more time for exploring this area of Magic Cap development.

At the end of this section, you should be able to:

• Given a package's exported definitions and Citation values, write code to:
• Locate the other package in memory
• Instantiate one of the other package's classes
• Access one of the "exported" objects from that other package
• Call an operation on an imported or instantiated object in that package

Communications

Communications is a key feature of Magic Cap, and no comprehensive discussion of Magic Cap can ignore its communications features. In general, the communications abilities are integrated into the existing Magic Cap framework and you have to do very little to take advantage of them. Still, Magic Cap is an extensible system so you may want to add some communications abilities of your own.

This section discusses both the "high level" communications abilities acessable from the Magic Lamp and the "low level" communications abilities that developers can control directly. This section is just an overview &endash; detailed implementation information can be found in the Magic Cap sample packages from General Magic Developer Technical Support.

At the end of this section you should be able to:

• Describe the basic steps to support faxing, beaming, printing, and mailing user
• information using Magic Cap's built-in frameworks.
• Describe the three ways a package can interact with Magic Cap's mail system.
• Describe the issues surrounding class exchange on Magic Cap.
• Describe the three types of stream-based communications servers in Magic Cap.
• Locate example code which demonstrates how to use the stream-based communications
• servers