Oz (programming language) explained

Oz
Paradigm:multi-paradigm

logic, functional, imperative, object-oriented, constraint, distributed, concurrent

Year:1991
Designer:Gert Smolka, his students
Developer:Mozart Consortium
Latest Release Version:Oz 1.4.0 (final), Mozart 2.0.1
Typing:dynamic
Implementations:Mozart Programming System
License:MIT X11[1]
Dialects:Oz, Mozart
Influenced By:Erlang, Lisp, Prolog
Influenced:Alice, Scala

Oz is a multiparadigm programming language, developed in the Programming Systems Lab at Université catholique de Louvain, for programming-language education. It has a canonical textbook: Concepts, Techniques, and Models of Computer Programming.

Oz was first designed by Gert Smolka and his students in 1991. In 1996, development of Oz continued in cooperation with the research group of Seif Haridi and Peter Van Roy at the Swedish Institute of Computer Science. Since 1999, Oz has been continually developed by an international group, the Mozart Consortium, which originally consisted of Saarland University, the Swedish Institute of Computer Science, and the Université catholique de Louvain. In 2005, the responsibility for managing Mozart development was transferred to a core group, the Mozart Board, with the express purpose of opening Mozart development to a larger community.

The Mozart Programming System is the primary implementation of Oz. It is released with an open source license by the Mozart Consortium. Mozart has been ported to Unix, FreeBSD, Linux, Windows, and macOS.

Language features

Oz[2] contains most of the concepts of the major programming paradigms, including logic, functional (both lazy evaluation and eager evaluation), imperative, object-oriented, constraint, distributed, and concurrent programming. Oz has both a simple formal semantics (see chapter 13 of the book mentioned below) and Oz is a concurrency-oriented language, as the term was introduced by Joe Armstrong, the main designer of the Erlang language. A concurrency-oriented language makes concurrency easy to use and efficient. Oz supports a canonical graphical user interface (GUI) language QTk.[3]

In addition to multi-paradigm programming, the major strengths of Oz are in constraint programming and distributed programming. Due to its factored design, Oz is able to successfully implement a network-transparent distributed programming model. This model makes it easy to program open, fault-tolerant applications within the language. For constraint programming, Oz introduces the idea of computation spaces, which allow user-defined search and distribution strategies orthogonal to the constraint domain.

Language overview

Data structures

Oz is based on a core language with very few datatypes that can be extended into more practical ones through syntactic sugar.

Basic data structures:

'|'(2 '|'(4 '|'(6 '|'(8 nil)))) % as a record.2|(4|(6|(8|nil))) % with some syntactic sugar2|4|6|8|nil % more syntactic sugar[2 4 6 8] % even more syntactic sugarThose data structures are values (constant), first class and dynamically type checked. Variable names in Oz start with an uppercase letter to distinguish them from literals[4] which always begin with a lowercase letter.

Functions

Functions[5] are first class values, allowing higher order functional programming:fun if N =< 0 then 1 else N* endendfun div (*) % integers can't overflow in Oz (unless no memory is left)end

fun case List of nil then 0 [] H|T then H+ % pattern matching on lists endendFunctions may be used with both free and bound variables. Free variable values are found using static lexical scoping.[6]

Higher-order programming

Functions are like other Oz objects. A function can be passed as an attribute to other functions or can be returned in a function. fun % A general function N*Nend

fun % F is a function here - higher order programming case Xs of nil then nil [] X|Xr then | endend

%usage %browses [1 4 9]

Anonymous functions

Like many other functional languages, Oz supports use of anonymous functions (i.e. functions which do not have a name) with higher order programming. The symbol $ is used to denote these.

In the following, the square function is defined anonymously and passed, causing [1 4 9] to be browsed.

Since anonymous functions don't have names, it is not possible to define recursive anonymous functions.

Procedures

Functions in Oz are supposed to return a value at the last statement encountered in the body of the function during its execution. In the example below, the function Ret returns 5 if X > 0 and -5 otherwise.declarefun if X > 0 then 5 else ~5 endendBut Oz also provides a facility in case a function must not return values. Such functions are called procedures.[7] Procedures are defined using the construct "proc" as followsdeclareproc if X > 0 then else endendThe above example doesn't return any value, it just prints 5 or -5 in the Oz browser depending on the sign of X.

Dataflow variables and declarative concurrency

When the program encounters an unbound variable it waits for a value. For example, below, the thread will wait until both X and Y are bound to a value before showing the value of Z.thread Z = X+Y endthread X = 40 endthread Y = 2 end

The value of a dataflow variable cannot be changed once it is bound:X = 1X = 2 % error

