CSP1150

Programming Principles
Lecture 1: Introduction to Programming
This Lecture

• Establishing a context
– Approach to the unit
– What is programming?
– Program implementation and source code

• Program design
– Pseudocode and flowcharts

• A brief history of programming languages

• Getting started
– Introduction to Python
– A simple program
– Variables, comments and concatenation
Textbook

• Starting Out with Python, 3rd Edition

– Tony Gaddis

• Reading the chapter(s) is required

– Read the indicated chapter(s) before class

• This week covers the following textbook chapter(s):

– Chapter 1 – Introduction to Computers and Programming
• Entire chapter
– Chapter 2 – Input, Processing, and Output
• Entire chapter
– Appendix A and B
Establishing a Context
Approach to the Unit

• This unit aims to teach you introductory programming

– It does not aim to teach you “programming in Python”

• The language you happen to use when learning to program

is not the focus or goal, it is simply the tool you are using
– When you learn to drive, you learn to drive a car – not a dark
red 1997 Ford Festiva Trio

• We will focus on the core concepts of programming

– What they entail
– Why they are necessary, important or desirable
– How (and why) their implementations differ between languages
– Most of the examples, and your lab work, will just happen to
use the Python programming language
Approach to the Unit

• While Python is the programming language we focus on,

this unit will discuss and demonstrate other languages
– This is to keep you focused upon the concepts being covered,
rather than their specific implementation in Python

• Code samples written in Python will look like this:

# print "Hello world!" to the screen Python
print('Hello world!')

• Code samples written in other languages will look like this:

// print "Hello world!" to the screen Java
class HelloWorld
{
public static void main(String[] args)
{
System.out.println("Hello world!");
}
}
What is Programming?

• Let us first consider “What is a computer?”

• A computer is a device with a few basic components:

– A processor (CPU) which can execute basic instructions
– Memory to store data and instructions that are in use
– Storage for ongoing retention of data and programs
– Input and output devices to communicate/interact with users

• Computers exist to be useful; To do things for us

– e.g. Automation of a manual process, or making something
possible that would otherwise be impossible or unfeasible
– Computers need to be told exactly how to do things
– This must be written in a way that a computer can understand
i.e. they must follow a pre-defined set of rules
Operating Systems

• Operating systems such as Windows, Mac OS or Linux sit

between the hardware and the programs on a computer

• Operating Systems are responsible for:

– Interfacing with the hardware of a computer and making it
available for programs to interact with
– Managing the storage and organisation of data and programs
– Allocating and scheduling the usage of the computer’s
processor, memory, etc, so that everything can run smoothly
– Managing users and security

• This provides a layer of abstraction, so that programs can

interact with hardware and resources in a consistent way
– Hence programming languages / programmers do not need to
implement things “from the ground up” every time
What is Programming?

• So, what is programming? Programming is problem solving

– Programs are written in order to fulfil a need / solve a problem
– A programming language is the tool used to create a solution

By writing a program using a programming language,

you can make a computer do something useful
Why Learn Programming?

• Learning to program is about developing cognitive

processes - i.e. ways of thinking - not memorising syntax
– Programming teaches you to think about a problem and
design a solution that adheres to an established set of rules

– Programming teaches you to think in a precise and

methodical manner when approaching a problem

– Programming teaches you to think of solutions that are

appropriate, elegant, modular and well-structured

Programming teaches you to think

Program Implementation

• A computer’s processor can only understand a set of very

basic instructions, such as simple arithmetic operations
– This is known as machine code, and it is not feasible to write
long or complex code directly in machine code
B801000000 Machine Code
BF02000000
01F8

• To make this easier, assembly language was developed

– Assembly language replaces the numeric instruction codes of
machine code with short descriptive words, e.g. “add”
– Each instruction corresponds to a machine code instruction,
so it is still very low level and unfeasible for complex code
mov eax, 0x1 Assembly
mov edi, 0x2
add eax, edi
Program Implementation

• In order to write complex programs in a way that is easy to

read and write as well as being processor-independent, we
use high-level languages
– These are the programming languages you hear about / use:
Python, C, Java, PHP, C++, JavaScript, etc
– Instructions in high-level languages are “statements”, and
usually translate to multiple machine code instructions
– These languages are much easier for people to write code in,
as well as reading and editing that code at a later stage

