Telescript Reference Manual:
Table of Contents

Section I: Beginnings

This section is a two-chapter overview of Telescript that first acquaints the reader with the power and special features of Telescript, then has an overview of object-oriented programming as it's practiced in the Telescript world.

Chapter 1: Introducing Telescript

This chapter shows the special telecommunications needs addressed by Telescript, discusses the consistent environment of the Telescript engine on different platforms, and looks at the agents and places of the Telescript model. This chapter is a preliminarily reviewed first draft.

Chapter 2: The Telescript Object-Oriented Environment

This chapter introduces object-oriented programming in a brief way to programmers who may not have object-oriented experience and--more important--introduces Telescript's specific implementation of object-oriented programming and the terminology Telescript uses.

Section II: Objects

This section serves two main purposes: it introduces the basics of High Telescript syntax so the programmer can work with sample code; and it works through the Telescript foundation classes: primitives, collections, and so on. It views Telescript without custom classes (which are covered in the next section) and without processes (covered in the section after that).

Chapter 3: Basic Elements of Telescript Syntax

This chapter introduces basic HTS syntax for expressions, operators, statements, blocks, comments, and breaks.

Chapter 4: Using an Object's Features

This chapter shows how to call an operation on an object and get or set an attribute. It discusses using multiple features, global variables, escalation, and assertion.

Chapter 5: Using Primitives and Literal Expressions

This chapter thoroughly explains each of Telescript's primitive classes. It also introduces literal expressions and shows how to use them to instantiate primitives.

Chapter 6: Working With Operators, Variables, and Assignments

This chapter introduces operators and operator expressions, and shows how to use operators with primitives. It also introduces variables and shows how to declare and assign them. It discusses variable scope.

Chapter 7: Executing a Simple Script

This chapter puts together a simple script and identifies the parts of script. It introduces the do block, works with simple arithmetic expressions and characters, compares values, uses the dump operation, and introduces the syntax for flow control (if/else, loops, etc.)

Chapter 8: Initializing an Object

This chapter discusses object initialization and constructor expressions--how to provide initialization arguments for class instantiation. It also shows how to derive a class from a class family and create an object from that derived class.

Chapter 9: Working With Collections

This chapter introduces collections and its subclasses--lists, sets, dictionaries, and so on. It discusses matching and the ways to manipulate members of the different collections.

Chapter 10: Handling Text

This chapter discusses text. It introduces strings and patterns, shows how to concatenate and split strings, and talks about analyzing and modifying strings with patterns.

Chapter 11: Expressing Time

This chapter shows how to use Time and CalendarTime objects, and talks about conversions, normalization, and other timely topics.

Section III: Classes

This section introduces all the concepts and conventions necessary for creating custom classes: inheritance, initialization, modules, defining operations, attributes, methods and properties, and more. It also talks about types and passages. It introduces all the Telescript core classes. It views Telescript without processes (which are covered in the following sections).

Chapter 12: Introducing Custom Classes

This chapter introduces the class mechanisms used by Telescript. It shows how to declare a simple custom class, and provides an overview of the full class declaration syntax. The reader should know how to create their own simple custom classes by the end of the chapter. This chapter is a preliminarily reviewed first draft.

* Chapter 13: Working With Modules and Class Interfaces

This chapter discusses modules in detail: how they function, how to declare them, why they're important. It also discusses class interfaces and how they're used to work with custom classes across modules. This chapter is in rough outline form only.

* Chapter 14: Declaring Class IDs, Characteristics, and Inheritance

This chapter discusses in detail everything in a class definition except for declaring operations and attributes. It covers class IDs, sealed and unsealed classes, and concrete and abstract classes, mix-in and flavor superclasses. This chapter is in rough outline form only.

* Chapter 15: Declaring Operations

This chapter shows how to declare an operation, showing all the details except defining the method to go with the operation. It covers the operation ID, abstract or sealed operations, the operation signature, the output result, and specifying exceptions. This chapter is in rough outline form only.

