1 The Class Concept u Abstraction u What

1 The Class Concept u. Abstraction u. What is a class? u. Two parts of the class u. Two views of the class u. Class vs. type

A Class -- Abstraction Over Objects 2 A class represents a set of objects that share a common structure and a common behavior. COM 3230

Class = Abstraction Over Objects 3 u Phenomena: Similar Objects u Abstraction Mechanism: Class l Basic Metaphor: Data Type An Abstraction Process COM 3230

Dimensions of the Class Concept 4 u Static vs. Dynamic Aspects u Shared vs. Particular features u Internal vs. External views l Multiple Interfaces u The Data Type Metaphor u Relationship with Instances l Class as an instance factory u Existence as an Object l Meta classes COM 3230

5 What is a Class? u Abstraction Over Objects: a set of objects that share: l Dynamic Aspect n Protocol: Declarations (signatures) of function members in C++ n Behavior: Definitions (body) of function members in C++ l Static Aspect n Structure: Declarations of data members in C++. • But not the definitions (value) of data members. l State is not part of the class abstraction. u Mould for objects: used to instantiate objects (instances) with distinct identities that share protocol, behavior and structure but may assume different states. n In contrast to concrete object, a class does not necessarily exist in (run) time and (memory) space. u What’s not a Class? l An object is not a class, but a class may be an object. n In “exemplar based’’ languages, there are no classes. New objects are “instantiated” from existing objects. l Not every set of objects is a class COM 3230

6 Collaborating Classes: UML find all persons waiting at any bus stop on a bus route bus. Stops Bus. Route buses Bus. List 0. . * Bus Static aspect Dynamic aspect NU Bus. Stop. List OO solution: one method for each red class 0. . * Bus. Stop waiting passengers Person. List Person 0. . * COM 3230

7 Object. Graph: in UML notation Route 1: Bus. Route bus. Stops buses : Bus. List : Bus. Stop. List Central. Square: Bus. Stop waiting : Person. List Bus 15: Bus passengers : Person. List Joan: Person Paul: Person Seema: Person Eric: Person NU COM 3230

Shared vs. Particular Features 8 COM 3230

A Different Abstraction over Objects 9 u Common Parts: l Structure l Protocol u Specified per Instance: l State: values of data members. l Behavior: “values” of function members. class Stack { enum { N = 100 }; int buff[N]; int size; public: void (*push)(int element); int (*pop)(void); }; Abstraction, but not of the desired nature! COM 3230

The Two Views of a Class 10 u Implementation: the common structure and the details of how the behavior works. n Body in Ada n Definitions of function members in C++ u Interface: the common protocol and the external specifications of the behavior. n Specification in Ada n Declarations in C++ l Interface as a Contract: defines the contract of the relationship between instances of the class and their clients. l Strongly typed languages can detect some contract violations prior to run time. u Interface Components: l Declaration of all class operations l Declarations of externally accessible attributes l Other pertinent declarations: constants, exceptions and other classes and/or types, etc. u Multiple Interfaces: frequently, the class has different interfaces to different kinds of clients. l Example: electronic mail agent has different interfaces to users and to administrators. COM 3230

11 Java Interface Class. Graph. I u Collection get. Incoming. Edges(Object v) A List of edges (Edge. I objects) coming into node v. u Object get. Node(String l) The node labeled l in the class graph. u Collection get. Nodes() A collection of nodes in the class graph. u Collection get. Outgoing. Edges(Object v) A collection of edges (Edge. I objects) going out of node v. NU COM 3230

UML class graph 12 H f F D A NU e g G E B C COM 3230

Java: how to use the Interface 13 u public class Class. Graph extends Object implements Class. Graph. I NU COM 3230

Java Interface Edge. I 14 u String get. Label() The label of the edge, or null if it is not a construction edge. u Object get. Source() The source node of the edge. u Object get. Target() The target node of the edge. u boolean is. Construction. Edge() Is the edge a construction (part) edge? u boolean is. Inheritance. Edge() Is the edge an inheritance (superclass) edge? NU COM 3230

Implementation in the Interface? 15 u In C++, the structure of an instance is defined in the private part of class interface. l Give away state information l Changes to representation -> a functional affect on clients. u Why isn’t the structure of an instance part of the Implementation? l Needed by the compiler. l Cannot allocate memory for objects without knowing their size. l Size is determined by structure. u Alternatives: l OO Hardware: technology is not sufficiently advanced. l Sophisticated Compilers: slowly, but coming. l Other OOPLs: not as sexy as C++ and Java. COM 3230

