• Three themes: reliability, reproducibility, and robustness
• What we cover:
  • Command line and shell scripting
  • Version control with Git and GitHub
  • Reproducible reports with Quarto
  • AI-assisted programming
  • Cloud computing
  • Getting data from the web
  • Scaling and parallel computing
  • Containers with Docker

• Grading:
  • 50% assignments (10)
  • 30% in-class quizzes (5)
  • 20% final project

• AI is allowed in all assignments and quizzes
• Discuss with classmates, but submit your own work
• Late submissions: 10% off per day
• More details on the course repository

Video: How to use an abacus

The 1970s marked the transition from mechanical to electronic:

• Transistors act as switches for electronic signals
• Integrated circuits combine multiple transistors on a single chip
• Microprocessors are integrated circuits that contain the functions of a computer’s central processing unit (CPU)
• They follow the Von Neumann architecture

• The Von Neumann architecture keeps programs and data in the same memory
• Five parts: memory, control unit (directs the others), arithmetic logic unit (does the maths), input, and output
• Instructions travel from slow storage (a hard disk) to fast RAM, then to the CPU
• The CPU repeats one cycle: fetch, decode, execute
• Proposed in 1945, when programs were still seen as part of the machine
• Almost every computer you use today works this way

• Advantages:
  • One memory for everything, so the design stays simple and cheap
  • Programs can be loaded, changed, and replaced like any other data
• Disadvantages:
  • The Von Neumann bottleneck: one bus (the wires linking the CPU to memory) carries both instructions and data, so only one can move at a time
  • The CPU sits idle while it waits for memory. Modern chips hide this with caches
  • The Harvard architecture splits the two memories. Most CPUs today use a mix of both

• Computers store everything as 0s and 1s
• A transistor is a switch: high voltage is 1, low voltage is 0
• They are tiny and cheap. A modern chip holds ~200 billion transistors and performs billions of operations per second!
• Two states are the simplest thing a switch can do

• So how do we get to text, images, and video?
• By abstraction, keeping only the detail we need
• A colour becomes three numbers. A number becomes 0s and 1s
• Each layer hides the one below

• We can convert between number systems by translating a value from one system to the other
• For example, the coins on the left represent the same value as $0.87
• Using pictures is clunky. Let’s make a new representation system for coins

• To represent coins, we will make a number with four digits
• The first represents quarters, the second dimes, the third nickels, and the fourth pennies
  • c3102 =
  • 3 x $0.25 + 1 x $0.10 + 0 x $0.05 + 2 x $0.01 =
  • $0.87

• When we represent values with multiple bytes, it is hard to distinguish where numbers begin and end
• Hexadecimal is a number system with 16 digits: 0123456789ABCDEF
• It is used to represent binary numbers in a more compact way
• Each hex digit corresponds to 4 binary bits, making it a shorthand for binary:
  • 0000 = 0
  • 0001 = 1
  • 0010 = 2
  • …
  • 1110 = E
  • 1111 = F

• Next, how do we represent text?
• First, we break it down into smaller parts, like with images. In this case, we break text down into individual characters
• A character is the smallest component of text, like A, B, or /
• A glyph is the graphical representation of a character
• The display of glyphs is typically handled by GUI (Graphical User Interface) toolkits or font renderers

• For example, the text “Hello World” becomes H, e, l, l, o, space, W, o, r, l, d
• Unlike colours, characters do not have a logical connection to numbers
• To represent characters as numbers, we use a lookup table called ASCII
• ASCII stands for American Standard Code for Information Interchange
• As long as every computer uses the same lookup table, computers can always translate a set of numbers into the same set of characters

• ASCII maps the numbers 0 to 127 to characters
• That range needs 7 bits, so a character fits in one byte
• A is 65, a is 97, and a space is 32
• The first 32 entries are not letters at all. They are control codes, like tab and newline
• Explore the whole table here

“Hello World” =

01001000 01100101 01101100 01101100 01101111 00100000 01010111 01101111 01110010 01101100 01100100

• Translate the following binary into ASCII text:
• Work in hexadecimal or in decimal

01011001 01100001 01111001

• Konrad Zuse was a German engineer and computer pioneer
• He created the first programmable computer, the Z3, in 1941
• The Z3 was the first computer to use binary arithmetic and read binary instructions from punch tape
• Example: Z4 had 512 bytes of memory
• Zuse also created the first high-level programming language, Plankalkül (“calculus for planning”)

• Assembly language is a low-level programming language that allows writing machine code in human-readable text
• Each instruction corresponds to a single machine code instruction
• The first assemblers were human!
• Programmers wrote assembly code, which secretaries transcribed to binary for machine processing

• Low-level languages are closer to machine code and are harder to read and write
• High-level languages abstract from hardware details and are portable across different systems

• Compiled Languages: Convert code to binary instructions before execution (e.g., C++, Fortran, Go)
• Interpreted Languages: Run inside a program that interprets and executes commands immediately (e.g., R, Python)

• “Hello, World!” in machine code (hex):

48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21

• “Hello, World!” in Assembly (x86-64 Assembly for Linux)

section .data
    message db 'Hello, World!', 10  ; 10 is ASCII for newline
    msglen  equ $ - message         ; length, worked out by the assembler

section .text
    global _start

_start:
    mov rax, 1          ; system call number for write
    mov rdi, 1          ; file descriptor 1 is stdout
    mov rsi, message    ; address of the string
    mov rdx, msglen     ; how many bytes to write
    syscall             ; hand over to the kernel

    mov rax, 60         ; system call number for exit
    xor rdi, rdi        ; exit status 0
    syscall             ; hand over to the kernel

• “Hello, World!” in Python:

print("Hello, World!")