• The code of a program written in a high-level language is

known as the “source code” of the program
– The computer’s processor still only understands machine
code; the source code must be translated into machine code
Program Implementation

• There are two main approaches for translating high-level

source code into machine code:
– Compilation: The entirety of the source code is translated
into machine code and an executable file of it is produced
• This is a relatively slow process, however the resulting file runs
quickly as it is not being translated on the spot, and the compiler
can spend time to further optimise the resulting file
• Some compiled languages include C and C++

– Interpretation: An interpreter translates and executes each

source code statement one at a time as the program is run
• Slower to run as it is “doing it live”, but fewer steps involved
• Some interpreted languages include Python, PHP and JavaScript

• Some languages, e.g. Java & .NET languages, use a hybrid

method – compiling to “bytecode” and interpreting that
Source Code

• A program’s source code consists of a list of statements

written in a programming language

• Every statement must adhere to the syntax of the language

– The “words” that the language recognises
– The “phrasing” required to specify values
– The ways of arranging these into valid “sentences”

• Any errors in your syntax will prevent the code from running
prunt('Hello world!') Python

Traceback (most recent call last):

File "C:\Python\Scripts\test.py", line 1, in <module> Error location
prunt('Hello world!') Erroneous statement
NameError: name 'prunt' is not defined Type of error
– Do not fear error messages; read them and learn from them
Source Code

• When program is run, it runs the statements in the source

code from start to end (unless it encounters an error)
– Some statements choose between different sections of code
to run based upon the result of a conditional check (Selection)
– Some statements repeatedly run a section of code until a
certain condition is met (Iteration)
– Some statements request input from users or data from other
sources, often processing it using selection and iteration
– Some statements define sections of code to be used at other
points in the program where it is needed (Functions)

• Many programs are “event-driven”, meaning that they wait

for events to occur (e.g. the user clicking on something)
– When an event occurs, it triggers some statements to be run
Walking Exercise

• Goal: To navigate from one end of the room to the other

– As an English-speaking human, this can be achieved simply
by telling the person “Go over there”… Easy!

• We will be instructing a robot (played by a volunteer), who

can only understand the following statements:
– FORWARD( num )
• Walk forward num steps (assume 1 metre steps)

– TURN( LEFT | RIGHT )

• Turn 90 degrees left or right

• The robot must be given all of their statements in advance

– Bonus points for walking like a robot or making robot noises
Walking Exercise

• RoboTest.robo
FORWARD(1) Robo
TURN(LEFT)
FORWARD(1)
TURN(LEFT)
FORWARD(1)
TURN(LEFT)
FORWARD(1)
TURN(LEFT)

• EndOfRoom.robo
Robo
Program Design
Program Design

• Writing syntactically correct code is difficult and can distract

you from the problem that you are trying to solve
– Hence it is useful to be able to plan out the logic and structure
of your solution prior to commencing the actual programming
– This is the concept of program design

• Pseudocode and flowcharts are two ways of representing

the steps and statements that a program will implement

• Pseudocode and flowcharts…

– are valuable design tools that experienced programmers use
– are designed to be read by people, not parsed by a computer
– follow conventions of programming, e.g. selection & iteration
– often omit minor, insignificant and assumed statements
Program Design

• Pseudocode does not have defined standards, rules or

syntax that need to be adhered to
– There is no single “correct” way to write pseudocode
– To emphasise this, different conventions have been used in
each of the following pseudocode examples

• Flowcharts are a more visual approach to program design,

using symbols with specific meanings associated with them
– They are “stricter” than pseudocode, but this is a necessity in
order to produce flowcharts that anyone can read

• Always remember that the goal of these design tools is to

illustrate and communicate your design in a clear way
Flowchart Symbols

• This table summarises the main symbols used in flowcharts

– Note that flowcharts are used to illustrate algorithms to solve
problems in many fields, not just programming – very useful!

Symbol Meaning

Flow Line (indicates direction and connection between things)

Processing (indicates a basic operation, step or action)

Terminator (indicates start or end of a flowchart)