16 The Two Parts of a Class u Dynamic Part: specifications of the dynamic aspects of the class instances. u Static Part: specifications of the static aspects of the class instances. u Example: views and parts in Smalltalk. Implementation Interface Static Part Dynamic Part Instance Variables --- Messages & Methods COM 3230

17 Views and Parts in C++ u Kinds of Interfaces in C++ l Users of a Class: Instances Subclasses Clients l Levels of Visibility: private protected public Static Part private data Implementation members public data Interface members Dynamic Part private function members public function members COM 3230

Public Data Members? 18 class Person { public age int; } class Person { private a int; public int age() {return a; } } class Person{ public int age() {return current_year-birth_year; } } AVOID INTERFACE CHANGES NU COM 3230

Views and Parts in Eiffel l l 19 Level and direction of export are orthogonal to kind of feature. User cannot know the kind of implementation of a feature. Static Part Implementation Interface Dynamic Part Unexported attributes Unexported routines Exported without args? Exported routines COM 3230

20 Abstract Data Types and Classes u Type: A set of values with common operations l Main Application: protect mixing unrelated values/operations l Example 1: Decree forbidding pointers multiplication l Example 2: Decree against assigning a struct to an int variable u Abstract Data Type: defined by the set of basic values, means of generating other values, set of allowed operations and their meaning. l Example: Boolean type in Pascal. n Values: True, False. n Operations: Not, And, Or, =, <>, <=, >=, <, >. n Implicit Operations: Assignment, argument passing, function return value. Conversion to integer (ord). u Class: A lingual mechanism that gives the means for realization of a: l Type l Abstract Data Type l Abstraction COM 3230

User Defined Types 21 u If a user-defined type is to be a first class citizen (have the look and feel of a built-in type), then the programming language must provide the ability to define for it: u Initialization u Memory management: l Allocation l Deallocation u Type conversions u Literals (basic values) u A set of operators l Operator overloading COM 3230

22 Inheritance u u Sets, Objects and Inheritance Specialization and Factorization Basic Terminology and Notation Inheritance Hierarchies COM 3230

Inheritance -- What does it look like? 23 COM 3230

