This is one of the STIPPLE Documentation pages.

STIPPLE Introduction

Preface

Why did I undertake to write a new programming language? Well, the primary reason was frustration. When I was in graduate school at M.I.T. in the late 70's and early 80's, I had the opportunity to program in strongly typed language called CLU. My productivity in CLU was quite high. When I left graduate school to work in industry, I returned to programming in C and was appalled to discover that my productivity had been reduced by factor of 3. However, I was not too worried because I knew something better would eventually come along. Imagine my surprise when I realized that "something better" was going to be C++. Don't get me wrong, C++ is somwhat better than C, but I find it falls far short of CLU in terms of the ability to write lots of high quality code in a very short amount of time. To make a long story short, I got tired of C, ANSI-C, and C++ and decided to write a language that would return me to my former productivity level in CLU. The resulting language is called STIPPLE and I hope that you enjoy it.

Acknowledgments

I would like to acknowledge that the basic design of STIPPLE started from the CLU programming language designed by Professor Barbara Liskov and her very talented graduate students at the Massachusetts Institute of Technology. I taken the liberty to add and remove features from CLU as STIPPLE evolved. I take full responsibility for any mistakes occurred during this evolutionary process.

Most importantly, I would also like to acknowledge the patience and love of my wife, Christine, and child, Kevin, for bearing with me while I worked on this project.

Introduction

This document is both the reference manual and the rationale for the STIPPLEŽ (see What does STIPPLE mean and why make it registered trade-mark) programming language. It is available only hypertext form. The language rationale is kept separate from the language reference and is cross-linked via hypertext links.

The primary purpose behind the design of STIPPLE is to improve programmer productivity (see Why improve programmer productivity.) by enabling the creation of high quality software in less time. STIPPLE has the following language features:

Strong static type checking: All objects and variables have a strong type. The language is designed to catch all type mismatch errors at compile time. (see Why static type-checking.) The STIPPLE type system has parameterized types to enable and encourage code reuse. (see Why parameterized types.)
Referential integrity: In STIPPLE, referential integrity means that all variables and objects always refer to objects of a valid type. The benefit of referential integrity is that a pure STIPPLE program can not "dump core." (see Why referential integrity.) A garbage collector is used to help maintain referential integrity. (see Why garbage collection.)
Modularity: The language directly supports the concept of modules and interfaces. (see Why modularity.)
Object-oriented: Given the lack of a good definition for the term "object-oriented", it is difficult to reach a consensus of whether STIPPLE is an object-oriented programming language or not. The STIPPLE language definitely supports some, but not all, object oriented programming concepts. (see Why object-oriented.)
Exception handling: Exception handling is built into the language, to permit programmers to directly deal with program faults. (see Why exception handling.)
Internationalizable: The compiler supports 1) programming in a native language other than English, 2) the ability to translate source code from one native language to another, and 3) a number features to simplify writing applications that can be easily internationalized and localized. (see Why internationalization.)
Availability: The original compiler is readily available in source code form. (see Why make STIPPLE readily available.)
Portable: The basic compiler emits code in ANSI-C so that it may be ported to a large number of systems. (see Why a portable compiler.) The basic compiler also comes with a reasonable debugger (see Why a portable debugger.)
Extensible: There are features in STIPPLE that will permit it to easily evolve over time (see "Why extensible.)
Word processor compatible: STIPPLE source code can be composed using either a plain text editor or a word processor. (see Why word processor compatible.)

The use of all of these language features empower the programmer to create and maintain high quality software in less time.

In general, this manual will take a top-down approach to describing the STIPPLE language. However, it is necessary to discuss some lexical issues very early. This manual contains the following chapters:

Introduction
Overview
Lexical Issues
Notational Issues
Prelude Delcarations
Type Declarations
Procedure and Object Declarations
Statements
Expressions

From here you can go to either the next chapter on STIPPLE Overview or back to the table of contents.