COMP 1001: Introduction to Programming

Lecture 1 Workbook

Course Introduction, Computers and Software

Pranjal Patra
Department of Computer Science, Memorial University of Newfoundland

The Course

What the course is, who teaches it, when and where it meets, and what it covers.

Course description

COMP 1001 is an introduction to problem solving and programming in Python. It is the first programming course for all Computer Science majors and minors, and it is required for entry into both programs. The course introduces fundamental programming techniques, data types and data structures. Problem-solving techniques are learned and applied through the design and implementation of simple algorithms.

People and contact

Office hours: Fridays, 12:00 to 2:00 p.m., by appointment only. Book a slot at the Google Calendar link (also on Brightspace); please take the next available slot if possible.

Lectures and labs

Attend the lab section in which you are registered. The lab quizzes are written in the lab and are worth 30% of the course, so the lab is not optional.

Course topics

The schedule is tentative; any change is announced in class and posted on Brightspace. Each block assumes the material before it, so keeping up matters.

Marks and Dates

How the course grade is built, what happens when you miss a lab or a test, and the dates to put in your calendar now.

Evaluation

Lab quizzes and both term tests are written in Brightspace using the Quiz tool, on the lab computers. Both sections write on the same date, at their own section times.

Labs and lab quizzes

There are eight lab quizzes and the best six count. That already allows for two missed labs, for any reason, without notice or documentation.

Student Health Certificate form (PDF)

Term tests and the final

• Term Test 1 covers Lectures 1–12.
• Term Test 2 covers Lectures 1–23, weighted toward the later material.
• The final covers Lectures 1–36, weighted toward the later units.

Important dates

Policies and Help

The rules that apply to your work in this course, and where to go when you are stuck.

Course policies

The full course outline on Brightspace lists the remaining university regulations: grading scheme, scheduling, deferred final examinations, accommodations and student supports.

Where to get help

• Your lab instructor, during the lab. Lab instructors and instructional assistants are there to help.
• Office hours, Fridays 12:00 to 2:00 p.m. by appointment.
• CS Student Help Centre, EN-2026. It helps with first- and second-year Computer Science lab courses; its schedule is linked from Brightspace.
• Peer Assisted Learning (PAL), led by Arash Arasteh, aarasteh@mun.ca. A PAL leader visits the class on September 9 to introduce the program and to collect an availability survey; the session schedule is set from that survey and posted on Brightspace. See the Peer Assisted Learning page.
• Brightspace, for announcements, materials and posted answers to common questions.

Study advice

Hardware

The big picture starts at the bottom: what a computer is physically, and how it represents everything as switches.

What a computer is

Strip away the screen, the keyboard and the case, and a computer is a very large arrangement of switches made of silicon. Each switch is either on or off. Everything the machine does, from adding two numbers to drawing this page, comes from turning enormous numbers of those switches on and off very quickly.

That is a long way from the problems you actually care about. The rest of this lecture is about the layers that close the gap between silicon and the person using the machine.

From sand to chips

Silicon is a semiconductor: it can be made to conduct or not, depending on a tiny control signal. Sand is purified into a single crystal, sliced into thin wafers, and patterned with layers of material so fine that a modern chip carries tens of billions of switches in a piece smaller than a fingernail.

Transistors, gates and processors

A single switch is a transistor. A few transistors wired together make a logic gate that computes AND, OR or NOT of its inputs. Gates combine into circuits that add, compare and store values, and those circuits combine into a processor. At no point does anything new appear: it is switches all the way down.

Binary representation

A switch has two states, so the machine stores everything as patterns of 0s and 1s (bits). The pattern means nothing by itself; people agree on a convention for reading it.

the number 5      00000101
the letter 'A'    01000001      (that is 65, by agreement)
one red pixel     11111111 00000000 00000000

The same eight bits can be a small number, a letter, or part of a colour. What makes 01000001 mean 'A' is an agreed convention, not anything inside the chip. Keep that in mind: it is why a program has to tell Python whether a value is a number or text.

The von Neumann architecture

Almost every computer you will meet follows a design described by John von Neumann in 1945.

The CPU repeats one loop endlessly: fetch the next instruction from memory, decode what it asks for, execute it, and move on. The control unit runs the loop; the arithmetic unit does the calculating.

The Layers

A computer system is built as a stack of layers. Knowing the stack tells you where Python, and this course, sit.

Layers of a computer system

