IT 240 Programming Paradigms

MS Information Technology Ateneo de Davao

Course Outline

 Programming Language Concepts  Survey of Languages and Paradigms  Imperative, Functional, Object-Oriented  Focus: OO Programming  OO Languages (Java and C++)  OO Design (UML)  Design Patterns

Prerequisites and Context

 IT 240: One of the six required (core) courses in the MS IT curriculum  Assumes sufficient exposure (at least two semesters) to programming  preferably in the C Language  undergraduate courses in data structures and/or programming languages will be helpful

References

 Programming Language Concepts Ghezzi and Jazayeri , by  Concepts of Programming Languages, Sebesta  The C++ Programming Language Stroustrup , by by

Course Requirements

 Midterm Exam  Final Exam  Exercises/Projects  Individual Report 25% 25% 30% 20%

Schedule

 Session 1: Overview, Imperative Prog (November)  Session 2: Functional Prog (December)  Midterm  Session 3: OO Programming (January)  Session 4: More OOP, Reports (February)  Final Exam

Schedule This Weekend

 Friday Afternoon  Overview, Classification of Languages  Saturday Morning  Evolution from Imperative/Structured Programming to OO Programming  Saturday Afternoon  Syntax and Semantics, Language Translation  Concepts in Imperative Programming

Revised Schedule This Weekend

 Saturday Afternoon Session 1:  Overview, Classification of Languages  Evolution from Imperative/Structured Programming to OO Programming  Saturday Afternoon/Evening Session 2:  Syntax and Semantics, Language Translation  Concepts in Imperative Programming  Sunday Morning session  Imperative Programming, continued  Introduction to Java (time permitting)

Session Format

 Lecture  discussion of formal definitions, concepts and cases  Lab  implementation of examples discussed  exercises to be submitted

Objective: gain working knowledge of the topics discussed

Course Material and Required Reading

 Visit course website regularly:  http://curry.ateneo.net/~jpv/courses.html

will link to a page containing IT 240 material  Read:  Stroustrup book: section on Programming Paradigms (sec. 1.2, pp. 14-22)

Overview of Programming Paradigms

IT 240

Definitions

 Programming Paradigm  programming “technique” (?)  way of thinking about programming  view of a program  Programming Language  consists of words, symbols, and rules for writing a program

Programming Paradigms

 Imperative Programming  program as a collection of statements and procedures affecting data (variables)  Object-Oriented Programming  program as a collection of classes for interacting objects  Functional Programming  program as a collection of (math) functions  Others

Some Languages by Paradigm

 Imperative (also called Structured or Procedural) Programming  FORTRAN, BASIC, COBOL, Pascal, C  Object-Oriented Programming  SmallTalk, C++, Java  Functional Programming  LISP, ML, Haskell

History of Languages

 1950s to 1960s  FORTRAN, COBOL, LISP, BASIC  1960s to 1970s  (ALGOL-based) Pascal and others  1970s to 1980s  Prolog, C, Ada  1980s to 1990s  C++, ML, Perl, Java

Paradigm Change

 For example, from Structured to Object Oriented  Arises from problems encountered in one paradigm but addressed in another  Case study: from C to C++  Evolution from structured, to modular, to object-based, to object-oriented programming  Stroustrup book section 1.2

Case Study: Stacks

 Stack  last-in, first-out structure  operations: push, pop  Sample uses ?

 Stacks are used to support some solution  push and pop are defined and implemented as functions  the solution consists of code that invoke these functions

Implementing a Stack

 Stack can be implemented as an array  array contains pushed elements  an integer refers to top of the stack  most common implementation  Or as a linked list  using pointers and dynamic allocation  Other implementations

Array Implementation in C

char Store[MAX]; int top = 0; void push(char x) { if (top < MAX) Store[top++] = x; else printf(“full\n”); } char pop() { if (top > 0) return Store[--top]; else printf(“empty\n”); } ...

Using the Stack

void application() { … push(‘x’); … result = pop(); … }

Procedural Programming

 Focus is on writing good functions and procedures  use the most appropriate implementation and employ correct efficient algorithms  Stack example (assume array implementation)  one source file  Store and top are global variables  stack and application functions defined at the same level (file)

Problems

 Application can alter implementation details  can directly manipulate top and Store from application()  integrity of stack not ensured  Stack code and application code are not separated

Encapsulation and Modular Programming

 Focus is on writing good modules  hide implementation details from user  provide an interface  Stack example  stack.h contains prototypes for push, pop  stack.c contains stack code, Store and top declared static (local to stack.c)  application includes stack.h

Benefits from Modules

 Application cannot destroy the integrity of the stack  Stack implementation can change without affecting application source  Question: what happens if we need more than one stack?

Multiple Stacks

 Strategy 1 (use structs)  in stack.h, define a stack structure that contains Store and top; push, pop now have an extra parameter that specifies which stack  application code defines stack variables  Strategy 2 (use handles)  implement multiple data structures in stack.c

 use an integer (the handle) to specify “stack number”

