# CMPUT 174 - Module 0 - Slides to present

```What is &quot;Computational Problem Solving&quot;?
1
Computational Problem Solving vs Programming
● Computational problem solving comes before Programming
● Computational problem solving is about finding an abstract,
computational solution for a problem or a task, e.g.:
○
○
○
finding the shortest route on a map between two locations
analyzing a sales data set and presenting the results on a screen
implementing a new game that you invented
● Programming is about taking a computational solution and describing
it in a particular programming language.
● Think of Computational Problem Solving activities as a Design Phase
that must come before the Programming Phase
2
Key Activities / Skills:
● Problem Decomposition
○ Break a bigger problem into smaller subproblems or subtasks that
are easier to understand, solve, implement, test, and maintain - or
● Abstraction &amp; Modeling
that the information can be stored and manipulated by a
computer.
● Algorithm Design
○ Find a sequence of well defined computational steps that, when
executed, achieve the solution/goal
3
A Simple Example
●
Turn-based strategy game
○
○
○
○
●
Player can move each turn on a playing field
Player has a circular field of vision
(how far a player can see may change during the game)
Player can only interact with game elements in its field of vision
…
Before implementing anything, you must
○
Problem Decomposition
Determine the &quot;things&quot; and their desired behaviour in the game
○
Abstraction &amp; Modeling
Decide how to represent the things that occur in the game
○
Algorithm Design
Determine computational steps needed to achieve the desired game behaviour
4
A Simple Example (continued)
●
Part of your decomposition effort determines
○ a playing field
○ a player character
○ items that the player can interact with
●
What should a representation of a player and items include, so that you can
compute whether or not an item is within the player's field of vision?
○
●
Assume that your playing field representation includes some kind of 2-dimensional
coordinate system.
Given you representation of player and items, what is an algorithm to
actually compute whether or not an item is within the player's field of vision?
5
y
A Simple Example (continued)
●
Representation
○
(xp, yp) coordinate for the (centre) position
radius r for the size of the field of vision
…
Items:
■
■
●
yp
yi
Player:
■
■
■
○
r
Xp
x
Xi
(xi, yi) coordinate for the (centre) position
…
Algorithm
○
○
For each item in the game: Compute the Euclidean distance d between player
centre and the item centre: d = √(xi - xp)2 + (yi - yp)2
If the distance is smaller than the radius r, then the item is within the player's
field of vision, otherwise it is not.
6
What is Programming?
7
Simplified Computer Architecture
CPU - Central Processing Unit
Main Memory
Sequence of &quot;cells&quot;
Input
Input: sequence
of bytes, e.g.,
generated by a
keyboard
Output
Output:
sequence of
bytes, e.g., sent
to a monitor
1
10110101
2
00100101
3
00010100
4
11110100
5
...
Typical cell size:
1 byte = 8 bits
Its unique number
in the sequence of cells
8
Simplified ComputerCUArchitecture
decodes
CPU - Central Processing Unit
CU - Control Unit
ALU - Arithmetic
Logic Unit
ALU performs basic
arithmetic and
logical operations
on binary data
Input
Input: sequence
of bytes, e.g.,
generated by a
keyboard
PC - Program Counter
PC &quot;points&quot; to the
next instruction to
be executed
Output
Output:
sequence of
bytes, e.g., sent
to a monitor
instruction and
Main Memory
controls other
parts of the
Program Code
CPU
Main Memory
Sequence of &quot;cells&quot;
1
10110101
2
00100101
3
00010100
Other reserved areas
4
11110100
----------------------------
5
...
Instruction 1
Instruction 2
Instruction 3
...
----------------------------
Free memory (Heap)
Typical cell size:
1 byte = 8 bits
Its unique number
in the sequence of cells
9
How computers &quot;run&quot;
● Simplified instruction cycle:
CPU
ALU
fetch instruction pointed to by PC
increment PC to the next instruction
Main Memory
CU
Instruction 1
Instruction 2
Instruction 3
...
PC
Input
Program Code
Output
decode &amp; execute instruction
● Instructions are: very basic, low-level, and hardware specific
● All complex tasks are composed of basic instructions
10
Programming a Computer
● Program = &quot;Description of computations, written in a way that
a computer can execute them&quot;
● Difficult to write complex programs in low-level languages!
● Programs are typically written using &quot;higher level&quot; languages
○ human readable and easier to understand
○ hardware independent ways of expressing common tasks
● Programs written in high-level languages are translated into
instructions at the lowest level before they can be executed
11
Translation of High Level Programs...
● ...depends on the programming language
● Compiler (e.g., C, C++, Pascal)
○ compile = translate a source code program completely into
&quot;Object Code&quot;, which can then be executed
● Interpreter (e.g., Perl, Python, Java)
○ interpret = translate and immediately execute source code,
statement by statement, in the written order
○ often allow an interactive mode: &quot;interactive shell&quot; accepts and
executes a statement and then waits for the next statement
12
How computers &quot;run&quot;
Conceptual
Control flow
1
6
● Simplified instruction cycle:
fetch instruction pointed to by PC
increment PC to the next instruction
decode &amp; execute instruction
Main Memory
...
Instruction i: code for call of a function f
Instruction i + 1
Instruction i + 2
...
2
3
4
5
Instruction 1 of function f code
Instruction 2 of function f code
Instruction 3 of function f code
Last instruction of function f code
...
● Instructions are: very basic, low-level, and hardware specific
● All complex tasks are composed of basic instructions
● some instructions change the PC to a different location
○
e.g., to where the code for a called function is stored in memory
13
Writing &amp; Running Python Programs
14
What is a (Python) Program?
● A sequence of statements in the Python programming
language that describe how to compute something.
● Python language has many different statement types for
○ creating data objects
○ giving data object names
(so that you can easily to refer to an object by name in later statements)
○ create new objects as the result of certain computations
(by applying operators, calling functions, etc)
○ executing statements only conditionally, or repeatedly, ...
○ ...
15
Writing &amp; Running Python Programs
1.
2.
Write a program in a &quot;plain text&quot; editor &amp; save it
&quot;Running&quot; the Python program
= have the Python Interpreter evaluate it statement by statement
Can be done in several ways
○ Editor + Call the Python interpreter in a system shell
○ Use an IDE (Integrated Development Environment) that combines in one
interface/application
- a plain text editor (with Python syntax coloring)
- a debugger (plus possibly other tools)
- an interactive shell
- a shortcut to execute the file currently in the editor window
16
Demonstration of Editor, Command Line, and IDE
17
How does Python &quot;Interpret&quot; a Program
● Lexical Analysis (Tokenization)
○ parses the program file and identifies the &quot;tokens&quot; in the
sequence of characters
● Syntax Analysis (check for &quot;grammatical&quot; mistakes)
○ checks if statements are well-formed, given the identified tokens
● Semantics (the meaning of a program)
○ a program describes a computation; that computation
(as interpreted/executed by Python) is its meaning
18
Creating Objects:
Simple Expressions &amp; Statements
19
Representing &quot;things&quot; in Python
● Different Kinds of Objects
○ Object Type
○ Object Identity
○ Object Value
20
Creating objects in Python: Literals
● int literals
○ e.g.: 0, 1, 45, -17
● float literals
○ e.g.: 0.0, 3.0, 0.578, -0.489, -1000.0
● string literals
○ e.g.: &quot;Hello World&quot;, 'Barney', &quot;123&quot;, &quot;4.56&quot;
21
Creating objects in Python: Expressions
● &quot;Atomic&quot; expressions are expressions.
○ These include literals and other things we will encounter in this
course such as identifiers and list displays.
● Enclosing an expression in parenthesis is an expression.
● The &quot;application&quot; of an operator to expressions is an
expression.
○ e.g.: 4 + 5, 3.45 * 7, age + 1
● There are many other kinds of expressions, including function
calls
● Executing\evaluating an expression results always in an object
22
Describing Computations in Python: Statements
● Simple statements fit in a single line
(as opposed to compound statements that we will encounter
later in this course, which require multiple lines to formulate)
● Expressions by themselves are simple statements,
so-called &quot;expression statements&quot;
■
useful only in interactive mode, unless they have a so-called
&quot;side-effect&quot; such as printing something to the screen.
● The assignment statement is a simple statement that allows
you to give names to objects.
23
Naming Objects:
The Assignment Statement
24
age | 140728674067120
Naming Objects
Objects stored in
memory:
...
140728674067120
00001010
140728674067121
00001011
140728674067122
00001100
140728674067123
...
● The assignment statement with an identifier &quot;target&quot;
&lt;identifier&gt; = &lt;expression that evaluates to an object&gt;
e.g.: age = 10
Namespace
● Namespace vs Objectspace
○
Objects are created by Python in Main Memory
■
○
age
10
int
Think of them as &quot;living&quot; in an &quot;objectspace&quot;
Python also keeps track of the identifiers
and their association with objects
■
...
Objectspace
this information is called the &quot;namespace&quot;
&quot;State Diagram&quot;
age
...
10
25
Describing simple computations in Python - Examples
26
Practice
Q1 Trace through the following program and write the value of the identifiers as they change.
Example 1
first = 2
second = 3
third = first * second
second = third - first
first = first + second + third
third = second * first
Example 2
x = 10
x = x + x
x = x - 5
Q2 Write a program that swaps the values of two identifiers.
Q3 Write a program to print the id, type and value of an object.
27
```