Between the physics of silicon and the application on your screen sit several layers. Each one hides the details of the layer below it and offers something simpler to the layer above.

This course lives in the top two layers: you will write applications, and you will use libraries (Python's modules) that other people wrote. The layers below are what make that possible.

Layers and courses

Each layer is a field of study in its own right. Later courses in the degree pick them up one by one.

The operating system

The operating system is the layer every program talks to. It shares the processor and memory among running programs, manages files, and talks to the keyboard, screen and network so that each program does not have to.

Whether you run Windows, macOS or Linux in the lab, Python sits on top of the operating system in exactly the same way. That is one reason a Python program written on one machine runs unchanged on another.

Languages

A processor understands only bits. Programming languages exist to let people write for the machine without thinking in bits.

Machine code

The processor understands only one language: patterns of bits called machine code. Here are three real instructions for a common processor, written in hexadecimal to save space, with what each one means.

48 83 C0 05      add 5 to a register
48 01 D8         add one register to another
C3               return

In binary the first instruction is 01001000 10000011 11000000 00000101. People wrote programs like this in the 1940s. It is exact, and it is unreadable.

Assembly

Assembly language gives each instruction a short name and lets you label positions in the program. An assembler translates it, one line to one instruction, into machine code.

add_five:
    add rax, 5        ; 48 83 C0 05
    add rax, rbx      ; 48 01 D8
    ret               ; C3

Better, but you are still thinking in terms of the processor's registers rather than your problem.

C and compilation

A language such as C lets you describe the calculation itself. A compiler translates the whole program into machine code once, ahead of time, and the result is a file the CPU can run directly.

int add_five(int x) {
    return x + 5;
}

The translation happens once. Running the program afterwards costs nothing extra, which is why compiled languages are used where speed matters most.

Python and interpretation

Python, the language of this course, takes a different route. Python code is translated into an intermediate form called bytecode, and a program called the Python virtual machine carries out that bytecode. The translation happens every time you run the program.

Translating on every run costs speed. What it buys is convenience: no separate compile step, the same code on every operating system, and the ability to try one line at a time and see what happens. For learning to solve problems, that is the right trade.

A short history

Each step in the history of programming languages hides a little more of the machine.

• 1945 Machine code
• 1949 Assembly
• 1957 Fortran, the first widely used high-level language
• 1959 COBOL
• 1972 C
• 1985 C++
• 1991 Python
• 1995 Java, JavaScript
• 2010s Go, Rust, Swift

Low-level and high-level languages

This course uses Python because its subject is problem solving, not the processor. Python lets you spend your attention on the problem.

Programming

Where a programmer fits in the picture, how big the field is, and what this course gives you.

Where programming fits

Programming is the point where a person's intention becomes something the machine can carry out. You describe what you want precisely enough that the layers below can do it, and what comes back is a result you can actually use.

The software industry

A few rounded, mid-2020s figures give a sense of scale:

• Worldwide spending on information technology is roughly $5 trillion a year, of which about $1 trillion is software.
• Several software companies are each worth more than a trillion dollars.
• There are tens of millions of professional software developers in the world.

Whatever field you end up in, someone there is writing programs.

What you will be able to do

• An entry point. This course is the first step into computer science and into programming in general.
• Portable skills. Problem solving, reading code and finding errors carry over to every other language.
• Useful immediately. By the end of term you can automate tedious tasks, process data and check your own calculations.
• A prerequisite. COMP 1001 is required for the Computer Science major and minor and for the courses that follow.

The course begins with problem solving before it begins with Python. A program is only ever as good as the thinking behind it.

Problem Solving

The rest of the course is about solving problems. Here is the framework, and what to do before Lecture 2.

The framework

Every problem in this course, and most problems outside it, can be approached with the same six activities.

1. Understand the problem: what is given, what is wanted, and what the rules are.
2. Decompose it into smaller parts.
3. Recognise patterns: parts you have solved before, or that look like each other.
4. Design and evaluate a method, and test it on normal and awkward cases.
5. Implement the method.
6. Reflect on what worked and what to do differently next time.

Before next class

• Log in to Brightspace and find the COMP 1001 page.
• Confirm which lab section you are registered in (Tuesday morning or afternoon).
• Put October 15, November 4 and November 10 in your calendar.
• Fill in the PAL availability survey.
• Lecture 2 is problem solving on paper: no computer needed, but bring something to write with.

Welcome to COMP 1001.