Chapter 9: High Level Language

Transcription

1 Elements of Computing Systems, Nisan & Schocken, MIT Press, Chapter 9: High Level Language Usage and Copyright Notice: Copyright 2005 Noam Nisan and Shimon Schocken This presentation contains lecture materials that accompany the textbook The Elements of Computing Systems by Noam Nisan & Shimon Schocken, MIT Press, The book web site, features 13 such presentations, one for each book chapter. Each presentation is designed to support about 3 hours of classroom or self-study instruction. You are welcome to use or edit this presentation for instructional and non-commercial purposes. If you use our materials, we will appreciate it if you will include in them a reference to the book s web site. And, if you have any comments, you can reach us at tecs.ta@gmail.com Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 1

2 Where we are at: Human Thought Abstract design Chapters 9, 12 abstract interface H.L. Language & Operating Sys. Compiler Chapters abstract interface Virtual Machine Software hierarchy VM Translator Chapters 7-8 abstract interface Assembly Language Assembler Chapter 6 abstract interface Machine Language Computer Architecture Chapters 4-5 Hardware hierarchy abstract interface Hardware Platform Gate Logic Chapters 1-3 abstract interface Chips & Logic Gates Electrical Engineering Physics Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 2

3 Brief history of programming languages (some milestones) Machine language Assembler: symbolic programming Fortran: formula translation Algol: structured programming, dynamic memory Pascal, C: industrial strength compilers C++: OO Java, C#: OO done well Other paradigms. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 3

4 The OO approach to programming Object = entity associated with properties (fields) and operations (methods) Objects are instances of classes E.g. bank account, employee, transaction, window, gamesession, OO programming: identifying, designing and implementing classes Each class is typically: A template for generating and manipulating objects and/or A collection of related subroutines. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 4

5 An OO programming language can be used for Procedural programming Abstract data types Concrete objects Abstract objects Graphical objects Software libraries And more. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 5

6 Jack: a typical OO language -- sample applications Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 6

7 Disclaimer Although Jack is a real programming language, we don t view it as an end Rather, we view Jack as a means through which we explain: How to build a compiler How the compiler and the language interface with an OS How the topmost piece in the software hierarchy fits into the picture Jack s most important virtue: it can be learned (and un-learned) it in 1 hour. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 7