Input/Output (indicates input or output)

Decision (indicates a choice with true/false outcomes)

Predefined Process/Function (indicates a group of statements

that perform a task – may be detailed in separate flowchart)
 Pseudocode and Flowchart Examples

• Let’s look at some examples of pseudocode, flowcharts,

and corresponding source code
Get value

Prompt the user for a value Pseudocode

Multiply the value by 2 Result = value * 2
Show the value on the screen

Display result

value = input('Enter a value: ') Python

result = int(value) * 2
print(result)
 Pseudocode and Flowchart Examples
IF length of name > 15 THEN Pseudocode
PRINT name length error message
ELSE
PRINT name saved message

Name
length >
15?

True False

Display name Display name

length error saved message

if (name.length() > 15) Java

{
System.out.println("Error: Name too long.");
}
else
{
System.out.println("Your name has been saved.");
}
Pseudocode and Flowchart Examples
Get user details from Pseudocode
database
get user details from database

while (rows remaining in result set)

{
Row
get next row of data
remaining?
print name from row
}
True False
Get next row of
results

Display name
PHP
from row
$results = $db->query("SELECT * FROM users");

while ($row = $results->fetch_assoc())

{
echo $row['first_name'];
}
Software Engineering & Program Design

• Software Engineering describes the process of designing,

developing, testing and maintaining a piece of software
– Numerous different approaches to this are possible
– There are numerous other tools and techniques that are
involved in the design (and development) of software
• Some are only relevant in certain types/scales of software

• Some design tools and techniques in this process include…

– Program specifications (documenting the scope/functionality)
– User interface design (mock-ups of visual elements)
– Software architecture design (high-level logistics of software)

You should know exactly what you are building, and how,
before you start writing any code
Writing Good Code…

xkcd.com
 A Brief History of
Programming Languages
Early High-Level Languages

• Fortran is generally credited as the first high-level language

– Originally released in 1957, with subsequent versions
released since then (it’s still being released and used)
– Introduced many of the core concepts and conventions of
programming that we now take for granted
– Designed for scientific applications

• In the 1960s, computers were beginning to see significant

usage in business, which had different needs than science
– COBOL was a language designed to meet these needs,
aiming for accessibility and English-like syntax
– While not much COBOL is being written these days, many
businesses are still running COBOL code in various systems
Programming Languages, 1960s – 1980s

• Many other significant languages released over the years:

– BASIC (1963) emerged as a teaching language, and lives on
as Visual Basic .NET these days
– PL/I (1964) tried to take the best aspects of all languages and
invented some new ones in an attempt to be able to do it all
– Pascal (1971) also designed for teaching, led to Turbo Pascal
– C (1972) was designed for systems programming (e.g. OSs)
was very expressive and powerful – also packaged in UNIX
– Ada (1974) developed for US DoD to standardise the software
used in embedded systems. Introduced some new concepts
– Smalltalk-80 (1980) was first fully Object Oriented language,
expanding on features that appeared in SIMULA and Ada
– C++ (1983) evolved from C, incorporating OO from Smalltalk
Programming Languages, 1990s and Beyond

• Some of the more modern languages include…

– Python (1991), general purpose language emphasising
readability and expressiveness. Supports OO and other styles
– Java (1995), OO, designed to be platform independent
– PHP (1995), designed for web development (server-side)
– JavaScript (1995), designed for web development (client-side)
– .NET (2002) is a framework allowing for interoperability
between many different languages (C#, VB.NET, ASP.NET…)

• And more (including some popular and/or significant ones)!

– This isn’t a topic worth examining in further detail at this point
Programming Language Design Focus

• In the 1950s and 1960s languages focused upon writability

– How easy and effective it is to write code in the language
– Why? Few people writing code, not much reuse or
maintenance, time-consuming and costly to write and run

• By the 1970s, languages started emphasising readability

– How easy it is to read code in the language
– Why? More people (not just scientists) coding, larger and
more complex code in use, lots of maintenance and updating

• Striking a balance between these is important in a language

– Other factors include reliability (particularly for mission critical
code) and cost (influenced by all other factors – time and
effort needed to learn, train, write, read, maintain, etc.)