* Chapter 16: Creating Methods

This chapter shows how to create methods to go with an operation. It describes the HTS syntax involved, local variables, properties, throwing exceptions, creating a return value, and more. This chapter is in rough outline form only.

* Chapter 17: Method Execution and Operation Escalation

This chapter shows how a method is executed when an operation is called. It introduces the canonical order of a method search and operation escalation. This chapter is in rough outline form only.

* Chapter 18: Creating an Initialize Operation

This chapter discusses class initialization in detail, and shows how to create an initialize operation for a class. It pays particular attention to escalation order of an initialize operation. This chapter is in rough outline form only.

* Chapter 19: Defining Attributes

This chapter shows how to define attributes in a class definition. It discusses sealed and abstract attributes, nonstandard getters and setters, and more. This chapter is in rough outline form only.

* Chapter 20: Passing Arguments

This chapter shows how arguments are passed through an operation, and discusses constraints and the appropriate HTS syntax. This chapter is in rough outline form only.

* Chapter 21: Using Class Families

This chapter discusses class families in detail. It shows how to derive a class from a family and how to define a custom class family. It discusses formals and actuals, and how formals may be used with superclass families. This chapter is in rough outline form only.

Section IV: Processes

This section introduces processes and the Telescript mechanisms that affect processes but aren't too specifically tied to the concepts of place and agent--mechanisms such as permits, ownership, and sponsorship.

* Chapter 22: Understanding Process Fundamentals

This chapter introduces processes and discusses their fundamental properties. It talks about telenames and authority with some detail, and it provides a brief introduction of permits. It shows the life of a process and how processes typically interact with each other. This chapter is in rough outline form only.

* Chapter 23: Using Permits

This chapter discusses permits in detail: How they restrict activities, the types of permits, how they're stored, how they intersect, temporary and permanent permits. It introduces the resources teleclicks, age, and size. It shows how permits are assigned and changed. And it shows how to create a restrict block and how the block creates a temporary permit. A big chapter. This chapter is in rough outline form only.

* Chapter 24: Sponsored Operations and Multitasking

This chapter discusses sponsored operations and how they spawn threads. It looks at the anatomy of a thread--stack and frame--and how the engine executes threads. This chapter is in rough outline form only.

* Chapter 25: Ownership and Closure

This chapter discusses the interrelated concepts of closure and ownership. It looks at the closures of objects and processes. It shows why ownership is necessary, what it means, and how it affects life in the telesphere. It talks about acquiring and transferring ownership, object isolation, and the usefulness of setting a current owner with an own block. This chapter is in rough outline form only.

Section V: Places and Agents

This section describes agents and places and the Telescript mechanisms such as events and packages that help them work together. This section is the most advanced section of the book, and depends on the concepts presented in all the previous sections.

* Chapter 26: Using Places

This chapter introduces and discusses in detail places, teleaddresses, the finder, and place occupancy. It shows how entering and exiting a place works. This chapter is in rough outline form only.

* Chapter 27: Understanding Agent Fundamentals

This chapter introduces agents and provides an overview of traveling and meeting, topics discussed in detail in following chapters. This chapter is in rough outline form only.

* Chapter 28: Sending an Agent on a Trip

This chapter discusses in detail how agents travel. It describes tickets, routes, ways, and means. It also discusses process branding. This chapter is in rough outline form only.

* Chapter 29: Arranging a Meeting Between Agents

This chapter discusses meeting in detail. It covers petitions, meeting operations, parting, and recording a meeting among other things. This chapter is in rough outline form only.

* Chapter 30: Working With Resources

This chapter discusses resources in detail and how they can control multiple execution of a block of code. It talks about creating a resource block, setting and using conditions, and providing a waiting time, among other things. This chapter is in rough outline form only.

Appendices

A glossary of Telescript terms; a list of Telescript reserved words; a list of built-in classes divided into core, foundation, and agent classes; a Backus-Naur summary of HTS syntax.