24 The Personnel Example u Suppose we want to computerize our personnel records. . . u We start by identifying the two main types of employees we have: struct Engineer { Engineer *next; char *name; short year_born; short department; int salary; char *degrees; void raise_salary( int how_much ); //. . . }; struct Sales. Person { Sales. Person *next; char *name; short year_born; short department; int salary; float *commission_rate; void raise_salary( int how_much ); //. . . }; COM 3230

25 Factorization and Specialization struct Employee { char *name; short year_born; short department; int salary; Employee *next; void raise_salary( int how_much ); //. . . }; struct Engineer: Employee { char *degrees; //. . . }; C version: struct Engineer { struct Employee E; char *degree; /*. . . */ }; Indeed, inclusion is a poor man’s (poor) imitation of inheritance! struct Sales. Person: Employee { float *commission_rate; //. . . }; COM 3230

26 Program Domain Example Shape Location Rotation Move Locate Rotate Observe the OMT (Object Modeling Technique) style of using a triangle for denoting Inheritance Rectangle Ellipse Draw COM 3230

27 Inheritance Hierarchy Vehicle Land Vehicle Car u Truck Water Vehicle Boat Submarine Observe the direction of the arrows! Air Vehicle Airplane Rocket Fundamental Rule: l Suppose that a Vehicle has a n speed attribute, and n an accelerate method, l then all other classes in the above diagram will have (at least) n speed attribute, and n the same accelerate method. u Classification of hierarchies: l Connected / Disconnected l Tree / DAG COM 3230

Terminology: Smalltalk vs. C++ Smalltalk 28 C++ Inherit/Derive Superclass Base class Subclass Derived class Instance Variable Data Member Method Member function Message Member function call Class Variable Static data member Class Method Static function member COM 3230

The Eiffel Terminology 29 u Inheritance: l l l Heir: immediate subclass. Descendant: transitive closure of the heir relation. Proper Descendant: Descendant minus heir. Parent: immediate super-class. Ancestor: transitive closure of the parent relation. Proper Ancestor: Ancestor minus parent. u Taxonomy of features: l Feature: member in C++. n Attribute: data member of C++. n Routine (Service): function member in C++. • Procedure (Command): void function member in C++ (Mutator). • Function (Query): ordinary function member in C++ (Inspector). COM 3230

30 Typing and Strict Inheritance u Value, Type, Variable u Static and Dynamic Typing u Strict Inheritance COM 3230

Value, Type, Variable 31 u Value - the entities manipulated by programs. l Contents of a memory cell at a specific moment. l State of an object. u Type - means of classification of values. l Type is a set of values that have similar protocol. n Protocol - collection of permissible operations. u Variable l A name of a memory cell that may contain values. COM 3230

32 Object. Graph: in UML notation A value Route 1: Bus. Route bus. Stops buses : Bus. List : Bus. Stop. List Central. Square: Bus. Stop waiting : Person. List Bus 15: Bus passengers : Person. List Joan: Person Paul: Person Seema: Person Eric: Person NU COM 3230

33 Significance of Type u Type Determines Meaning: What will be executed as a result of the following expression? a + b l Integer addition, if a and b are integer, or l Floating point addition, if a and b are of floating point type, or l Conversion to a common type and then addition, if a and b are of different types. u Type determines what’s allowed: Is the following expression legal? X[i] l Yes, if X of an array type and i is of an integral type. l No, e. g. , if X is a real number and i is a function. COM 3230

34 Loopholes in the Type System Types usually hide the fact that a variable is just a box of bits, however: Type Casting, as in = &i, *q = &j; ((long) p) ^ ((long) q)); long i, j, *p long ij = and union (variable records), as in union { float f; l; long } d; d. f = COM 3230

Typing in Languages 35 u Formal Lang. : classified by significance of type l Strongly typed languages: a type is associated with each value. It is impossible to break this association within the framework of the language. n ML, Eiffel, Modula, . . . l Weakly typed languages: values have associated types, but it is possible for the programmer to break or ignore this association. n C, Turbo-Pascal l Untyped languages: values have no associated type. n Assembly, BCPL, Lisp, Mathematical formulae. u Programming Lang. : classified by time of enforcement l Dynamic typing: type rules are enforced at run-time. Variables have no associated type. n Smalltalk, Prolog, . . . l Static typing: type rules are enforced at compile time. All variables have an associated type. n C, Pascal, Eiffel, ML, . . . COM 3230

36 Dynamic Typing u Type is associated with values. Each value carries a tag, identifying its type. u A variable may contain any value of any type. My. Book “Nineteen-eighty-four” 1984 string Integer COM 3230

37 Strong Typing -- What does it look like? Strong typing prevents mixing abstractions. COM 3230

38 Static Typing (is Strong Typing) u In static typing, each variable, and even more generally, each identifier is associated with a type. Type Identifier l This usually means that all identifiers should be declared before used. However this is not always the case: n Type inference in ML. n Implicit type inference in Fortran. n Grammatical type inference in some dialects of Basic. l A variable may contain only values of its associated type. u All expressions are guaranteed to be type-consistent: l No value will be subject to operations it does not recognize. l This allows the compiler to engage in massive optimization. u Static typing goes together with strong typing: l The two terms are used almost synonymously in the literature and in this course. l In OOP, the preferred term is strong typing, since, as we will see later, there is also a notion of dynamic type even in statically/strongly typed systems. COM 3230

39 Why Static Typing? u Recursive functions theory teaches us that an automatic tool is very limited as a programming aid l Cannot determine if the program stops. l Cannot determine if the program is correct. l Cannot decide almost any other interesting run time property of a program. u One thing that can be done automatically is make sure that no run time type error occurs. u We can use every tiny bit of help in our struggle against the complexity of software! l Few other automatic aids are: n Garbage collection n Const correctness n Pre and post conditions COM 3230

Design by contract 40 u Object-Oriented Software Construction by Bertrand Meyer, Prentice Hall u The presence of a precondition or postcondition in a routine is viewed as a contract. NU COM 3230

Rights and obligations 41 u Parties in the contract: class and clients u require pre, ensure post with method r: If you promise to call r with pre satisfied then I, in return, promise to deliver a final state in which post is satisfied. u Contract: entails benefits and obligations for both parties NU COM 3230

Rights and obligations 42 u Precondition binds clients u Postcondition binds class NU COM 3230

Example NU 43 COM 3230

If precondition is not satisfied 44 u If client’s part of the contract is not fulfilled, class can do what it pleases: return any value, loop indefinitely, terminate in some wild way. u Advantage of convention: simplifies significantly the programming style. NU COM 3230

Source of complexity 45 u Does data passed to a method satisfy requirement for correct processing? u Problem: no checking at all or: multiple checking. u Multiple checking: conceptual pollution: redundancy; complicates maintenance u Recommended approach: use preconditions NU COM 3230

Class invariants and class correctness 46 u Preconditions and postconditions describe properties of individual methods u Need for global properties of instances which must be preserved by all routines u 0<=nb_elements; nb_elements<=max_size u empty=(nb_elements=0); NU COM 3230

Class invariants and class correctness 47 u A class invariant is an assertion appearing in the invariant clause of the class. u Must be satisfied by all instances of the class at all “stable” times (instance in stable state): l on instance creation l before and after every remote call to a routine (may be violated during call) NU COM 3230

Class invariants and class correctness 48 u A class invariant only applies to public methods; private methods are not required to maintain the invariant. NU COM 3230

Invariant Rule u NU 49 An assertion I is a correct class invariant for a class C iff the following two conditions hold: l The constructor of C, when applied to arguments satisfying the constructor’s precondition in a state where the attributes have their default values, yields a state satisfying I. l Every public method of the class, when applied to arguments and a state satisfying both I and the method’s precondition, yields a state satisfying I. COM 3230

50 Invariant Rule u u u NU Precondition of a method may involve the initial state and the arguments Postcondition of a method may only involve the final state, the initial state (through old) and in the case of a function, the returned value. The class invariant may only involve the state COM 3230

Invariant Rule u u NU 51 The class invariant is implicitly added (anded) to both the precondition and postcondition of every exported routine Could do, in principle, without class invariants. But they give valuable information. Class invariant acts as control on evolution of class A class invariant applies to all contracts between a method of the class and a client COM 3230

52 Resource Allocation reqs <Job. Category> 0. . * type schedule <Job> when: Time. Interval 0. . * <Facility> provides 0. . * allocated 0. . 1 <Resource> inv Job: : allocated<>0 ==> allocated. provides->includes. All(type. reqs) --Any allocated resource must have the required facilities inv Resource: : jo 1, jo 2: Job: : (schedule->includes. All({jo 1, jo 2}) ==> jo 1. when. no. Overlap(jo 2. when) -- no double-booking of resources NU COM 3230

Benefits of Strong Typing 53 u Enforce the design decisions. u Prevent runtime crashes: l Mismatch in # of parameters l Mismatch in parameters l Sending an object an inappropriate message u Early error detection reduces: l Development time l Cost l Effort u Type declarations help to document programs l X: speed; l Y: real; l Z = 3; (* Good *) (* Bad *) (* Worse *) u More efficient and more compact object code l type SMALL_COUNTER is range 0. . 128; COM 3230

54 Benefits of Strong Typing class A { Object b; Object c; } class B { Object d; } class C extends B { } Object b c d A D B C If all instance variables are of class Object we get strange class graphs COM 3230

55 Benefits of Strong Typing class A { B b; C c; } class B { D d; } class C extends B { } Object c A D b B C d COM 3230

56 Strict Inheritance u Extension of base class: l Structure l Protocol l Behavior u Engineer and Sales. Person extend, each in its own way, the structure and protocol of Employee. u Identifying the Employee abstraction, helps us define more types: struct Manager: public Employee { char *degrees; //. . . }; General Idea: similar to procedure call, but applied to data. l If procedure P calls procedure Q, then it can be said that “P extends Q” n P does everything that Q does + more. COM 3230

Is-A Relationship 57 u Inheritance represents an is a relationship. l A subclass is a (more specialized) version of the base class: n Manager is an Employee. n Rectangle is a Shape. u A function taking the class B as an argument, will also accept a class D derived from B. class Monom {. . . } class. . . } d 1, Monom {. . . }; operator +(Monom m 1, Monom m 2) DMonom: public Monom { d 2; Monom m = d 1 + d 2; COM 3230

Types and OOP 58 u Types and Classes l Types: Administrative aid n Check for typos. n Type predicates and type calculus. l Classes: A mould for creating objects Usually, type = class. u Subtypes and Subclasses l Subtype: a type which is a subset of another type. l Subclass: a class that inherits from another class. n Extend the mould. Usually, the subtype and subclass relationship are isomorphic. u Strict inheritance and Subtypes: l With strict inheritance, we have full conformance and substitutability, and therefore, a subclass is always a subtype. COM 3230

59 Properties of Strict Inheritance u The structure and the behavior of a subclass are a superset of those of the superclass. l The only kind of inheritance in Oberon (the grand-daughter of Pascal). u Conformance (AKA substitutability) l If a class B inherits from another class A, then the objects of B can be used wherever the objects of A are used. u Benefits of strict inheritance: l New abstraction mechanism: extend a given class without touching its code. Except in the total size of objects, l No performance penalty. which, due to alignment, depends on the depth of inheritance hierarchy n Compile-time creature. n Can be thought of as a syntactic sugar which helps define classes. l No conceptual penalty. n Structured path for understanding the classes. u Drawbacks of strict inheritance: l Not overly powerful! COM 3230

Collections in Little Smalltalk u u u 60 What are they? Kinds of collections. Basic Operations. Usage of Inheritance in the Collections Library. Roman numbers example. The Stack Example: l Defining a new kind of collection. COM 3230

61 What are Collections? u Collections provide the means for managing and manipulating groups of objects. Kinds of collections: l Set: represents an unordered group of objects. Elements are added and removed by value. l Dictionary: is also an unordered collection of elements, but insertions and removals require an explicit key. l Interval: represents a sequence of numbers in arithmetic progression, either ascending or descending. l List: is a group of objects having a specific linear ordering. Insertions and removals are done in the extremes. l Array: a fixed-size collections. Elements can not be inserted or removed, but they may be overwritten. l String: can be considered to be a special form of Array, where the elements must be characters. u Collections can be converted into a different kind by the use of messages like as. Set, as. Array, etc. COM 3230

Classification of Collections 62 u The different kinds of Collections may be classified according to several attributes. u Size l Fixed l Unbounded u Ordering l Ordered l Unordered u Access Method l By value l Indexed l Sequential F Choose the right Collection by examining its attributes. COM 3230

63 Collections’ Attributes Name Creation Fixed Method Size? Order? Insertion Access Method Removal Method Set new no no add: includes: remove: Dictionary new no no at: put: at: remove. Key: Interval n to: m yes none List new no yes add. First: add. Last: first remove. First remove: Array new: yes at: put: at: none String new: yes at: put: at: none Note however that the implementation of new: in the class String is buggy. It creates a string of size 0! This is rarely a problem, since one usually creates strings as literals. COM 3230

64 Inserting an Element u Indexed collections (Dictionary, Array) require an explicit key and a value, by using the method at: put: > D <- Dictionary new at: 'com 1204' put: 'OOP'; at: 'com 3230' put: 'OOD'; at: 'com 3351' put: 'PPL' Dictionary ( 'com 1204' 'com 3230' 'com 3351' ) u Non-indexed collections require only a value, by using the method add: > S <- Set new add: 'red'; add: 'green'; add: 'blue' Set ( 'blue' 'green' 'red' ) u In the case of Lists the values can be added in the beginning or end of the collection, by using the methods add. First: and add. Last: > L <- List new add. Last: 'End'; add. First: 'Begin' List ( 'Begin' 'End' ) COM 3230

65 Removing an Element u In indexed collections the removal method requires the key. > D remove. Key: 'com 1204' Dictionary ( 'com 3230' 'com 3351' ) u In collections with fixed size (Array and String) elements can not be removed. u In non-indexed collections the argument is the object to be removed. > S remove: 'green' Set ( 'blue' 'red' ) u In a List, an element can be removed from the beginning (remove. First) or by value (remove: ). > L remove. First remove: 'END' List ( ) COM 3230

66 Accessing an Element u In indexed collections the elements are accessed by key. > 'Small. Talk' at: 6 $T u The method keys returns the keys of an indexed collection. > D keys Set ('com 3230' 'com 3351') u In non-indexed collections we already have the value, hence the only question is whether it is in the collection. > S includes: 'black' false u The method includes: is defined for all collections. > #( 10 20 30 40 50 ) keys includes: 5 true COM 3230

67 Selecting Elements u The method select: returns a collection containing all the elements that satisfy some condition. u It receives a one-argument block that is evaluated for each element in the collection, returning true or false. u The returned collection is of the same class as the receiver in case it is Set, List, and Array otherwise. > #( 1 2 3 4 5 ) select: [ : i | ( i rem: 2 ) = 0 ] Array ( 2 4 ) u The method reject: returns the complementary collection. > #( 1 2 3 4 5 ) as. Set reject: [ : i | ( i rem: 2 ) = 0 ] Set ( 1 3 5 ) u Strings are special: > '1234567890' select: [ : c | c > $5 ] Array ( $6 $7 $8 $9 ) COM 3230

68 Performing Computations u The method do: allows a computation to be performed on every element in a collection. u It also receives a one-argument block. > B <- [ : x | ( x rem: 2 ) = 0 if. True: [ ( x print. String , ' is even!' ) print ] if. False: [ ( x print. String , ' is odd!' ) print ] ] Block > #(1 2 3 4 5) do: B 1 is odd! 2 is even! 3 is odd! 4 is even! 5 is odd! Array ( 1 2 3 4 5 ) COM 3230

69 Collecting Results The method collect: is similar to do: , but it produces a new collection containing the results of the block evaluation for each element of the receiver collection. > #( 1 2 3 4 5 ) collect: [ : i | i factorial ] Array ( 1 2 6 24 120 ) > #( 1 2 3 4 5 ) collect: [ : j | j rem: 2 ] Array ( 1 0 1 ) > D <- Dictionary new at: 0 put: 'even'; at: 1 put: 'odd' Dictionary ( 'even' 'odd' ) > #( 1 2 3 4 5 ) collect: [ : x | D at: ( x rem: 2 ) ] Array ( 'odd' 'even' 'odd' ) > factor <- 1. 1 > grades <- #(70 55 60 42) collect: [ : g | g * factor ] Array ( 77 60. 5 66 46. 2 ) COM 3230

70 Accumulative Processing u The method inject: into: is useful for processing all the values of a collection and returning a single result. u The first argument is the initial value, and the second is a twoparameter block that performs some computation. u At each iteration the block receives the result of the previous computation and the next value in the collection. > A <- #(1 2 3 4 5) Array ( 1 2 3 4 5 ) > ( A inject: 0 into: [: a : b| a + b ] ) / A size 3 “average of the values in the array” > A inject: 0 into: [: x : y| x > y if. True: [x] if. False: [y]] 5 “maximum value in the array” > A inject: 0 into: [: i : j| ( j rem: 2 ) = 0 if. True: [ i + 1 ] if. False: [ i ] ] 2 “number of even values in the array” COM 3230

71 Implementation Examples u Collection inject: into: inject: a. Value into: a. Block | last <- a. Value. self do: [: x | last <- a. Block value: last value: x ]. ^last u Collection size ^self inject: 0 into: [ : x : y | x + 1 ] u Collection occurrences. Of: an. Object ^self inject: 0 into: [ : x : y | ( y = an. Object ) if. True: [ x + 1 ] if. False: [ x ] ] COM 3230

Roman Numbers 72 Class Roman Object dict Methods Roman 'all' new dict <- Dictionary new at: 1 put: 'I'; at: 4 put: 'IV'; at: 5 put: 'V'; at: 9 put: 'IX'; at: 10 put: 'X'; at: 40 put: 'XL'; at: 50 put: 'L'; at: 90 put: 'XC'; at: 100 put: 'C'; at: 400 put: 'CD'; at: 500 put: 'D'; at: 900 put: 'CM'; at: 1000 put: 'M' | generate: an. Integer | count roman | count <- an. Integer. roman <- ''. ( dict keys select: [ : k | k <= count ] ) sort reverse. Do: [ : key | ( count quo: key ) times. Repeat: [ roman <- roman , ( dict at: key ) ]. count <- count rem: key ]. ^roman ] COM 3230

The Class Stack 73 Class Stack Object list Methods Stack new list <- List new | push: an. Object list add. First: an. Object | pop | top <- list first. list remove. First. ^top | A Stack is composed size ^list size by a List. | do: a. Block list do: a. Block ] COM 3230