XXXXXXXXXXXXXXXXXXXXXXX. Evolution of Software Languages

Transcription

1 Section 8: Simula Smalltalk Evolution of Software Languages Theo D'Hondt Bachelor of Computer Science Faculty of Sciences and Bio-Engineering Sciences Vrije Universiteit Brussel Academic Year

2 Ole-Johan Dahl Kristen Nygaard Simulation language Simula I Simula 67 Extension of Algol 60 Call-by-value default Call-by-name still around Hoare s Record Classes 2

3 Simula basics Class class C(... ); begin... end; Prefix class A class B; begin... end; Garbage collection Assignment begin x := y; p :- q; end; Nested classes class A; begin class B; begin... end; B class C; begin... end;... end; Prefix blocks A begin... B... end; Class parameters class C(... )... new C(...) Casts a qua B.c The development of the SIMULA languages Kristen Nygaard, Ole-Johan Dahl HISTORY OF PROGRAMMING LANGUAGES 439, 1981 ACM ISBN No multiple inheritance X, Y class Z(... ); begin... end; Dot notation C.v Procedures setter :- boolean procedure (... ) begin... end; Virtual entities virtual procedure V(... ) begin... end; 3

4 Hoare s Record Classes cord Classes in 1966 ariation in data structures Expression Constant value: real Variable name: string BinaryExpr left: reference(expression) right: reference(expression) ession) left, right; nce, Product, Quotient)); Sum Product Difference Quotient Subclassing through concatenation 4

5 Simula example: overriding begin class Vehicle; virtual: procedure sound is procedure sound;; begin end; Vehicle class Car ; begin procedure sound; begin OutText("Beep beep"); OutImage; end; end; taken from: /2014-fall/slides/25-history-oo.pdf Vehicle class Bike; begin procedure sound; begin OutText("Ding ding"); OutImage; end; end; ref (Vehicle) array vehicles (1 : 2); Integer i; vehicles (1) :- new Car; vehicles (2) :- new Bike; for i := 1 step 1 until 2 do vehicles(i).sound end; 5

6 Simula example: simulation begin ref (Car) acar; ref (Truck) atruck; class Car; begin Integer N; detach; for N := 1 step 1 until 10 do begin OutText("Driving me insane"); OutImage; resume(atruck); end; end; taken from: /2014-fall/slides/25-history-oo.pdf class Truck; begin Integer N; detach; for N := 1 step 1 until 10 do begin OutText("Keep on truckin'"); OutImage; resume(acar); end; end; acar :- new Car; atruck :- new Truck; resume(acar); end; 6

7 Alan Kay: Xerox PARC computer-history/ /appleand-xerox-parc 7

8 Smalltalk 80 Requires a workstation 1Mpixels memory-mapped display 1Mb memory 32bits processor pointing device with 2 buttons Uses a virtual machine with bytecodes Uses a garbage collecting memory manager Uses a uniform memory model (image) Uses an integrated graphical kernel Uses an object model for all language concepts Single inhertance, ad-hoc poymorphism Uses strong and dynamic typing of all values Metaprogramming and computational reflection A true IDE 8

9 Smalltalk-80 XXXXXXXXXXXXXXXXXXXXXXX the Blue Book 9

10 VUB 10

11 Terminology1 Object Message Receiver Element of Smalltalk composed of private datastructures and a set of operations. Request for an object to perform one of its operations. Object that receives a message. Interface Set of messages identified by an object. Class Instance Specification of the set of objects with identical behaviour Representative of a Class 11

12 Terminology1 Object Message Receiver Interface Element of Smalltalk composed of private datastructures and a set of operations. Request for an object to perform one of its operations. Object that receives a message. Set of messages identified by an object. Class Specification of the set of objects with identical behaviour Representative of a Class InstanceEverything is an object 12

13 Terminology2 Instance variable Method Primitive method System class Name of a private datastructure of an object Implementation of an operation of an object Method directly executed by the Smalltalk virtual machine. Class of the Smalltalk virtual image 13

14 Literal objects Numerical Character String Symbol Aggregate literal objects #('January' ) #(( one' 1 $1) ('two' 2 $2)... ( zero' 0 $0)) 14

15 Variables Variable name Private variables Shared variables Letters, digits Lower case initial Upper case initial 15

16 Pseudo variables Names that refer to specific objects Cannot be assigned a value with <- Some are constant Some have a value depending on the context nil true, false self, super Undefined variable Boolean values Reference to receiver Boolean object = object with interface all messages for logical operations 16

