Designed for computer science instruction, Turing is simply the easiest, most fun, and most effective way of teaching programming concepts.
		Quick Links
		Contact Us Textbooks Textbook Solutions Manuals Student Purchases School/Bookstore Purchases Courses for Teachers Careers in Computing Book Computer Engineering Book ------------------- Turing Home Page What is Turing? Turing Announcements Turing Textbooks Turing Pricing for Schools Turing Technical Information Turing Technical Support Turing Software Library Resources for Teaching ------------------- Java Home Page (Our's) Java Textbooks The hsa Package Resources for Teaching Java ------------------- Ready Java IDE Home Page What is Ready to Program? Ready Pricing for Schools Ready Technical Support Ready Updates ------------------- Turbo Pascal Textbook Chris' Stuff School CS Pages

Introduction to Turing

• What is Turing?
• The Turing Environment
• Features of Turing
• Sample Program with a Loop
• Turing's Graphics Features
• Sample Program Using Graphics
• Object-Oriented Features of Turing
• Sample Program Using Classes
• Advanced Features of Turing
• Turing Platforms and System Requirements
• Pricing

What is Turing?

The Turing Environment

• allows teachers to choose between a simple single-window mode or a multi-window mode for more experienced programming students,
• one-button program indentation,
• one button compilation and execution,
• syntax colouring,
• easy to understand error messages,
• direct access to the PC parallel port ( for computer engineering courses).

Features of Turing

• convenient strings and input/output,
• if statements with elsif clauses,
• case statements with otherwise clauses,
• loop statements with exits,
• modules with import and export,
• dynamic arrays and parameters,
• assertions (assert, pre, post and invariant),
• type transfer functions (such as string to real),
• random number generation,
• exponentiation, and
• run-time constants.

Sample Program with a Loop

    % Roll a die until you get 6.  (This line is a comment)
    var die : int
    loop
        randint (die, 1, 6)
        exit when die = 6
        put "This roll is ", die
    end loop
    put "Stopping with roll of 6"
  

Turing's Graphics Features

• drawing primitives (lines, rectangles, ovals, stars and maple leaves),
• loading graphics files (BMP, and Macintosh PICT),
• simple animation,
• sound, and
• music.

Sample Program Using Graphics

    var x, y, clr : int                           % The location and color of the star
    drawfillbox (0, 0, maxx, maxy, black)         % Make the window black
    drawline (0, 100, maxx, 100, white)           % Draw the horizon
    for i : 1 .. 40
        randint (x, 0, maxx)                      % Set the x position
        randint (y, 100, maxy)                    % Set the y position
        randint (clr, 0, maxcolor)                % Set the color
        drawfillstar (x, y, x + 20, y + 20, clr)  % Draw the star
    end for
  

Object Oriented Features of Turing

The core object-oriented features of Turing are easy to learn, so programmers can read programs and understand them quickly and easily. Programs consist of units which are objects (called modules) or classes. These units exist as separate items in the environment and the user has immediate access to use (or re-use) these units in his/her program.

Sample Program Using Classes

    class Complex
        export Set, GetReal, GetImaginary, Add, Multiply

        var realComponent, imaginaryComponent : real

        procedure Set (r, imag : real)
            realComponent := r
            imaginaryComponent := imag
        end Set

        function GetReal : real
            result realComponent
        end GetReal

        function GetImaginary : real
            result imaginaryComponent
        end GetImaginary

        procedure Add (number : ^Complex)
            realComponent += number -> GetReal
            imaginaryComponent += number -> GetImaginary
        end Add

        procedure Multiply (number : ^Complex)
            realComponent := realComponent * number -> GetReal -
                    imaginaryComponent * number -> GetImaginary
            imaginaryComponent := realComponent * number -> GetImaginary +
                    imaginaryComponent * number -> GetReal
        end Multiply
    end Complex

    % Main program
    var x, y, z : ^Complex
    new x                        % Create the x object
    new y                        % Create the y object
    new z                        % Create the z object
    x -> Set (5, 0)             % x = 5
    y -> Set (0, 5)             % y = 5i
    z -> Set (3, 3)             % z = 3 + 3i
    x -> Add (y);
    x -> Multiply (z);
    put "x = ", x -> GetReal, " + ", x -> GetImaginary, "i"
  

Advanced Features of Turing

• natural (unsigned) numbers,
• sized numbers (e.g., nat1 is a one-byte natural number),
• bit manipulation,
• subprograms as variables,
• characters and fixed length character strings,
• explicit type cheats (e.g., #c treats any value c as a nat1),
• indirection (e.g., int@(16#8ab36) is a peek or poke to hex location 8ab36),
• concurrency with dynamic forking and monitors,
• interrupt handling procedures,
• completely checked separate compilation,
• exception handlers,
• binary and random access input/output, and
• conditional compilation.

Turing Platforms and System Requirements

Pricing