8 Example 0: hello world /** /** Hello Hello World World program. program. */ */ class class Main Main { void void main() main() { /* /* Prints Prints some some text text using using the the standard standard library. library. */ */ do do Output.printString( Hello World ); World ); do do Output.println(); // // New New line line return; return; Java-like syntax Comments Standard library. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 8

9 Example 1: procedural programming class class Main Main { /* /* Sums Sums up up n */ */ int int sum(int sum(int n) n) { var var int int i, i, sum; sum; let let sum sum = 0; 0; let let i = 1; 1; while while (~(i>n)) (~(i>n)) { let let sum sum = sum sum + i; i; let let i = i + 1; 1; return return sum; sum; void void main() main() { var var int int n, n, x; x; let let n = Keyboard.readInt( Enter n: n: ); ); let let x = Main.sum(n); do do Output.printString("The result result is: is: "); "); do do Output.printInt(sum); do do Output.println(); return; return; // // Main Main Jack program = collection of one or more classes Jack class = collection of one or more subroutines Jack subroutine: Function Method Constructor (the example on the left has s only, as it is object-less ) There must be one Main class, and one of its methods must be main. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 9

10 Example 2: OO programming class class BankAccount { static static int int naccounts; // // account account properties field field int int id; id; field field String String owner; owner; field field int int balance; balance; /* /* Constructs a new new bank bank account. account. */ */ constructor BankAccount new(string aowner) aowner) { let let id id = naccounts; let let naccounts = naccounts + 1; 1; let let owner owner = aowner; aowner; let let balance balance = 0; 0; return return this; this; var // // More More BankAccount methods. var int int sum; sum; methods. var var BankAccount b, b, c; c; // // BankAccount let let b=bankaccount.new( Joe ); Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 10

11 Example 2: typical OO programming (cont.) class class BankAccount { static static int int naccounts; // // account account properties field field int int id; id; field field String String owner; owner; field field int int balance; balance; // // Constructor (omitted) /* /* Deposits Deposits money money in in this this account. account. */ */ method method void void deposit(int amount) amount) { let let balance balance = balance balance + amount; amount; return; return; /* /* Withdraws money money from from this this account. account. */ */ method method void void withdraw(int amount){ amount){ if if (balance (balance > amount) amount) { let let balance balance = balance balance - amount; amount; return; return; // // More More BankAccount methods. methods. // // BankAccount var var int int sum; sum; var var BankAccount b, b, c; c; let let b=bankaccount.new( Joe ); do do b.deposit(5000); let let c=bankaccount.new( jane ); let let sum sum = 1000; 1000; do do b.withdraw(sum); Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 11

12 Example 2: typical OO programming (cont.) class class BankAccount { static static int int naccounts; // // account account properties field field int int id; id; field field String String owner; owner; field field int int balance; balance; // // Constructor (omitted) /* /* Prints Prints information about about this this account. account. */ */ method method void void printinfo() { do do Output.printInt(ID); do do Output.printString(owner); do do Output.printInt(balance); return; return; /* /* Destroys Destroys this this account. account. */ */ method method void void dispose() { do do Memory.deAlloc(this); return; return; // // More More BankAccount methods. methods. // // BankAccount var var int int sum; sum; var var BankAccount b, b, c; c; // // Construct and and manipulate // // b and and c do do b.printinfo(); do do b.dispose(); Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 12

13 Example 3: abstract data types (API + usage) Motivation: Jack has only 3 primitive data type: int, char, boolean Fraction API Using the Fraction API (example) API = public contract Interface / implementation. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 13

14 Example 3: abstract data types (implementation) Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 14

15 Example 3: abstract data types (implementation cont.) Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 15

16 Example 4: linked list /** /** Provides Provides a linked linked list list abstraction. */ */ class class List List { field field int int data; data; field field List List next; next; /* /* Creates Creates a new new List List object. object. */ */ constructor List List new(int new(int car, car, List List cdr) cdr) { let let data data = car; car; let let next next = cdr; cdr; return return this; this; /* /* Disposes Disposes this this List List by by recursively disposing its its tail. tail. */ */ method method void void dispose() { if if (~(next (~(next = null)) null)) { do do next.dispose(); class do do Memory.deAlloc(this); class Foo Foo {... return;... return; // // Creates Creates a list list holding holding the the numbers numbers (2,3,5). (2,3,5).... void void create235() {... var // // class class List. var List List v; v; List. let let v = List.new(5,null); let let v = List.new(2,List.new(3,v)); Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 16

17 Jack language specification Syntax Data types Variable kinds Expressions Statements Subroutine calling Program structure Standard library (for complete coverage, see chapter 9 in the book). Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 17

18 Jack syntax Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 18

19 Jack syntax (cont.) Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 19

20 Jack data types Primitive: Int 16-bit 2 s complement (15, -2, 3,...) Boolean 0 and 1, standing for true and false Char unicode character ( a, x, +, %,...) Abstract data types (supplied by the OS or by the user): String Fraction List... Application-specific objects: BankAccount Bat / Ball... Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 20

21 Jack data types: memory allocation Object types are represented by a class name and implemented as a reference, i.e. a memory address Memory allocation: Primitive variables are allocated memory space when they are declared Object variables are allocated memory space when they are created via a constructor. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 21

22 Jack variable kinds and scope Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 22

23 Jack expressions No operator priority! Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 23

24 Jack Statements let letvariable = expression; or or let let variable variable [expression] = expression; if if (expression){ statements else else { statements while (expression){ statements do do -or-method-call; return expression; or or return; Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 24

25 Jack subroutine calls general syntax: subroutinename(arg1, arg2, ) Each argument is a valid Jack expression Parameter passing is by value Example: suppose we have int sqrt(int n) This can be invoked as follows: sqrt(17) sqrt(x) sqrt(a*c-17) sqrt(a*sqrt(c-17)+3) Etc. Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 25

26 Jack subroutine calls (cont.) Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 26

27 Jack program structure Each class in a separate file (compilation unit) Jack program = collection of classes, containing a Main.main() Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 27

28 Jack standard library = language extensions = OS class class Math Math { void void init() init() Class Class String String int int abs(int { abs(int x) x) constructor int int multiply(int String String new(int new(int x, x, int maxlength) int y) y) method Class method Class Array int void Array { int void divide(int dispose() x, x, int int y) y) method method int int int int min(int length() min(int Array Array length() x, x, new(int new(int y) y) size) method class size) method class int char Output int char Output max(int charat(int { max(int x, x, int y) j) y) j) method method method method int void int void void sqrt(int void setcharat(int dispose() void sqrt(int void movecursor(int x) j, x) j, char char c) i, c) i, int int j) j) method method String Class String Class Screen Screen appendchar(char void void printchar(char { c) c) c) c) method method void void eraselastchar() void void void void printstring(string clearscreen() s) s) method method int class int class Memory Memory intvalue() void void void void printint(int setcolor(boolean { i) b) i) b) method method void void setint(int void void void void println() drawpixel(int x, x, int int y) j) peek(int peek(int address) y) j) Class address) Class char char backspace() void void Keyboard void void Keyboard backspace() drawline(int { x1, x1, int int y1, y1, void void poke(int poke(int x2, address, x2, address, int int y2) y2) int int value) value) char char doublequote() char void void drawrectangle(int char keypressed() Class x1, x1, int int y1, y1, char char newline() Class Sys int Array Sys { Array alloc(int size) int size) x2, x2, int int y2) char char readchar() y2) void void drawcircle(int x, x, int int y, y, int int r) void r) void void dealloc(array void halt(): halt(): o) o) String String readline(string message) message) void void error(int errorcode) int int readint(string message) message) void void wait(int wait(int duration) Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 28

29 Perspective Jack is an object-based language: no inheritance Primitive type system Standard library Our hidden agenda: gearing up to understand how to develop a: Compiler (chapters 10-11) OS (chapter 12). Elements of Computing Systems, Nisan & Schocken, MIT Press, 2005, Chapter 9: High Level Language slide 29