Dataflow variables make it easy to create concurrent stream agents:

fun if N

Max then nil else N| endend

fun case Stream of nil then S [] H|T then S| endend

local X Y in thread X = end thread Y = end end

Because of the way dataflow variables work, it is possible to put threads anywhere in a program and guaranteed that it will have the same result. This makes concurrent programming very easy. Threads are very cheap: it is possible to have 100,000 threads running at once.[8]

Example: Trial division sieve

This example computes a stream of prime numbers using the trial division algorithm by recursively creating concurrent stream agents that filter out non-prime numbers:fun case Xs of nil then nil [] X|Xr then Ys in thread Ys = end X| endend

Laziness

Oz uses eager evaluation by default, but lazy evaluation[9] is possible. Below, the fact is only computed when value of X is needed to compute the value of Y.fun lazy if N =< 0 then 1 else N* endendlocal X Y in X = Y = X + 1end

Lazy evaluation gives the possibility of storing truly infinite data structures in Oz. The power of lazy evaluation can be seen from the following code sample:declarefun lazy case Xs#Ys of (X|Xr)#(Y|Yr) then if X < Y then X| elseif X>Y then Y| else X| end endend

fun lazy case Xs of nil then nil [] X|Xr then N*X| endend

declare HH = 1 | The code above elegantly computes all the Regular Numbers[10] in an infinite list. The actual numbers are computed only when they are needed.

Message passing concurrency

The declarative concurrent model can be extended with message passing via simple semantics:declarelocal Stream Port in Port = % Stream is now 1|_ ('_' indicates an unbound and unnamed variable) % Stream is now 1|2|_ ... % Stream is now 1|2| .. |n|_end

With a port and a thread, asynchronous agents can be defined:fun Msg Out in thread end end

State and objects

It is again possible to extend the declarative model to support state and object-oriented programming with very simple semantics. To create a new mutable data structure called Cells:local A X in A = A := 1 % changes the value of A to 1 X = @A % @ is used to access the value of Aend

With these simple semantic changes, the whole object-oriented paradigm can be supported. With a little syntactic sugar, OOP becomes well integrated in Oz.class Counter attr val meth init(Value) val:=Value end meth browse end meth inc(Value) val :=@val+Value endend

local C in C = end

Execution speed

The execution speed of a program produced by the Mozart compiler (version 1.4.0 implementing Oz 3) is very slow. On a 2012 set of benchmarks it averaged about 50 times slower than that of the GNU Compiler Collection (GCC) for the C language.[11]

See also

References

External links

Notes and References

  1. Web site: Mozart Oz License Info . 16 January 2014 . 16 January 2014.
  2. Book: Gert Smolka. Computer Science Today. The Oz Programming Model. Lecture Notes in Computer Science. 1000. 1995. 324–343. 10.1007/BFb0015252. 978-3-540-60105-0. https://www.ps.uni-saarland.de/Publications/documents/Vol1000.pdf.
  3. Web site: QTk . 6 April 2009 . https://web.archive.org/web/20130520060646/http://www.mozart-oz.org/home/doc/mozart-stdlib/wp/qtk/html/ . 20 May 2013 . dead .
  4. Web site: 3 Basics.
  5. Book: Leif Grönqvist. Advanced Functional Programming in Oz. Higher Order Functions. 3 November 2014. https://web.archive.org/web/20160303171453/http://www2.gslt.hum.gu.se/~leifg/gslt/doc/ozfunpaper.ps. 3 March 2016. dead.
  6. Robert Gentleman. Ross Ihaka. Lexical Scope in Statistical Computing. Journal of Computational and Graphical Statistics. 9. 3, Systems and Languages . Sep 2000. 491–508. 10.1080/10618600.2000.10474895.
  7. Web site: 5 Basic Control Structures.
  8. Web site: Archived copy . 29 November 2008 . https://web.archive.org/web/20150224185115/http://www.mozart-oz.org/documentation/tutorial/node8.html#chapter.concurrency . 24 February 2015 . dead .
  9. Paul Hudak. Paul Hudak. Conception, evolution, and application of functional programming languages. ACM Computing Surveys. 1989. 21. 3. 359–411. 10.1145/72551.72554. 207637854.
  10. Rao, AC . Varada Raju, D . amp . Application of the Hamming number technique to detect isomorphism among kinematic chains and inversions. Mechanism and Machine Theory. 26. 1. 55–75. 1991 . 10.1016/0094-114x(91)90022-v.
  11. https://archive.today/20120713231944/http://shootout.alioth.debian.org/u32/which-programming-languages-are-fastest.php?calc=chart&gcc=on&oz=on The Computer Language Benchmarks Game