17 Temporary variables argument names and self only exist during the method activation moreover one can introduce local variables with the same characteristics these are being enumerated nominatively between message - pattern and method, preceded and followed by $ ; these are initialized to nil 17

18 Assignment name1 <- name2 <-... <- namen <- expression binds structure as well as contents to a name name refers to an instance of the class determined by the expression colour <- #('red' 'orange' 'green') 18

19 Messages = interactions between objects <receiver> <selector> [ <arguments> ] <receiver> <selector> <arguments> = object that receives and implements the = identity of the message = additional expressions that play a role in the method that implements the message 19

20 Message patterns operator message one or two non alpha numerical symbols ( last $ ); there is exactly one argument numerator / denominator unary message alpha-numerical name and no arguments discriminant sqrt keyword message one or more alpha-numerical names each followed by $:; each keyword associated with an argument letter from:'donald' on:#( ) 20

21 Message evaluation The result of the evaluation of a method, consequence of the sending of a corresponding message, is an object Messages are bi-directional sum < binds the integer object implementing 3 to sum The object returned by a method is not necessarily used Messages are 2nd class function calls 21

22 Left to right for unary messages and operators Unary messages have precedence D <- (b * b (4 * a * c)) sqrt Parentheses are used for reversal of this rule perimeter <- ((rectangle width) + (rectangle height)) * 2 22

23 Expression evaluation2 in case of non unary messages complex arguments have to be enclosed in parentheses R width: x height y R width: (x height y) operators have priority over non unary messages rectangle width: x * 2 height: y * 4 23

24 Cascading multiple successive messages to one object turtle FD: 10; RT: 90; BK: 5 24

25 Blocks Expression of one or more sequential interactions enclosed by $[ and $] and separated by $. Blocks can be assigned to variables : move <- [ turtle FD: 10. turtle RT: 90. turtle BK: 5 ] Does not imply the execution Execution occurs after sending the message value move value 25

26 Control structures1 iteration <integer> timesrepeat: <block> 4 timesrepeat [turtle FD: 50; RT: 90] selection <boolean expression> iftrue: <block> iffalse: <block> x < a > b iftrue:[ a ] iffalse: [ b ] 26

27 Control structures2 block arguments = variable names with $: prefix appearing at the beginning of the block, terminated by $ [:count :sum [count < 10] whiletrue: [count < count + 1. sum < sum + array at: tel]. sum < sum / count ] value: #(0 0) i < 1. [i <= 10] whiletrue: [sum < sum + (list at: i). i < i + 1] 27

28 Control structures2 block arguments = variable names with $: prefix appearing at the beginning of the block, terminated by $ [:count :sum [count < 10] whiletrue: [count < count + 1. sum < sum + array at: tel]. sum < sum / count ] value: #(0 0) closures i < 1. [i <= 10] whiletrue: [sum < sum + (list at: i). i < i + 1] 28

29 Applicative operations do: -message sum < 0. #( ) do: [:sq sum < sum + (sq * sq)] collect: -message list < #( ) collect: [:sq sq * sq] 29

30 Classes Objects For all elements in Smalltalk ( from constant to entire compiler ) Interaction by way of messages that make functionality of the object available. The implementation is hidden Each object is an instance of a class All objects of a class have the same interface 30

31 Classes1 { instance variables } U { methods } Identified by a shared variable - An object identifies its class - Classes are manipulated within an expression A class is an object an instance of a class is created by sending it a message rt < Rectangle new Some classes accept additional messages now < Date today 31

32 Protocol a class is implemented in 2 stages defines # and structure of accepted messages says what, not how is composed of message patterns <message selector> <arguments> selector to be used when sending the message symbolic name(s) for the argument 32

33 Message pattern message rt < Rectangle new. rt lowerleft: # (0 0) upperright: # (10 20) message pattern lowerleft: lb upperright: ra a message pattern is compared ( " matched " ) to a message when sent, and expressions are bound to the symbolic names 33

34 Message implementation A method implements a message argument names refer to expressions within the message, expressions are evaluated one by one; read - only The return - value is stated in one of these two ways : ( 1 ) implicit, the receiver ( 2 ) explicit with arithmetic expressions, i.e. expression with prefix $^ 34

35 Variables a method has access to ( 1 ) instance ( 2 ) temporal ( 3 ) class ( 4 ) global ( 5 ) " pool " name of the class instance variables methods remark : ±free syntax differentiation by way of fonts 35