Modules and Multiple Stacks

 Disadvantage of strategy 1:  implementation (data) is exposed  back to original problem on stack integrity  Disadvantage of strategy 2:  stack module will be unnecessarily complex  handle is artificial (what if an arbitrary integer is passed?)

Abstract Data Types and Object-based Programming

 Focus is on writing good classes (or types) that define operations on objects of the class  class defined like a module (encapsulation enforced) but multiple instances now possible  user-defined type  Stack example (C++)  stack.h and stack.cpp define a stack class

Object-Oriented Programming

 Incorporates both encapsulation and inheritance through the class concept  Focus is on writing good classes and on code reuse  Examples  Shape, Circle, and Rectangle in a drawing program  Employee, Faculty, Staff in a university personnel system

Lab Exercises (Set 1)

 Modular Programming  create a stack module  Multiple stacks 

create a multiple-stack module using structs

 create a multiple-stack module using handles  Object-based Programming  create a stack class in C++

Syntax and Semantics

IT 240

Outline

 Language Definition  syntactic vs semantic rules  Translation & Language Processing  Compilation  stages  handout

Language Definition

 Syntax  set of rules that define form  BNF Grammar or syntax diagram  Semantics  specify meaning of well-formed programs  formal semantics: pre- and post- conditions

Specifying Syntax

 Lexical Rules  rules for determining tokens  tokens: syntactic units (e.g., number, identifier, semicolon, equals)  Syntactic Rules  Grammar: set of productions  productions: terminals (tokens) and nonterminals

Semantics

 Given a language construct  what is required for that (well-formed) construct to execute?

 what happens upon execution?

 Example: assignment statement  tokens present? syntax? semantics?

Language Translation

 Interpreters  processes instructions on the fly  Compilers  produces object code for execution  Intermediate code  e.g., pcode or the Java Virtual Machine

Compilation Stages

 Lexical Analysis  Parsing (Syntax Analysis)  Code Generation  Code Optimization * Symbol Table Management

Handout

 For the sample program, simulate compilation and describe effect for each compilation stage  Lab exercise (Set 2) 

Simple exercise on Lexical Analysis, Parsing, and Symbol table management

 Parser for variable declarations (C & Pascal)  Output: list of variables per data type

Imperative Programming

IT 240

Imperative Programming

 Variables, assignment, sequencing, iteration, procedures as units  State-based, assignment-oriented  Global variables, side effects  Program units: Data (Variables) and Computation (Statements and Routines)

Data and Computation

 Binding  Data  Variables  Data types  Computation  Assignments and expressions  Control structures  Subprograms / routines

Binding

 Program units/entities have attributes  e.g., a variable has a name, a statement has associated actions  Binding  setting the value of an attribute  Binding time  when binding occurs

Binding Time

 Language definition time  Language implementation time  Compile-time  Execution-time Examples?

Variable

 A named location in memory that can hold a value  Formally, a 5-tuple:  name  scope  type  l-value  r-value

Name and Scope

 Declaration  Identifier rules and significant characters  Scope  range of instructions over which variable name is known  namespaces  Blocks (as in Pascal or C)  Static vs dynamic scope binding

Type

 Consists of  Set of values  Operations  Built-in/Primitive vs User-defined types  binding?

 Implicit declarations  e.g., FORTRAN and first letter of a variable and first assignment in BASIC or Foxpro  Dynamic typing

Why Use Data Types?

 Purpose: classification and protection  note that all data are ultimately represented as bit-strings  Advantages:  abstraction  compile-time checking and resolution  explicit specification

Complex Data Types

 User-defined enumeration types  Composite types  Aggregations  cartesian product (records or structures)  mapping (arrays)  unions

L-value and r-value

 l-value: address/location  lifetime  memory allocation  r-value: contents/encoded value  initialization  constants * binding

Pointers

 Attributes  Allocation and de-allocation  Operators  referencing (address-of)  de-referencing  Unnamed Variables  e.g., Pascal

Control: Statements and Routines

 Expressions and statements  Conditional execution  Iteration  Routines  Parameter Passing  Modules and Program Structure

Expressions and Statements

 Operands: variables, literals  Operators  Unary, binary, and others (functions?)  Value returned vs effect  Precedence  Statements  The semicolon: C (terminator) vs Pascal (separator)  Blocks: C { } vs Pascal (begin-end)  Control structures: decision, iteration, routines

Conditional Execution

 Conditions and boolean values  Relationship of conditions and int in C  Not adopted in Java  Short-cutting  If-statements and dangling else  The switch statement  Restrictions  The break; statement

Iteration

 For statement  Loop control variable  The while loop  while vs do-while  do-while versus repeat-until  Iteration using goto

Routines

 Program unit; sequence of instructions  Also a 5-tuple:  name  scope  type  l-value  r-value

About Routines

 Functions vs procedures (methods?)  Parameter Passing  By value  By reference  Others?

 Activation Records  Recursion

Modules and Program Structure

 Programming in the Large  need to compose program through units  Modules  program units that interact with each another  Encapsulation  information hiding  independent modules with interfaces

Modularity

 Interface and Implementation  Compilation  Independent  Separate  Libraries