Welcome to the Dictionary of Programming Languages, a compendium
of computer coding methods assembled to provide information and
aid your appreciation for computer science history.
Browse the dictionary by clicking on a section:
Get a full dump of the dictionary:
List of Names
- Language type:
Pict is a research programming language
designed as a practical implementation
of the pi-calculus (a parallel computation
formalism). While based on a very
advanced formal model, Pict also provides
a small but usable complement of data types
The core elements of the Pict language are
a simple but general
static type system and
concurrent processes that
communicate using channels.
The pi-calculus defines the
semantics of the processes and
Pict supports a small
set of primitive data types:
integer, character, boolean,
string, and channel. It does not have
enumerated or real number primitive types.
The aggregate data type in Pict is the
tuple, which can have named or unnamed
Pict supports only three sequential
programming constructs: sequential
composition, conditional (if-then-else),
and associative application (application
of a function over several values).
Oddly enough, Pict does not have any
sequential looping constructs, although
other forms like recursion and process
composition can do the same thing.
The core Pict language is extended by
several 'derived forms' and library
functions that add no
formal expressive power but make
programming much easier (relatively, anyway).
local value declarations and
associative application are derived
Some of the library forms
include bounded loops, array handling,
events and exceptions, and several
other additional data types.
The Pict libraries also include
interfaces to useful features:
- most of the Posix-standard
operating system facilities
- image handling
- X11 windows and graphics
For composing larger programs, Pict
has a simple import module import
B.C. Pierce, D.N. Turner, 1993
- See Also:
Development of Pict seems to have stopped
in 1998. The most recent version, 4.1, is
still available from U. of Indiana. The
Pict compiler is written in Objective-CAML
(an OO variant of ML). Pict runs on
Unix systems, and requires the GNU C
compiler and GNU Make.
The pi-calculus formalism was defined
Milner, Parrow, and Walker in 1992.
Pict is a concrete
instantiation of the pi-calculus
in the way that pure Lisp is an
instantiation of the lambda-calculus.
- Sample code:
The example below implements the Sieve
of Erastosthenes (from the examples shipped
with Pict 4.1).
now (reset checks)
def interval (min:Int max:Int):(List Int) =
if (>> min max) then nil else (cons min (interval (inc min) max))
def sieve (max:Int):(List Int) = (
def again (l:(List Int)):(List Int) =
if (null l) then
(val n = (car l)
if (>> (* n n) max) then l
else (cons n (again (list.filter #Int l \(x) = (<> (mod x n) 0)))))
(again (interval 2 max))
def prPrime (idx:Int x:Int): =
if (== (mod idx 10) 9) then ((int.pr x); (nl))
else ((int.pr x); (pr " "))
(list.itApply (sieve 4000) prPrime);
Descriptions in this dictionary are ©1997-99 Neal Ziring. Some
examples copyright of their respective authors. Some
technologies and languages are trademarked. Permission to
copy descriptions is granted as long as authorship credit is preserved.
Comments on this dictionary, corrections and suggestions, are all welcome.
Please use email, the address is firstname.lastname@example.org
[Ziring MicroWeb Home]
Dictionary and script maintained by Neal Ziring, last major modifications 3/18/98. Most recent
additions to dictionary and master list, 1/00.