![]() | This article needs to be updated.(December 2021) |
![]() | |
Paradigm | multi-paradigm: procedural, object-oriented |
---|---|
Designed by | Ric Holt, James Cordy |
Developer | Holt Software Associates |
First appeared | 1982 |
Final release | 4.1.1 / November 25, 2007 |
Typing discipline | static, manifest |
OS | Microsoft Windows |
Major implementations | |
Turing, TPlus, OpenT | |
Dialects | |
Object-Oriented Turing, Turing Plus | |
Influenced by | |
Euclid, Pascal, SP/k |
Turing is a high-level, general purpose programming language developed in 1982 by Ric Holt and James Cordy, at University of Toronto in Ontario, Canada. It was designed to help students taking their first computer science course learn how to code. Turing is a descendant of Pascal, Euclid, and SP/k that features a clean syntax and precise machine-independent semantics.
Turing 4.1.0 is the latest stable version. Versions 4.1.1 and 4.1.2 do not emit stand alone .exe files. Versions pre-4.1.0 have outdated syntax and functions.
Named after British computer scientist Alan Turing, Turing is used mainly as a teaching language at the high school and university level. [1] Two other versions exist, Object-Oriented Turing and Turing Plus, a systems programming variant. In September 2001, "Object Oriented Turing" was renamed "Turing" and the original Turing was renamed "Classic Turing". Turing is now unsupported by Holt Software Associates in Toronto, Ontario. Turing was widely used in high schools in Ontario as an introduction to programming. [2]
On November 28, 2007, Turing, which was previously a commercial programming language, became freeware, available to download from the developer's website free of charge for personal, commercial, and educational use. [3] [4] [5]
The makers of Turing, Holt Software Associates, have since ceased operations, and Turing has seen no further development since November 25, 2007. [4]
Turing is designed to have a very lightweight, readable, intuitive syntax. Here is the entire "Hello, World!" program in Turing with syntax highlighting:
put"Hello World!"
Turing avoids semicolons and braces, using explicit end markers for most language constructs instead, and allows declarations anywhere. Here is a complete program defining and using the traditional recursive function to calculate a factorial.
*comment*% Accepts a number and calculates its factorialfunctionfactorial (n: int) : realifn = 0 thenresult 1 elseresultn * factorial (n - 1) end ifendfactorialvarn: intloopput"Please input an integer: " .. getnexit whenn >= 0 put"Input must be a non-negative integer."end loopput"The factorial of ", n, " is ", factorial (n)
Currently, there are two open source alternative implementations of Turing: Open Turing, an open source version of the original interpreter, and TPlus, a native compiler for the concurrent system programming language variant Turing Plus. OpenT, a project to develop a Turing compiler, was discontinued.
Open Turing is an open-source implementation of the original Turing interpreter for Windows written by Tristan Hume. It includes speed improvements, new features such as OpenGL 3D and a new code editor. It is fully backwards compatible with the closed-source implementation. [6]
TPlus is an open-source implementation of original (non-Object-Oriented) Turing with systems programming extensions developed at the University of Toronto and ported to Linux, Solaris, and Mac OS X at Queen's University in the late 1990s. [7] TPlus implements Turing+ (Turing Plus), a concurrent systems programming language based on the original Turing programming language. Some, but not all, of the features of Turing Plus were eventually subsumed into the present Object-Oriented Turing language. Turing Plus extends original Turing with processes, monitors (as specified by C.A.R. Hoare), and language constructs needed for system programming such as binary input-output, separate compiling, variables at absolute addresses, type converters and other features.
Paradigm | multi-paradigm: procedural, object-oriented, concurrent |
---|---|
Designed by | Ric Holt, James Cordy |
Developer | Ric Holt, James Cordy |
First appeared | 1987 |
Typing discipline | static, manifest |
Influenced by | |
Concurrent Euclid, Turing | |
Influenced | |
Object-Oriented Turing |
Turing+ (Turing Plus) is a concurrent systems programming language based on the Turing programming language designed by James Cordy and Ric Holt, then at the University of Toronto, Canada, in 1987. Some, but not all, of the features of Turing+ were eventually subsumed into Object-Oriented Turing. Turing+ extended original Turing with processes and monitors (as specified by C.A.R. Hoare) as well as language constructs needed for systems programming such as binary input-output, separate compiling, variables at absolute addresses, type converters, and other features.
Turing+ was explicitly designed to replace Concurrent Euclid in systems-programming applications. The TUNIS operating system, originally written in Concurrent Euclid, was recoded to Turing+ in its MiniTunis implementation. Turing+ has been used to implement several production software systems, including the language TXL.
Paradigm | multi-paradigm: procedural, object-oriented, concurrent |
---|---|
Designed by | Ric Holt |
Developer | Ric Holt |
First appeared | 1991 |
Typing discipline | static, manifest |
OS | Cross-platform: Sun-4, MIPS, RS-6000 |
Influenced by | |
Turing |
Object-Oriented Turing is an extension of the Turing programming language and a replacement for Turing Plus created by Ric Holt [8] [9] of the University of Toronto, Canada, in 1991. It is imperative, object-oriented, and concurrent. It has modules, classes, single inheritance, processes, exception handling, and optional machine-dependent programming.
There is an integrated development environment under the X Window System and a demo version.[ citation needed ] Versions exist for Sun-4, MIPS, RS-6000, NeXTSTEP, Windows 95, and others.
A computer program is a sequence or set of instructions in a programming language for a computer to execute. It is one component of software, which also includes documentation and other intangible components.
Dylan is a multi-paradigm programming language that includes support for functional and object-oriented programming (OOP), and is dynamic and reflective while providing a programming model designed to support generating efficient machine code, including fine-grained control over dynamic and static behaviors. It was created in the early 1990s by a group led by Apple Computer.
Eiffel is an object-oriented programming language designed by Bertrand Meyer and Eiffel Software. Meyer conceived the language in 1985 with the goal of increasing the reliability of commercial software development; the first version becoming available in 1986. In 2005, Eiffel became an ISO-standardized language.
Lisp is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation. Originally specified in 1960, it is the third-oldest high-level programming language still in common use, after Fortran and COBOL. Lisp has changed since its early days, and many dialects have existed over its history. Today, the best-known general-purpose Lisp dialects are Common Lisp, Scheme, Racket, and Clojure.
Mercury is a functional logic programming language made for real-world uses. The first version was developed at the University of Melbourne, Computer Science department, by Fergus Henderson, Thomas Conway, and Zoltan Somogyi, under Somogyi's supervision, and released on April 8, 1995.
A programming language is a system of notation for writing computer programs.
Smalltalk is a purely object oriented programming language (OOP) that was originally created in the 1970s for educational use, specifically for constructionist learning, but later found use in business. It was created at Xerox PARC by Learning Research Group (LRG) scientists, including Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Diana Merry, and Scott Wallace.
OCaml is a general-purpose, high-level, multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features. OCaml was created in 1996 by Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez, and others.
F# is a general-purpose, strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. It is most often used as a cross-platform Common Language Infrastructure (CLI) language on .NET, but can also generate JavaScript and graphics processing unit (GPU) code.
The Syntax/Semantic Language (S/SL) is an executable high level specification language for recursive descent parsers, semantic analyzers and code generators developed by James Cordy, Ric Holt and David Wortman at the University of Toronto in 1980.
James Reginald Cordy is a Canadian computer scientist and educator who is Professor Emeritus in the School of Computing at Queen's University. As a researcher he is most recently active in the fields of source code analysis and manipulation, software reverse and re-engineering, and pattern analysis and machine intelligence. He has a long record of previous work in programming languages, compiler technology, and software architecture.
Euclid is an imperative programming language for writing verifiable programs. It was designed in the mid-1970s by Butler Lampson and James G. Mitchell at the Xerox PARC lab in collaboration with Jim Horning at the University of Toronto, Ralph L. London at USC ISI and Gerald J. Popek at UCLA. The implementation was led by Ric Holt at the University of Toronto and James Cordy was the principal programmer for the first implementation of the compiler. It was originally designed for the Motorola 6809 microprocessor. It was considered innovative for the time; the compiler development team had a $2 million budget over 2 years and was commissioned by the Defense Advanced Research Projects Agency of the U.S. Department of Defense and the Canadian Department of National Defence. It was used for a few years at I. P. Sharp Associates, MITRE Corporation, SRI International and various other international institutes for research in systems programming and secure software systems.
Factor is a stack-oriented programming language created by Slava Pestov. Factor is dynamically typed and has automatic memory management, as well as powerful metaprogramming features. The language has a single implementation featuring a self-hosted optimizing compiler and an interactive development environment. The Factor distribution includes a large standard library.
Richard Craig Holt was an American-Canadian computer scientist.
TXL is a special-purpose programming language originally designed by Charles Halpern-Hamu and James Cordy at the University of Toronto in 1985. The acronym "TXL" originally stood for "Turing eXtender Language" after the language's original purpose, the specification and rapid prototyping of variants and extensions of the Turing programming language, but no longer has any meaningful interpretation.
Concurrent Euclid (ConEuc) is a concurrent descendant of the Euclid programming language designed by James Cordy and Ric Holt, then at the University of Toronto, in 1980. ConEuc was designed for concurrent, high performance, highly reliable system software, such as operating systems, compilers and embedded microprocessor systems. The TUNIS operating system, a Unix variant, was implemented entirely in Concurrent Euclid. ConEuc extends a core subset of Euclid with processes and monitors as well as language constructs needed for systems programming including separate compilation, variables at absolute addresses, type converters, long integers and other features.
Haskell is a general-purpose, statically-typed, purely functional programming language with type inference and lazy evaluation. Designed for teaching, research, and industrial applications, Haskell has pioneered a number of programming language features such as type classes, which enable type-safe operator overloading, and monadic input/output (IO). It is named after logician Haskell Curry. Haskell's main implementation is the Glasgow Haskell Compiler (GHC).
Nim is a general-purpose, multi-paradigm, statically typed, compiled high-level systems programming language, designed and developed by a team around Andreas Rumpf. Nim is designed to be "efficient, expressive, and elegant", supporting metaprogramming, functional, message passing, procedural, and object-oriented programming styles by providing several features such as compile time code generation, algebraic data types, a foreign function interface (FFI) with C, C++, Objective-C, and JavaScript, and supporting compiling to those same languages as intermediate representations.