List of lectures. Lecture content. Lecture goal. Object Oriented Programming. Object-oriented and type. TDDA69 Data and Program Structure

Transcription

1 List of lectures TDDA69 Data and Program Structure Object Oriented Programming and type system Cyrille Berger 1 Introduction and Functional Programming 2 Imperative Programming and Data Structures 3 Environment 4 Evaluation 5 Object Oriented Programming and type system 6 Macros and 7 Virtual Machines and Bytecode 8 Garbage Collection and Native Code 9 Distributed Computing 10 Logic 11 Guest lecture 12 Summary 2 / 54 Lecture goal Object-oriented and type concepts and conscequence for program interpretation Lecture content Object Oriented Programming Object-Oriented Concepts Implementation Revisiting the visitor pattern Exceptions Type 3 / 54 4 / 54

2 Program Organizing Techniques Non-structured Programming Object Oriented Programming Structured Programming Modular Programming Object-Oriented Programming 6 Non-structured Programming The main program directly operates on globa data Program main program / data Impractical when the program gets sufficiently large The same statement sequence must be copied if it is needed several times Procedural Programming Combine a sequence of statements into a procedure with calls and returns The main program coordinates calls to procedures and hands over appropriate data as Program main program / data Procedure 1 Procedure 2 Procedure 3 Tasks are a collection of states, structures and procedures 7 8

3 Modular Programming Procedures of a common functionality are grouped together into separate modules. The main program coordinates calls to procedures in separate modules and hands over data as parameters. Program Module 1 data + data 1 Procedure 1 Procedure 2 main program / data Module 2 data + data 2 Procedure 3 Limitations of Structured and Modular Programming Unrestricted access to global Global data 1 Global data 2 Global data 3 Procedure 1 Procedure 2 Procedure 3 Procedure 4 Attributes and behaviors are seperated Not 9 10 What is Object-Oriented Programming? Object-Oriented Concepts A modeling technique It is a natural technique The world is made of objects: house, tree, car, computer... Allow to describe a program before it is written 12