36 Instance variables lower case initial exist for the total life time of the object are only visible for the implementation of the object represent the state of the object 36

37 Temporary variables lower case initial ) only exist during the execution of a method are only visible for this method are being created / destroyed with sending of message 37

38 Class variables upper case initial identify each of the classes present ( mostly shared variables ) visible everywhere 38

39 Global variables upper case initial instance of an object, beginning with upper case letter visible everywhere 39

40 Pool variables upper case initial shared " variable with limited visibility common to every instance of a subset of the { all classes } 40

41 Primitive methods most methods are implemented by sending messages to other objects some are directly interpreted by Smalltalk : the primitive methods there are more or less a 100 " standard " primitive methods 41

42 Named instance variables added to the list of instance variables are referenced in message expressions making up the methods default initialisation "nil" 42

43 Indexed instance variables1 added to the list implicitly there is only one indexed instance per object are indexed with the at: and at:put: messages indexed with numbers from [ 1, [ 2 instances have = named i.v. but not necessary = # indexed i.v. 43

44 Indexed instance variables2 For instance in String: at: index put: value (size < index ) iftrue: [ self error "overflow"] iffalse: [ ^ self at: index put: value ] at: index ( size < index ) iftrue: [ ^ nil ] iffalse: [ ^ self at: index ] 44

45 Indexed instance variables3 indexed classes ( = classes with indexed instance variables) being instantiated with new: max if at: and at: put: are defined as messages upon an indexed class, then aggregates can be assigned 45

46 Self reference via the self pseudo variable. self refers to the receiver of the message that is being executed. factorial (self = 0) iftrue: [ ^ 1 ]. (self < 0) iftrue: [ self wrong: 'wrong' ] iffalse: [ ^ self * (self - 1) factorial ] 46

47 Subclasses is derived from an existing class the instance variables are automatically copied the list of instance variables may be extended the methods, if not "overridden" are being copied " overriding" happens by introducing a homonym at the subclass level 47

48 Class names class-names are unique instance variable names are unique within a class definition method-names ( message pattern) are unique within a class definition unique within a range of superclasses 48

49 Superclasses a superclass of a class K = a class which K is a subclass of normally : for each class K there is one superclass for each class K there are 0 or more subclasses this defines an hierarchical structure at the root of which we find a unique class that has no superclass: Object 49

50 Superclass chain consider a class K the series of classes, beginning at Object and ending at K such that any 2 succesive classes are each other's superclass / subclass is the superclass chain of K if a message M with pattern P is sent to an instance I of K, the first method encountered with pattern P in the superclass chain of K is executed 50

51 Method lookup (1) M - pattern in K ---> corresponding method is executed (2) M - pattern not in K ---> (a) K = Object ---> abort (b) K <> Object ---> substitute super (K) for K and ---> (1) 51

52 ZZZ self refers to M's receiver ( = instance I of K ) M's method lookup starts in K if delegation ---> superclass this remains the case super = to self M's method lookup starts with the superclass of the class containing the method that contains the message 52

53 Abstract superclasses only serve to be transformed in subclasses should "never" be instantiated 53

54 Subclass framework subclassresponsibility standard message in Object self subclassresponsability generates an errormessage, and is used as implementation of a message in an abstract subclass, which should be overridden in a subclass shouldnotimplement standard message in Object self shouldnotimplement generates an errormessage and is used as implementation of a method that is impossible to implement. 54

55 Metaclasses1 classes are objects ---> each class is instance of a class, called metaclass Object is superclass of each class 55

56 Metaclasses2 the class CLASS is: an abstract superclass of all metaclasses subclass of Object a class and its (meta)class are defined together distinction is made between " class methods " and "instance methods " used for for class instantiation 56

57 Metaclasses3 metaclasses inherit from superclasses with a restriction: there is a parallellism in sub / superclasses between metaclasses and classes IF : class c1 instance of metaclass m1 class c2 instance of metaclass m2 THEN : c1 subclass of c2 m1 subclass of m2 57

58 Object interface1 functionality: class iskindof: aclass ismemberof: aclass ---> receiver's class ---> true if aclass = receiver's class ---> true if aclass (super*) = receiver's class respondsto: asymbol ---> true if asymbol element is of the interface of the receiver's class 58

59 59 XXXXXXXXXXXXXXXXXXXXXXX Object interface2 comparison: == anobject = anobject ~ = anobject ~~ = anobject hash ---> true if receiver and anobject = ---> true if receiver and anobject refer to the same components ---> true if receiver and anobject are not = ---> true if receiver and anobject are not == ---> unique integer reference of the receiver

60 Object interface3 copy : copy shallowcopy ---> instance with equal instance-variable content or shared variable ---> instance with shared instance variables deepcopy ---> instance with copy of the instance variables 60

61 Object interface4 access: at : index at : index put : anobject basicat : index basicat : index put : anobject size basicsize 61

62 Object interface5 error handling: doesnotunderstand: amessage states that the receiver does not understand "amessage" error : astring statement of error identified by "astring" to receiver primitivefailed statement that systemprimitive is abused by receiver shouldnotimplement see before subclassresponsability 62

63 Dictionary framework1 Object subclass: #AbstractDictionary instancevariablenames: 'names values' classvariablenames: '' pooldictionaries: '' category: 'DemoDictionaries' class methods instantiation new private "instantiate new dictionary" size size := self minimalsize. ^ (super new ) initialize: size minimalsize "implementation dependent initial size" self subclassresponsibility instance methods statistics size "dictionary size" self subclassresponsibility 63

64 Dictionary framework2 access at: key "retrieve value corresponding to key" ^self at: key notfound: [ self error: 'key not found'] at: key notfound: block "retrieve value corresponding to key, with user error handling" index index := self indexatkey: key. (index = 0) iftrue: [ block value ] iffalse: [ ^values at: index ] at: key put: value "insert new key / value pair" self at: key put: value duplicate: [ self error: 'duplicate key' ] 64

65 Dictionary framework3 at: key put: value duplicate: block "insert new key / value pair with user error handling" index index <- self newindexatkey: key. (index = 0) iftrue: [ block value ] iffalse: [ values at: index put: value ] at: key replace: value "replace value in existing pair" self at: key replace: value notfound: [self error: 'key not found' ] at: key replace: value notfound: block "replace value in existing pair with user error handling" index index := self indexatkey: key. (index = 0) iftrue: [ block value ] iffalse: [ values at: index put: value ] 65

66 Dictionary framework4 newindexatkey: key "locate index for new key in names" (( self indexatkey: key) = 0) iftrue: [ self extend. names at: names size put: key. ^ names size ] iffalse: [ ^ 0 ] extend "extend implementation by one pair" oldnames oldvalues newsize oldnames := names. oldvalues := values. newsize := names size + 1. names := Array new: newsize. values := Array new: newsize. (1 to: oldnames size) do: [ :index names at: index put: ( oldnames at: index ). values at: index put: ( oldvalues at: index ) ] 66

67 Dictionary framework5 AbstractDictionary subclass: #FastDictionary instancevariablenames: 'size ' classvariablenames: '' pooldictionaries: '' category: 'DemoDictionaries' class methods instantiation new "instantiate new fast dictionary" ^ (super new ) initializesize private minimalsize "implementation dependent initial size" ^4 instance methods statistics size private "dictionary size" ^size 67

68 Dictionary framework6 indexatkey: key "locate index of key in names" index index := ( key hash \\ names size ) + 1. [ ( names at: index ) = key ] whilefalse: [ (names at: index) isnil iftrue: [ ^ 0 ]. index := ( index \\ names size ) + 1 ]. ^ index newindexatkey: key "locate index for new key in names" index (size = names size) iftrue: [ self extend ]. index := ( key hash \\ names size ) + 1. [ ( names at: index ) = key ] whilefalse: [ (names at: index) isnil iftrue: [ size := size + 1. names at: index put: key. ^ index ]. index := ( index \\ names size ) + 1 ]. ^ 0 68

69 Dictionary framework7 extend "extend implementation by doubling the number of pairs" oldnames oldvalues newsize oldnames := names. oldvalues := values. newsize := names size * 2. names := Array new: newsize. values := Array new: newsize. size := 0. (1 to: oldnames size) do: [ :index self at: ( oldnames at: index ) put: ( oldvalues at: index ) ] initializesize "set initial size to 0" size := 0 69

70 Conduit framework1 join pipe source pipe sink source 7 70

71 Conduit framework1 Object subclass: #Conduit instancevariablenames: 'name time capacity content ' classvariablenames: 'ConduitCollection ' pooldictionaries: '' category: 'Conduit-simulation' instance methods private name: aname capacity: acapacity "initialize a new Conduit" time := 0. content := 0. name := aname. capacity := acapacity. self report: 'capacity:' with: capacity 71

72 Conduit framework1 Object subclass: #Conduit instancevariablenames: 'name time capacity content ' classvariablenames: 'ConduitCollection ' pooldictionaries: '' reporting category: 'Conduit-simulation' instance methods private Transcript show: name; tab. name: aname capacity: acapacity Transcript show: 'error:'; tab. "initialize a new Conduit" Transcript show: amessage; cr. time := 0. self halt content := 0. name := aname. capacity := acapacity. self report: 'capacity:' with: capacity error: amessage "report error message" Transcript show: 't ='; tab. Transcript show: time printstring; tab. report: amessage with: anumber "report status message" Transcript show: 't ='; tab. Transcript show: time printstring; tab. Transcript show: name; tab. Transcript show: amessage; tab. Transcript show: anumber printstring; cr 72

73 Conduit framework1 Object subclass: #Conduit instancevariablenames: 'name processing time capacity content ' classvariablenames: 'ConduitCollection ' pooldictionaries: '' reporting fill category: 'Conduit-simulation' "instruct the conduit to fill itself" error: amessage self subclassresponsibility instance methods "report error message" process Transcript show: 't ='; tab. private Transcript "instruct show: the conduit time printstring; to process itself" tab. Transcript ^ self fill show: name; tab. name: aname capacity: acapacity Transcript show: 'error:'; tab. "initialize a new Conduit" tick Transcript show: amessage; cr. time := 0. self "try halt to advance the clock" content := 0. flow name := aname. report: flow amessage := self process. with: anumber capacity := acapacity. "report flow isnil status message" self report: 'capacity:' with: capacity Transcript iffalse: show: 't ='; tab. Transcript [ content show: := time content printstring; + flow. tab. Transcript time show: := time name; + 1. tab. Transcript self show: report: amessage; 'filled' with: tab. flow. Transcript self show: report: anumber 'contains' printstring; with: content cr ] 73

74 Conduit class framework1 methods name: aname capacity: acapacity Object subclass: #Conduit "instantiate a new Conduit" instancevariablenames: 'name processing time conduit capacity content ' classvariablenames: 'ConduitCollection conduit ':= super new name: aname capacity: acapacity. pooldictionaries: '' reporting fill ConduitCollection add: conduit. category: 'Conduit-simulation' "instruct ^ conduit the conduit to fill itself" error: amessage self subclassresponsibility instance methods new "report error message" process Transcript "disable show: message 't ='; " tab. private Transcript "instruct self shouldnotimplement show: the conduit time printstring; to process itself" tab. Transcript ^ self fill show: name; tab. name: aname capacity: acapacity simulation Transcript show: 'error:'; tab. "initialize a new Conduit" tick Transcript show: amessage; cr. time := 0. run: self "try acount halt to advance the clock" content := 0. "perform flow simulation" name := aname. report: flow amessage acount := self timesrepeat: process. with: anumber capacity := acapacity. "report flow isnil status [ ConduitCollection message" do: [ : conduit conduit tick] ] self report: 'capacity:' with: capacity Transcript iffalse: show: 't ='; tab. initialisation Transcript [ content show: := time content printstring; + flow. tab. Transcript time show: := time name; + 1. tab. initialize Transcript self show: report: amessage; 'filled' with: tab. flow. Transcript "initialise self show: report: Conduit anumber 'contains' framework" printstring; with: content cr ] Transcript clear; show: 'Conduit simulation'; cr. ConduitCollection := OrderedCollection new instance creation 74

75 Conduit class framework1 methods name: aname capacity: acapacity Object subclass: #Conduit "instantiate a new Conduit" example instancevariablenames: 'name processing time conduit capacity content ' classvariablenames: 'ConduitCollection conduit ':= super new name: aname capacity: acapacity. simulate pooldictionaries: '' reporting fill ConduitCollection add: conduit. "Conduit category: simulate" 'Conduit-simulation' "instruct ^ conduit the conduit to fill itself" source1 source2 pipe1 pipe2 pipe3 error: join1 amessage self sink1 subclassresponsibility Conduit instance initialize. methods new "report error message" source1 := Source name: 'Source 1' process capacity: Transcript "disable 5 profile: show: message 't#((10 ='; " tab. 1) (20 3) (40 1) (50 4) (80 1) (90 5)). pipe1 private := Pipe name: 'Pipe 1' capacity: Transcript 4 "instruct inconduit: self shouldnotimplement show: the source1. conduit time printstring; to process itself" tab. source2 := Source name: 'Source 2' capacity: Transcript ^ self fill 4 profile: show: name; #((10 2) tab. (20 4) (40 1) (50 2) (80 1) (90 4)). pipe2 name: := Pipe aname name: capacity: 'Pipe 2' capacity: acapacity simulation Transcript 2 inconduit: show: source2. 'error:'; tab. join1 := "initialize Join name: a new 'Join Conduit" 1' capacity: tick Transcript 3 inconduit1: show: pipe1 amessage; inconduit2: cr. pipe2. pipe3 := time Pipe := name: 0. 'Pipe 3' capacity: run: self 3 "try inconduit: acount halt to advance join1. the clock" sink1 := content Sink name: := 0. 'Sink 1' capacity: 4 "perform inconduit: flow simulation" pipe3. Conduit name run: 50 := aname. report: flow amessage acount := self timesrepeat: process. with: anumber capacity := acapacity. "report flow isnil status [ ConduitCollection message" do: [ : conduit conduit tick] ] self report: 'capacity:' with: capacity Transcript iffalse: show: 't ='; tab. initialisation Transcript [ content show: := time content printstring; + flow. tab. Transcript time show: := time name; + 1. tab. initialize Transcript self show: report: amessage; 'filled' with: tab. flow. Transcript "initialise self show: report: Conduit anumber 'contains' framework" printstring; with: content cr ] Transcript clear; show: 'Conduit simulation'; cr. ConduitCollection := OrderedCollection new instance creation 75

76 Conduit framework1 Conduit subclass: #Sink instancevariablenames: 'inconduit ' classvariablenames: '' pooldictionaries: '' category: 'Conduit-simulation' instance methods processing fill fill "instruct the Sink to fill itself" ^ inconduit drain: capacity capacity ~ section private inconduit: adrainableconduit "initialize a new Sink" inconduit := adrainableconduit class methods instance creation name: aname capacity: acapacity inconduit: adrainableconduit "instantiate a new Source" ^ (super name: aname capacity: acapacity) inconduit: adrainableconduit 76

77 Conduit framework1 Conduit subclass: #DrainableConduit instancevariablenames: 'lastflow ' classvariablenames: '' pooldictionaries: '' category: 'Conduit-simulation' instance methods processing drain: maxflow "drain the Conduit" flow lastflow isnil iffalse: [ lastflow := nil. flow := self flush: maxflow. content := content - flow. self report: 'drained' with: flow. ^flow ] iftrue: [ self report: 'requested' with: maxflow. ^ nil ] 77

78 Conduit framework1 Conduit subclass: #DrainableConduit instancevariablenames: 'lastflow ' classvariablenames: '' pooldictionaries: '' category: 'Conduit-simulation' instance methods processing flush: maxflow "flush the Conduit" content > maxflow iftrue: [ ^ maxflow ] iffalse: [ ^ content ] flow := self flush: maxflow. content := content process - flow. self report: 'drained' with: "instruct flow. the conduit to process itself" lastflow isnil iftrue: [ self report: 'requested' with: maxflow. [ lastflow := self fill ]. ^ nil ] ^ lastflow drain: maxflow "drain the Conduit" flow lastflow isnil iffalse: [ lastflow := nil. ^flow ] iftrue: 78

79 Conduit framework1 DrainableConduit subclass: #Pipe instancevariablenames: 'inconduit cells ' classvariablenames: 'PipeLength ' pooldictionaries: '' category: 'Conduit-simulation' instance methods private inconduit: adrainableconduit "specific initialisation" PipeLength isnil iftrue: [ PipeLength := 10 ]. inconduit := adrainableconduit. cells := (Array new: PipeLength) atallput: 0 delay ~ length fill drain capacity ~ section 79

80 Conduit framework1 DrainableConduit subclass: #Pipe instancevariablenames: 'inconduit processing cells ' classvariablenames: 'PipeLength ' pooldictionaries: '' fill category: 'Conduit-simulation' "instruct the Pipe to fill itself" instance methods private inconduit: adrainableconduit "specific initialisation" PipeLength isnil iftrue: [ PipeLength := 10 ]. inconduit := adrainableconduit. cells := (Array new: PipeLength) atallput: 0 flow free used available used := cells at: 1. flow := inconduit drain: capacity - used. flow isnil iftrue: [ ^ nil ]. cells at: 1 put: used + flow. PipeLength to: 2 by: -1 do: [ : index available := cells at: index - 1. used := cells at: index. free := capacity - used. available <= free iftrue: [ cells at: index - 1 put: 0. cells at: index put: used + available ] iffalse: [ cells at: index - 1 put: available - free. cells at: index put: capacity ] ]. ^ flow 80

81 Conduit framework1 DrainableConduit subclass: #Pipe instancevariablenames: 'inconduit processing cells ' classvariablenames: 'PipeLength ' pooldictionaries: '' fill category: 'Conduit-simulation' "instruct the Pipe to fill itself" flow free used available instance methods used := cells at: 1. flush: maxflow flow := inconduit drain: capacity - used. private "flush the Pipe" flow isnil available iftrue: inconduit: adrainableconduit available := cells at: PipeLength. [ ^ nil ]. "specific initialisation" available > maxflow cells at: 1 put: used + flow. PipeLength isnil iftrue: PipeLength to: 2 by: -1 do: iftrue: [ cells at: [ PipeLength : index put: (available - maxflow). [ PipeLength := 10 ^ ]. maxflow available ] := cells at: index - 1. inconduit := adrainableconduit. iffalse: used := cells at: index. cells := (Array new: PipeLength) [ cells at: atallput: PipeLength free := 0 capacity put: 0. - used. ^ available available ] <= free iftrue: [ cells at: index - 1 put: 0. cells at: index put: used + available ] iffalse: [ cells at: index - 1 put: available - free. cells at: index put: capacity ] ]. ^ flow 81

82 Conduit framework1 DrainableConduit subclass: #Pipe instancevariablenames: 'inconduit processing cells ' classvariablenames: 'PipeLength ' pooldictionaries: '' fill category: 'Conduit-simulation' "instruct the Pipe to fill itself" flow free used available instance methods used := cells at: 1. flush: maxflow flow := inconduit drain: capacity - used. private "flush the Pipe" flow isnil available iftrue: inconduit: adrainableconduit available := cells at: PipeLength. [ ^ nil ]. "specific initialisation" available > maxflow cells at: 1 put: used + flow. PipeLength isnil iftrue: PipeLength to: 2 by: -1 do: iftrue: [ cells at: [ PipeLength : index put: (available - maxflow). class methods [ PipeLength := 10 ^ ]. maxflow available ] := cells at: index - 1. inconduit := adrainableconduit. iffalse: used := cells at: index. instance creation cells := (Array new: PipeLength) [ cells at: atallput: PipeLength free := 0 capacity put: 0. - used. ^ available available ] <= free name: aname capacity: acapacity inconduit: adrainableconduit iftrue: "instantiate a new Pipe" [ cells at: index - 1 put: 0. ^(super name: aname capacity: acapacity) inconduit: cells adrainableconduit at: index put: used + available ] iffalse: [ cells at: index - 1 put: available - free. cells at: index put: capacity ] ]. ^ flow 82

83 Conduit framework1 DrainableConduit subclass: #Join instancevariablenames: 'inconduit1 inconduit2 flow1 flow2 ' classvariablenames: '' pooldictionaries: '' category: 'Conduit-simulation' delay ~ standard instance methods processing fill fill fill "instruct the Join to fill itself" flow flow1 isnil iftrue: [ flow1 := inconduit1 drain: (capacity - content) // 2 ]. flow2 isnil iftrue: [ flow2 := inconduit2 drain: (capacity - content + 1) // 2 ]. flow1 isnil flow2 isnil iftrue: [ ^ nil ] iffalse: [ flow := flow1 + flow2. flow1 := nil. flow2 := nil. ^ flow ] 83 capacity ~ section drain

84 Conduit framework1 DrainableConduit subclass: #Join processing instancevariablenames: 'inconduit1 inconduit2 flow1 flow2 ' classvariablenames: '' fill pooldictionaries: '' "instruct the Pipe to fill itself" category: 'Conduit-simulation' flow free used available used := cells at: 1. instance methods flow := inconduit drain: capacity - used. flow isnil processing iftrue: [ ^ nil ]. fill private cells at: 1 put: used + flow. "instruct the Join to fill itself" PipeLength to: 2 by: -1 do: flow inconduit1: adrainableconduit1 [ : index inconduit2: adrainableconduit2 flow1 isnil iftrue: "initialize a new Join" available := cells at: index - 1. [ flow1 := drain: (capacity - content) used := cells // 2 at: ]. index. class methods inconduit1 := adrainableconduit1. flow2 isnil iftrue: inconduit2 := adrainableconduit2. free := capacity - used. [ flow2 := inconduit2 drain: (capacity - content available + <= 1) // free instance creation flow1 := nil. 2 ]. flow1 isnil flow2 flow2 isnil := nil iftrue: iftrue: [ cells at: index - 1 put: 0. name: aname capacity: acapacity inconduit1: adrainableconduit1 [ ^ nil ] cells at: index put: used + available ] inconduit2: iffalse: iffalse: adrainableconduit2 "instantiate a new Join" [ flow := flow1 + flow2. [ cells at: index - 1 put: available - free. ^ (super name: aname capacity: acapacity) flow1 := nil. cells at: index put: capacity ] ]. inconduit1: adrainableconduit1 flow2 := nil. ^ flow inconduit2: adrainableconduit2 ^ flow ] 84

85 Conduit framework1 DrainableConduit subclass: #Source instancevariablenames: 'sourceprofile produced ' classvariablenames: '' pooldictionaries: '' category: 'Conduit-simulation' fill instance methods capacity ~ volume processing fill "instruct the Source to fill itself" flow flow := sourceprofile check: time. (content + flow) > capacity iftrue: [ self report: 'overflow' with: content + flow - capacity. flow := capacity - content ]. produced := produced + flow. self report: 'produced' with: produced. ^ flow drain 85

86 Conduit framework1 private DrainableConduit subclass: #Source profile: asequence instancevariablenames: 'sourceprofile produced ' "specific initialisation" classvariablenames: '' item pooldictionaries: '' produced := 0. category: 'Conduit-simulation' sourceprofile := Profile new. 1 to: asequence size do: instance methods [ : index item := asequence at: index. processing sourceprofile register: (item at: 1) with: (item at: 2) ] fill "instruct the Source to fill itself" flow flow := sourceprofile check: time. (content + flow) > capacity iftrue: [ self report: 'overflow' with: content + flow - capacity. flow := capacity - content ]. produced := produced + flow. self report: 'produced' with: produced. ^ flow 86

87 Conduit framework1 private DrainableConduit subclass: #Source profile: asequence instancevariablenames: 'sourceprofile produced ' "specific initialisation" classvariablenames: '' item pooldictionaries: '' produced := 0. category: 'Conduit-simulation' sourceprofile := Profile new. 1 to: asequence size do: instance methods [ : index item := asequence at: index. processing sourceprofile register: (item at: 1) with: (item at: 2) ] class methods fill "instruct instance the Source creation to fill itself" flow flow := sourceprofile name: aname check: capacity: time. acapacity profile: asequence (content + flow) "instantiate > capacity a new Source" iftrue: ^ (super name: aname capacity: acapacity) profile: asequence Conduit initialize [ self report: 'overflow' with: content + flow - capacity. flow := capacity - content ]. produced := produced + flow. self report: 'produced' with: produced. ^ flow 87

88 Conduit framework1 configuration Object subclass: #Profile instancevariablenames: 'times flows register: top ' atime with: aflow classvariablenames: 'MaxTable MaxTime "set ' times and flows" pooldictionaries: '' top = MaxTable category: 'Conduit-simulation' iftrue: [ self error: 'Profile overflow' ]. instance methods top := top + 1. times at: top put: atime. accessing flows at: top put: aflow 4 check: atime "retrieve current flow" time top = 0 iftrue: private initprofile "initialize a new Profile" MaxTable isnil [ self error: 'Profile not initialized' ]. iftrue: time := atime rem: MaxTime. [ MaxTable := to: top do: [ :index class methods MaxTime := 100 ]. top := 0. (times at: index) >= time iftrue: instance creation times := Array new: MaxTable. flows := Array new: MaxTable [ ^ flows at: index ] ]. ^ flows at: 1 new "instantiate a new Profile " ^ super new initprofile

89 Smalltalk goodies Memory management with handles (become:) Garbage collection Integrated graphics (bitblt) Metaprogramming Processes Model view controller Collections... 89

90 Smalltalk goodies Memory management with handles (become:) Garbage collection Integrated graphics (bitblt) Metaprogramming BUT... Processes No vararg (perform:) Model view controller Closures methods Collections Single image

91 Conclusion Smalltalk is major milestone: less powerful than Lisp but much more accessible It made objects popular It made dynamic languages popular It made metaprogramming popular It made garbage collection popular It showed the way for GUI / IDE It enabled versioning and OO databases It led the way to Self, Java,... It was/is a commercially viable platform And so many things more... 91

92 Assignment 1. Make Squeak run ( 2. Make Squeak run the Conduit simulation 92