1 / 34

Lecture 1: Introduction to Oz Programming Language

Lecture 1: Introduction to Oz Programming Language. Per Brand. Features of Oz. Oz is an object-oriented language , it provides state, abstract data types, classes, objects, and inheritance.

argus
Download Presentation

Lecture 1: Introduction to Oz Programming Language

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Lecture 1: Introduction to Oz Programming Language Per Brand

  2. Features of Oz • Oz is an object-oriented language, it provides state, abstract data types, classes, objects, and inheritance. • Oz provides the features of functional programming: a compositional syntax, first-class procedures, and lexical scoping. In fact, every Oz entity is first class, including procedures, threads, classes, methods, and objects. • Oz is a concurrent (constraint) language • users can create dynamically any number of sequential threads that can interact with each other. • executing a statement in Oz proceeds only when all realdataflow dependencies on the variables involved are resolved. • Oz is a (concurrent) logic programming language

  3. Multi-paradigm • Object-oriented, functional, constraint programming paradigms in one package • Is this really possible ?? • Can I easily achieve in Oz all that I can in my single-paradigm language X?? • To a large degree yes • dynamically typed though • Cross-paradigm advantages also • Doesn’t this multi-paradigm make a big mess ?? • Well-integrated • Simple kernel language • higher-order makes the kernel simpler than most single paradigm languages

  4. Example: Object-oriented declare class Counter %% class definition attr count meth init %% constructor method count<-0 %% attribute update end meth inc %% public method (returning void) count<-@count +1 %% attribute access by @ end meth get($) %% public method (returning value) @count %% implicit return end end Obj={New Counter init} %% object constructed {Obj inc} %% object used {Obj inc} {Show {Obj get($)}} %% we expect to see ‘2’

  5. Observations • Syntax • keyword rather than special character approach • not enough special characters for all paradigms • No types • Oz is dynamically typed • What would happen on {Obj dec} ? • Where’s the distinction with public/private/protected etc?. • All methods in the example are public • Later we show how to achieve private/protected in language security model • Method of returning values look strange • Oz uses a more general concept than functions/object invocations returnvalues

  6. Example: Functional declare fun{Double X} %% function definition 2 * X end fun{Map F L}%% parameter F is a function case L of X|Xs then {F X}|{Map F Xs}%% returns list [] nil then nil end {Show {Map Double [1 2 3 4]}} %% we expect to see ‘[2 4 6 8]’ %% Alternatively using anonymous function (lambda expression) {Show {Map fun{$ X} 2*X end [1 2 3 4]}}

  7. Example: Concurrent Constraint Programming declare X A%% X and A are created unconstrained thread %% thread created caseXof[_]then %% thread waits on data-flow {Show triggered1(X)} end end thread caseXof[1]then %% thread waits on data-flow {Show triggered2(X)} end end {Delay 100} X=[A] %% X = [_] only first thread woken {Delay 100} A=1 %% X = [1] second thread woken %% we expect to see ‘triggered1([_])’ before ‘triggered2([1])’

  8. Observations • Concurrency more and more important for networked applications. • With concurrency (threads) you need to synchronize • Two methods • locking (monitors, sentinels etc.) • blocks other threads • threads woken by unlocking (or notify) • natural method when dealing with atomicity in continually changing composite stateful data e.g. critical region in object method application • data-flow • threads blocked on data availability • simpler and more efficient (data vs lock and data) • requires monotonicity • i.e. after thread becomes runnable always runnable, though the thread may suspend later after activation

  9. Concurrent Constraint Programming • Also gives powerful techniques for combinatorial search problems • Not covered in this course (www.mozart-oz.org) • see Chapter 12 of Oz-Tutorial • see Finite Domain Constraint Programming Tutorial • see Part I in Demo Applications

  10. How Mozart/Oz will be presented • Non-stateful non-concurrent subset • Oz without stateful entities, e.g. objects • Stateless data structures • Single-assignment variables • Procedures • Practical programming • OPI - open programming interface • Mozart web site • Concurrency and State • Threads and data-flow synchronization • Objects • Ports (for message sending) • Libraries • Distribution in Mozart • Misc • Mozart VM • Comparison with other platforms/languages for distributed programming • Issues in distributed programming

  11. Numbers • Oz supports integers and floats • Integers have infinite precision • Characters are integers in the range 0..255 with syntactic support • e.g. &t represents the character ‘t’ • Floats are different from integers and must have decimal points. • Other examples of floats are shown where ‘~’ is unary minus: ~3.141 4.5E3 ~12.0e~2 • .

  12. Literals • Literals are divided into atoms and names. • An atom is symbolic entity that has an identity made up of a sequence of alphanumeric characters starting with a lower case letter, or arbitrary printable characters enclosed in quotes. • Example: • a foo '=' ':=' 'OZ 2.0' • 'Hello World’ • Important -sequences that begin with lower case letter are by default atoms • Atoms have an ordering based on lexicographic ordering. • Another category of elementary entities is name. • The only way to create a name is by calling the procedure: • {NewName X} • X is assigned a new name that is guaranteed to be worldwide unique

  13. Boolean and Unit • A subtype of name is bool. • Consists of two names protected from being redefined by having the reserved keywords true and false. • There is also the type unit that consists of the single name unit. • This is used as synchronization token in many concurrent programs. local X Y B in X = foo {NewName Y} B = true {Show [X Y B]} % shows [foo <N> true]end

  14. Records • Records are structured compound entities. • A record has a label and a fixed number of components or arguments. • There are also records with a variable number of arguments that are called open records. • Example: tree(key: I value: Y left: LT right: RT) • It has four arguments. • The label tree. • Each argument consists of a pair Feature:Field. • The features of the record is key, value, left, and right. • The corresponding fields are I, Y, LT, and RT.

  15. Tuples • It is possible to omit the features of a record. • In Oz, this is called a tuple. • Example: • The following tuple has the same label and fields as the record shown before: • tree(I Y LT RT) • It is just a syntactic notation for the record: • tree(1:I 2:Y 3:LT 4:RT)

  16. Lists • The category of lists does not belong to a single data type in Oz. They are rather conceptual structure. • A list is: • either the atom nil representing the empty list, or • is a tuple using the infix operator ´|´ and two arguments which are respectively the head and the tail of the list. 1|2|3|nil • Another convenient special notation for a closed list, i.e. list with determined number of elements is: [1 2 3] • One can also use the standard notation for lists: '|'(1 '|'(2 nil))

  17. Infix Operator ´#´ • Another convenience is the infix operator ´#´. • Used to anonymously group terms a#b b#c#d • One can also use the standard notation : ’#'(a b) ’#'(a b c)

  18. Operations on Records - 1 • To select a field of a record component, we use the infix operator ‘.’ local X Y in X = person(first:per last:brand)Y = person(per brand) {Show X.first} %% shows per {Show Y.2} %% shows brand end

  19. Operations on Records - 2 • The arity of a record is a list of the features of the record sorted lexicographically. local X Y in X = person(last:brand first:per )Y = person(per brand) {Show {Arity X}} %% shows [first last] {Show {Arity Y}} %% shows [1 2] {Show {Label X}} %% shows person end

  20. Strings • Strings are not a primitive type • Further notational variant is allowed for lists whose elements correspond to character codes. Lists written in this notation are called strings, e.g. • "OZ 2.0" • is the list • [79 90 32 50 46 48] • or equivalently • [&O &Z &  &2 &. &0]

  21. Virtual Strings • A virtual string is special a tuple that represents a string with virtual concatenation. • Virtual strings are used for I/O with files, sockets, and windows. • All atoms, except nil and #, numbers, strings, and #-labeled tuples can be used to compose virtual strings: 123#"-"#23#" is "#100 • represents the string "123-23 is 100"

  22. Variable Declaration • In Oz computations are performed by a number of sequential threads. • Threads have access to a shared memory called the store. • Threads manipulate the store by reading, and adding information • Information is accessed through the notion of variables. • Oz variables are single-assignment variables. • A single assignment variable: • Initially it is introduced with unknown value, unbound • Later it might be assigned a value, in which case the variable becomes bound. • Once a variable is bound, it cannot be changed

  23. Variable Introduction A thread executing the statement:local X Y Z in S end • Introduces three single assignment variables. • Executes S in the scope of these variables. Another form of declaration is:declare X Y Z inS • Makes X Y and Z visible globally in S,and all statements the follows S textually in the session (file) • Unless overridden again by another variable declaration of the same textual variables.

  24. Binding a Variable local P F N A in P = person(fname:F lname:N add:A) F = per N = brand local T N in A = ’SICS’(town:T nat:N) T = kista N = sweden end end Store P F A N 4 unbound variables

  25. Binding a Variable-2 Store Store local P F N A in P = person(fname:F lname:N add:A) F = per N = brand local T N in A = ’SICS’(town:F nat:N) T = kista C = sweden end end person P fname lname F add N A The record shows itself as a graph in the store

  26. Binding a Variable-3 Store Store local P F N A in P = person(fname:F lname:N add:A) F = per N = brand local T N in A = ’SICS’(town:T nat:N) T = kista N = sweden end end person P fname lname F per add brand A SICS The outer variable N is no longer visible Lexical scoping town nat T N

  27. Binding a Variable-4 Store Store local P F N A in P = person(fname:F lname:N add:A) F = per N = brand local T N in A = ’SICS’(town:T nat:N) T = kista N = sweden end end person P fname lname F per add N brand A SICS The inner variables T N are no longer visible The outer variable N is again visible What happens after the next end - what is visible then?? town nat kista sweden

  28. Equality operator - 1 • The equality infix operator = X = 1 • Binds the unbound variable X to the integer 1. • Add this information to the store. • If X is already assigned the value 1, the operation is a no-op • If X is already bound to an incompatible value, a proper exceptionwill be raised. • local X in • X=1 • X=1 % no-op • end • local X in • X=1 • X=2 % exception • end

  29. Equality operator - 2 • local X Y in • X=Y • X=1 • {Show X#Y} • end • X=Y when X and Y are both unbound • Binds the variables X and Y to each other, unifies them. • Add this information to the store. • If X is assigned the value 1, then Y is also bound to 1. • Show will show 1#1. • local X in • X=1 • X=2 % exception • end

  30. Equality operator - over structures • X=Y • X and Y are unified or mutually constrained • Adds the minimal information to the store to make X and Y equal local X Y A B in X=f(A b) Y=f(a B) end X Y X Y f f f f b a a b a b

  31. Equality operator - over structures • X=Y • If X and Y are non-unifiable or incompatible a proper exceptionwill be raised. • The exception is called Tell failure: • from constraint view we are trying to tell (add) a constraint to the store that would make it inconsistent • in the constraint view there are only two things you do with the store • tell • ask local X Y A B in X=f(A b) Y=f(a c) %% raises %% exception end

  32. Anonymous variables • The syntax _ can be used for creating a single-assignment variable without a handle. • Even without a handle the single-assignment variable can be bound indirectly. local X in X=f(_ _) {Show X} %% shows X=f(_ _) X=f(a _) %% shows X=f(a _) X=f(a b) %% shows X=f(a b) end

  33. Equality Test Operator == • The equality test operator == is the askpartner of the tell equality operator = • The thread executing cannot know the result of the test Y==1 and waits until it can be decided. • Later we shall see how useful this is local X Y in X=1 {Show X==1} %% shows true {Show X==2} %% shows false {Show X==f(a b) %% shows false {Show Y==1} %% doesn’t show anything end

  34. Data Types with Structural Equality • The data types we have introduced so far, records, integers, floats, etc. have structural equality • 5 == 5.0 evaluates to false - floats and integers never equal • f(A B)==f(C D) evaluates to true iff A==B and C==D are true local X Y in {Show f(a b)==f(a b)} %% shows true {Show f(a b)==f(a c)} %% shows false {Show f(a b)==f(c d)) %% shows false {Show f(a _)==f(a b)} %% suspends!!! end

More Related