Content deleted Content added
→Dataflow variables and declarative concurrency: fix indentation (should be easier to understand; same formatting as Map example above) |
m →State and objects: Adding wikilinks |
||
| (30 intermediate revisions by 21 users not shown) | |||
Line 1:
{{Short description|Multiparadigm programming language}}
{{Infobox programming language
|name = Oz
Line 7 ⟶ 9:
|developer = Mozart Consortium
|released = {{Start date and age|1991}}
|latest release version = Oz 1.4.0 (final), Mozart 2.0.1
|latest release date = {{Start date and age|
|typing = [[dynamic typing|dynamic]]
|implementations = Mozart Programming System
|license = [[MIT License|MIT X11]]<ref>{{cite web |url=
|dialects = Oz, Mozart
|influenced by = [[Erlang (programming language)|Erlang]], [[Lisp (programming language)|Lisp]], [[Prolog]]
Line 17 ⟶ 19:
|website = {{URL|mozart.github.io}}
}}
▲{{Use dmy dates|date=May 2012}}
'''Oz''' is a [[multiparadigm programming language]], developed in the Programming Systems Lab at [[Université catholique de Louvain]], for 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
==Language features==
Oz<ref name="Oz programming model">
{{cite
| author = Gert Smolka
| title =
| chapter = The Oz Programming Model
|
| volume = 1000
| year= 1995
| pages = 324–343
| doi = 10.1007/BFb0015252
| url= https://www.ps.uni-saarland.de/Publications/documents/Vol1000.pdf}}▼
| isbn = 978-3-540-60105-0
</ref> contains most of the concepts of the major [[programming paradigm]]s, 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 an efficient implementation.{{Citation needed|date=June 2007}} Oz is a [[Concurrency (computer science)|concurrency]]-oriented language, as the term was introduced by Joe Armstrong, the main designer of the [[Erlang (programming language)|Erlang language]]. A concurrency-oriented language makes concurrency easy to use and efficient. Oz supports a canonical [[graphical user interface]] (GUI) language QTk.<ref>[http://www.mozart-oz.org/home/doc/mozart-stdlib/wp/qtk/html/ QTk]</ref>▼
▲| chapter-url= https://www.ps.uni-saarland.de/Publications/documents/Vol1000.pdf}}
▲</ref> contains most of the concepts of the major [[programming paradigm]]s, 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
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 tolerance|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#Computer science|orthogonal]] to the constraint ___domain.
Line 49 ⟶ 53:
* Tuples: Records with integer features in ascending order: <code> circle(1:0 2:1 3:3 4:blue 5:dots) </code>.
* Lists: a simple linear structure
<
'|'(2 '|'(4 '|'(6 '|'(8 nil)))) % as a record.
2|(4|(6|(8|nil))) % with some syntactic sugar
2|4|6|8|nil % more syntactic sugar
[2 4 6 8] % even more syntactic sugar
</syntaxhighlight>
Those data structures are values (constant), [[first-class object|first class]] and [[dynamic typing|dynamically type checked]]. Variable names in Oz start with an uppercase letter to distinguish them from [[Literal (computer programming)|literals]]<ref>{{Cite web|url=https://mozart.github.io/mozart-v1/doc-1.4.0/tutorial/node3.html#label18|title=3 Basics}}</ref> which always begin with a lowercase letter.
===Functions===
Functions<ref name="Advanced Functional Programming in Oz">{{cite book
| author = Leif Grönqvist
| title = Advanced Functional Programming in Oz
| chapter = Higher Order Functions
| url = http://www2.gslt.hum.gu.se/~leifg/gslt/doc/ozfunpaper.ps
| access-date = 3 November 2014
}}▼
| archive-url = https://web.archive.org/web/20160303171453/http://www2.gslt.hum.gu.se/~leifg/gslt/doc/ozfunpaper.ps
</ref> are first class values, allowing [[Higher-order programming|higher order functional]] programming:▼
| archive-date = 3 March 2016
<source lang="erlang">▼
| url-status = dead
▲}}</ref> are first class values, allowing [[Higher-order programming|higher order functional]] programming:
fun {Fact N}
if N =< 0 then 1 else N*{Fact N-1} end
end
</
fun {Comb N K}
{Fact N} div ({Fact K} * {Fact N-K}) % integers can't overflow in Oz (unless no memory is left)
Line 80 ⟶ 86:
end
end
</syntaxhighlight>
Functions may be used with both free and bound variables. Free variable values are found using static [[Scope (computer science)|lexical scoping]].<ref name="Scoping">
{{cite
| author = Robert Gentleman|author2=Ross Ihaka
| title = Lexical Scope in Statistical Computing
| url= https://www.stat.auckland.ac.nz/~ihaka/downloads/lexical.pdf
|journal=Journal of Computational and Graphical Statistics
|volume= 9|issue= 3, Systems and Languages |date=Sep 2000|pages=491–508
▲}}
</ref>
====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 {Square N} % A general function
N*N
Line 106 ⟶ 113:
%usage
{Browse {Map Square [1 2 3]}} %browses [1 4 9]
</syntaxhighlight>
====Anonymous functions====
Like many other functional languages, Oz supports use of [[anonymous
In the following, the square function is defined anonymously and passed, causing <code>[1 4 9]</code> to be browsed.
<
{Browse {Map fun {$ N} N*N end [1 2 3]}}
</syntaxhighlight>
Since anonymous functions don't have names, it is not possible to define recursive anonymous functions.
Line 120 ⟶ 127:
====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.
<
declare
fun {Ret X}
if X > 0 then 5 else ~5 end
end
</syntaxhighlight>
But Oz also provides a facility in case a function must not return values. Such functions are called procedures.<ref>{{Cite web|url=https://mozart.github.io/mozart-v1/doc-1.4.0/tutorial/node5.html#control.procedure|title = 5 Basic Control Structures}}</ref> Procedures are defined using the construct "proc" as follows
<
declare
proc {Ret X}
if X > 0 then {Browse 5} else {Browse ~5} end
end
</syntaxhighlight>
The 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
Line 144 ⟶ 151:
thread X = 40 end
thread Y = 2 end
</syntaxhighlight>
The value of a dataflow variable cannot be changed once it is bound:
<
X = 1
X = 2 % error
</syntaxhighlight>
Dataflow variables make it easy to create concurrent stream agents:
<
fun {Ints N Max}
if N == Max then nil
Line 175 ⟶ 182:
{Browse Y}
end
</syntaxhighlight>
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.<ref>{{Cite web |url=http://www.mozart-oz.org/documentation/tutorial/node8.html#chapter.concurrency |title=Archived copy |access-date=29 November 2008 |archive-url=https://web.archive.org/web/20150224185115/http://www.mozart-oz.org/documentation/tutorial/node8.html#chapter.concurrency |archive-date=24 February 2015 |url-status=usurped }}</ref>
===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 {Sieve Xs}
case Xs of nil then nil
Line 189 ⟶ 196:
end
end
</syntaxhighlight>
=== Laziness ===
Oz uses [[eager evaluation]] by default, but [[lazy evaluation]]<ref name="Lazy Programming">
{{cite journal
| author =
| author-link = Paul Hudak
| title = Conception, evolution, and application of functional programming languages
| journal = ACM Computing Surveys
| year = 1989
| volume = 21
| number = 3
| pages = 359–411
| doi=10.1145/72551.72554
}}
</ref> is possible. Below, the fact is only computed when value of X is needed to compute the value of Y.
<
fun lazy {Fact N}
if N =< 0 then 1 else N*{Fact N-1} end
Line 210 ⟶ 220:
Y = X + 1
end
</syntaxhighlight>
[[
<
declare
fun lazy {Merge Xs Ys}
Line 235 ⟶ 245:
H = 1 | {Merge {Times 2 H} {Merge {Times 3 H} {Times 5 H}}}
{Browse {List.take H 6}}
</syntaxhighlight>
The code above elegantly computes all the [[Regular Number]]s<ref name="Hamming Numbers">
{{cite journal
|author1=Rao, AC |author2=Varada Raju, D
|
| journal = Mechanism and Machine
| volume = 26
| number = 1
Line 249 ⟶ 259:
=== Message passing concurrency ===
The declarative concurrent model can be extended with [[message passing]] via simple semantics:
<
declare
local Stream Port in
Line 259 ⟶ 269:
{Send Port n} % Stream is now 1|2| .. |n|_
end
</syntaxhighlight>
With a port and a thread, asynchronous agents can be defined:
<
fun {NewAgent Init Fun}
Msg Out in
Line 268 ⟶ 278:
{NewPort Msg}
end
</syntaxhighlight>
=== 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 = {NewCell 0}
Line 279 ⟶ 289:
X = @A % @ is used to access the value of A
end
</syntaxhighlight>
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
Line 301 ⟶ 311:
{C browse}
end
</syntaxhighlight>
==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 [[The Computer Language Benchmarks Game|
==See also==
Line 316 ⟶ 326:
==References==
* Peter Van Roy and Seif Haridi (2004). ''[[Concepts, Techniques, and Models of Computer Programming]]''. MIT Press. There is [http://www.info.ucl.ac.be/~pvr/book.html online supporting material] for this book. The book, an introduction to the principles of programming languages, uses Oz as its preferred idiom for examples.
{{Reflist|30em}}▼
▲{{Reflist}}
==External links==
* {{Official website|mozart.github.io}}
* [
* [http://www.info.ucl.ac.be/people/PVR/distribution.html Programming Language Research at UCL]: One of the core developers of Mozart/Oz, this group does research using Mozart/Oz as the vehicle
* [http://www.informatik.uni-trier.de/~ley/db/conf/moz/moz2004.html ''Multiparadigm Programming in Mozart/Oz: Proceedings of MOZ 2004'']: Conference which gives a snapshot of the work being done with Mozart/Oz
* [http://people.cis.ksu.edu/~xou/505f10/slides/oz.pdf Programming in Oz]
* [
{{DEFAULTSORT:Oz (programming language)}}
| |||