4 What is an Object? Real-world objects are composed of attributes and behaviors Attributes: color, size,... Behaviors: accelerate, brake,... Program Attributes are states/variables Behaviors are functions Object-Oriented Concepts Class Inheritance Encapsulation Polymorphism Class An object is a specific instance (ie this car, this computer...) A class is a type of object (ie a car, a computer...) It is a blueprint of object The class defines: The default set of variables The default set of functions An initialisation function (called constructor The object is an instance of a class It points to a specific memory location with the actual values for variables Class Car class Car: attributes: color can be red, green, blue... speed from 0 to max_speed max_speed and max_acceleration are constant functions: accelerate increase speed with max_acceleration brake decrease speed with max_acceleration object: red_audi := { color:'red', max_speed: 200, max_acceleration: 10 blue_volvo := { color:'blue', max_speed: 180, max_acceleration:

5 Inheritance Some classes have common part Audi is a car, Volvo is a car, but Volvo and Audi are two different type of cars Inheritance allows to define a class in term of an other super-class Sub-classes can add new variables and functions override variables and functions from the super-class Inheritance from the class Car class Car: color, speed, max_speed and max_acceleration class Audi: class Car with max_speed := 200 and max_acceleration := 10 class Volvo: class Car with max_speed := 180 and max_acceleration := Encapsulation Encapsulation is the ability to hide variables Three common levels of Private: only accessible to the object Protected: only accessible to the object and through inheritance Public: accessible to the world Polymorphism polymorphism is the ability to appear in many forms It is the ability to call a function on an object that will execute different code for different objects For example, a shape class with an area function and triangle, square... It is one way of creating generic code 19 20

6 The advantages of Object-Oriented Programming Code reusability Code can shared in the superclass Polymorphism allow to define interfaces Inheritence clarifies the relationship among program elements Encapsulation allow modularity and control on access to variables 21 Implementation Implementing Object-Oriented Programming Defining members: variables (Almost) any imperative programming language can be made to support object-oriented programming For instance, first C++ compiler was compiling to C and many object systems have been added to C All you need is a In JavaScript/ obj = { value: 1.0, name: 'some object' console.log(obj.value) console.log(obj['value']) In class Test def init (self): self.value = 1.0 self.name = 'some object' obj = Test() print(obj.value) console.log(obj. dict ['value']) 23 24

7 Defining members: functions Allmost all you need is to save obj = { value: 1.0, dosomething: function() { return 42; But how to access the variables You either need to pass a pointer to the object Implicitely, like in JavaScript/ECMAScript: obj = { value: 1.0, getvalue: function() { return this.value; Explicitely, like in Python: class Test def init (self): self.value = 1.0 def getvalue(self): return self.value What about classes? With dictionnary we have objects For a class, all we need is a constructor function create_car(self, color, max_speed, max_acceleration): self.color = color self.speed = 0.0 self.max_speed = max_speed self.max_acceleration = max_acceleration self.accelerate = function() { self.speed = Math.min(self.max_speed, self.speed + self.max_acceleration) self.decelerate = function() { self.speed = Math.max(0, self.speed - self.max_acceleration) For inheritance, all we need is to call the super class constructor function create_audi(self, color): create_audi(self, color, 200, 10) Class in JavaScript/ECMAScript What about encapsulation? function Car(color, max_speed, max_acceleration) { this.color = color... Car.prototype.accelerate = function() { self.speed = Math.min(self.max_speed, self.speed + self.max_acceleration) Car.prototype.decelerate =... function Audi(color) { Car.call(color, 200, 10) Audi.prototype = Object.create(Car.prototype) red_audi = new Audi('red') red_audi.accelerate() (Ab)using environment function Car(color, max_speed, max_acceleration) { this.getcolor = function() { return color... And for protected function Car(color, max_speed, max_acceleration, protected = {) { protected.color = color... function Audi(color) { var protected = { Car.call(color, 200, 10, protected) this.getcolor = function() { return protected.color Audi.prototype = Object.create(Car.prototype) 27 28

8 What about polymorphism? Just overwrite function in the child class function Shape() { this.area = function() { throw 'Error'; function Square(width, height) { Shape.call(this) this.area = function() { return width * height Square.prototype = Object.create(Shape.prototype) Revisiting the visitor pattern 29 Object-Oriented Abstract Syntax Tree An Value class class Value: def init (self, value): self.value = value An Operator class class Operator: def init (self, a, b): self.a = a self.b = b An addition class class Addition(Operator): def init (self, a, b): super(). init (a, b)... Example ['+' [1 ['*' [4 ['/' [5 ['+' [ 2 3 ] ]]]]]]] Addition.new(1, Multiplication.new(4, Division.new(5, Addition.new(2, 3)))) 31 32

9 Visitor Oriented Object visitor (1/2) def evaluate(node): if not isinstance(node, list): return node elif node[0] == '+': return evaluate(node[1][0]) + evaluate(node[1][1]) elif node[0] == '-': return evaluate(node[1][0]) - evaluate(node[1][1]) elif node[0] == '*': return evaluate(node[1][0]) * evaluate(node[1][1]) elif array[0] == '/': return evaluate(node[1][0]) / evaluate(node[1][1]) else: raise Error() def evaluate(node): if isinstance(node, Value): return node.value elif isinstance(node, Addition): return evaluate(node.a) + evaluate(node.b) elif isinstance(node, Substraction): return evaluate(node.a) - evaluate(node.b) elif isinstance(node, Multiplication): return evaluate(node.a) * evaluate(node.b) elif isinstance(node, Division): return evaluate(node.a) / evaluate(node.b) else: raise Error() class Visitor: def visitvalue(self, node): return node.value def visitaddition(self, node): return node.a.accept(self) + node.b.accept(self) def visitsubstraction(self, node): return node.a.accept(self) - node.b.accept(self) def visitmultiplication(self, node): return node.a.accept(self) * node.b.accept(self) def visitdivision(self, node): Oriented Object visitor (2/2) class Value:... def accept(self, visitor): return visitor.visitvalue(self) class Addition:... def accept(self, visitor): return visitor.visitaddition(self) Why use the visitor pattern at all? Easy way to extend For an interpreted: A visitor for evaluating A visitor to convert to a different programming language A visitor to generate bytecode

10 Software Exceptions Exceptions Exceptions are events that affect the control flow of a program. An exception allows to return from a function or a statment at any point, with any type and on any number of levels. Exception need to be caught. 38 Control flow and exceptions What are exceptions used for? try: a() rescue Exception: print('rescued') def a(): b() print('never called') def b(): throw Exception() 39 40

11 Exception for error handling Most common use of exception is for error handling More convenient than returning a value (which is not possible in a constructor) Exception for exiting a double loop try: for i in range(0, 10): for j in range(0, 40): if i*j == 300: throw Exception('double break') except: pass Break and return statement Using exception for break and return How to implement the 'break' and 'return' statement? WhileStatement.new(..., [... BreakStatement.new ]) Using a return value? class EvalVisitor: def visitbreakstatement(self, node): return false def visitwhilestatement(self, node): while(node.condition.accept(self)): if not visitchildren(node): break; return true def visitchildren(self, node): for(child in node.children): if(not child.accept(self) return false return true Very similar to error checking 43 Instead, lets use class EvalVisitor: def visitbreakstatement(self, node): throw BreakException() def visitwhilestatement(self, node): try: while(node.condition.accept(self)): visitchildren(node) rescue BreakException: pass def visitchildren(self, node): for(child in node.children): child.accept(self) 44

12 And how to implement exception in the interpreter? Using exceptions... class EvalVisitor: def visitthrowstatement(self, node): throw InterpretedException(node.exceptionType) def visittrycatchstatement(self, node): try: visitchildren(node.body) except InterpretedException as ie: if ie.type == node.exceptiontype: visitchildren(node.catch) else: throw ie Type system 45 What is a type system? Type-Checking A type system defines how a type is associated to a variable Variables are stored as bits in memory A type give meaning to a set of bits In a program, a value is associated to at least one type 47 Static-type checking Types are checked at compilation from static analysis Usually variables have a single type Polymorphism allows for dynamicity Support from downcasting Dynamic-type checking Types are checked at runtime The type of a variable can change Unchecked Example: machine code 48

13 Static-type checking Allow for optimization No need to check for types at runtime Program verification Can work better than unit-tests if(almost always true) { /* valid code */ else { /* type invalid code */ But downcasting cannot be verified with static checking Static-type vs Dynamic-type Trade-off The number of actual errors found through static typing is debatable Dynamic typing allows for faster development and faster compilation Implementing static-typing Implementing dynamic-typing With an AST visitor! Instead of returning a value, return a type class StaticTypeCheckerVisitor: def visitvalue(self, node): return node.type def checkarithmetic(self, typea, typeb): if(typea == typeb): return typea elif(typea.canconvert(typeb)): return typeb elif(typeb.canconvert(typea)): return typea else: throw CompilationError('Invalid types') def visitaddition(self, node): return self.checkarithmetic(node.a.accept(self), node.b.accept(self) def visitassignment(self, node): typevariable = environment.getvariable(node.variablename).type typevalue = node.value.accept(self) if(typevariable!= typevalue and!typevalue.canconvert(typevariable)): throw CompilationError('Invalid types') return typevariable class EvalVisitor: def doarithmetic(self, op, node): a = node.a.accept(self) b = node.b.accept(self) if(a.type == b.type): return op(a, b) elif(a.type.canconvert(b.type)): return op(a.convert(b.type), b) elif(b.type.canconvert(a.type)): return op(a, b.convert(a.type)) else: throw ExecutionError('Invalid types') def visitaddition(node): return self.doarithmetic(operators.add, node) 51 52

14 Strong vs Weak typing A language is said to be strongly typed when it requires explicitely casting Example: ADA A language is said to be weakly typed when it allows certins nonexplicit casting For instance, from integers to floating points Conclusion Object-oriented concept and how to implement them Improved pattern visitor Exceptions and how to use them in an interpreter The implication of a type / 54