This course is an intensive workshop-approach introduction to the basic
features of TAL syntax and in the use of Inspect. This course will
both give you a very solid foundation in TAL, as well as using Inspect.
The course is presented as a workshop involving many short, interactive, hands-on, coding exercises, which are
then examined using Inspect, followed by a formal lab at the end of the module.
Course Duration: 5 days (on-site only)
Anyone who will be maintaining or developing code in TAL.
- TAL as a programming language
- Use of pointers, arrays, and strings
- Thorough hands-on workshop approach
- Extensive use of Inspect
- Hands-on mini-labs throughout module presentation, followed by a formal lab after each module
- PLS Features and Fundamentals course
6 months of heavy use of Tandem editors and run commands
- The student is expected to be familiar with basic Tandem precepts and basic jargon.
The student is also expected to understand programming in C, C++, Java, BAL, or other
block-structured or lower-level language. Familiarity with COBOL is helpful for program sturctures,
but is less helpful than languages that use pointers.
- Chapter 1: Dealing with a machine-dependent language
- TAL is machine-dependent. This is not the case with C and COBOL,
which were designed with platform neutrality in mind from the beginning.
TAL is unapologetically machine-dependent, and to present it any other way
will not effectively present the strengths of TAL.
- Inspect is introduced, and simple variables are declared, manipulated
and observed. The concept of memory address versus memory content is
brought out. The concept of memory map is introduced and the idea
that the same piece of data can (often) be reached by either string or
- Global data declarations are used to initialize memory, and addresses
are observed in Inspect to bring out the string/word addressing dichotomy.
- Chapter 2: Binary theory and practice
- Describing how many different things can be presented or signified in n bits.
- Handling negative numbers
- Handling absolute values such as addresses.
- Handling positive and negative signed numbers and finding out what they look like inside the machine.
- Look at some bits and tell whether they're a number, or text.
- Use Inspect to understand the characteristics of signed and unsigned binary,
and to corroborate our results with the binary computation capabilities of
the standard Windows calculator in scientific mode
- Chapter 3: Global variables
- Declare direct variables and arrays, and exceed the 256-word Global Direct limit
- Cover arrays and structures (direct and indirect) and show how that introduces the
Global Primary versus Global Secondary distinction and avoids the Global Direct limit
- Declare very large arrays that will exceed the 32Kword Procedure Stack limit.
- Introduce extended indirect arrays and structures and learn how to handle 127.5 Mbytes of data.
- Chapter 4: The Procedure Call Stack, Part One
- Manipulate global variables programmatically, make a preliminary study of routines that
call routines, observe the dynamic growth and shrinkage of the Procedure Call Stack in
the lower 32K words of the User Data Space
- Launch an infinite recursion and exceed the Procedure Call Stack in different
ways to show the tradeoff between Global Variable usage and the Procedure Call Stack depth limit
- Chapter 5: The Procedure Call Stack, Part Two
- Add local variables to the mix, and demonstrate that local variables have the same direct/indirect classification as globals
- Revisit the exceeding-stack scenario to see how it changes when you declare significant amounts of local storage.
- Chapter 6: Variable lifetimes: static versus dynamic
- The lifetime differences between global and local variables will be visited in this chapter,
and pitfalls pointed out and demonstrated.
- Chapter 7: Subprocedures
- The Tandem one-level-deep subprocedure will be demonstrated, along with its strengths and limitations,
like direct sublocal declarations.
- Chapter 8: General TAL Statement Syntax
- Review the TAL statement repertoire with detailed treatment of the more
essential aspects of the language.
- Chapter 9: Introduction to pointers
- Present basic pointer manipulation.
- Cover TAL's pointer arithmetic then explain and contrast it with C's.
Map TAL pointer syntax to C pointer syntax for further clarification.
- Chapter 10: Parameter passing
- Value and reference passing are demonstrated. Reference passing is really value passing,
although the value of a pointer is passed, so this chapter builds on Chapter 9.
- What happens when the "same" parameter is passed down various levels?
Dangers of passing back a pointer to a local variable are covered. Emphasis is on TAL procs.