<!--
Abstract:

CS 211
Computer Architecture
Lecture 01: Introduction
-->

# CS 211 - Lecture 01

## Introduction

Bernhard Firner

2026-01-21

---

## Course Details

* My email: `bfirner@cs.rutgers.edu`
* Canvas
* Office: Hill 273
* Office hours: TBD

---

## Email

* Use `bfirner@cs.rutgers.edu`
  * You may find other address that look like they are mine
  * But some I have never accessed, and others I only check rarely
* Include the course in the subject

---

## What is this class?

* About abstractions
  * Somehow we turn a bunch of bouncing electrons into computers
  * But obviously nobody posting a video online worries about the electrons
* This course looks at the big slice of technology in the middle
  * Starting at human-readable programs
  * Descending to abstract hardware units called gates

---

## Academic Goals

* In general
  * Solidify your understanding of computing
    * Low level programming and execution
    * Data representation
    * Concepts in architecture
      * Memory and cache, digital logic, performance concerns, etc
  * Prepare you for future topics

---

## A Moving Target

* We've never been good at guessing future trends
* What's next?
  * Quantum?
  * More parallelism?
  * Vibe Coding?
* Expect dramatic changes
  * The hot skills and best practices of today will become antiquated

</div>
<div class="col">
<img style="width: 65%" class="r-stretch" src="./figures/kitchen_computer.jpg" />

</div>
</div>

---

## Topic List

* Starting from the top and working down
  * Programming in C
  * Assembly
  * Glossing over Operating System and the software/hardware interface
  * Data representation and machine code
  * Architecture
  * Digital Logic Design

---

## Grading

* Homeworks (7 totalling 50%)
  * A hello world assignment
  * 4 C assignments
  * 1 Assembly
  * 1 Digital Logic

---

## In-Class Evaluations

* Exams and quizzes
  * in-recitation evaluations (10% total)
  * 1 midterm (15%)
  * 1 final (25%)

---

## Academic Integrity

* [CS Academic Integrity Policy](https://www.cs.rutgers.edu/academics/undergraduate/academic-integrity-policy)
* Also be aware that getting 100% on assignments and bombing exams is not a good strategy

---

## Absences & Late assignments

* Use the self-reporting tool
  * [https://sims.rutgers.edu/ssra/](https://sims.rutgers.edu/ssra/)
* Late assignments
  * 10% off for each day late, up to 50%
  * Nothing accepted after 7 days
  * Exceptions for major illnesses
* Missed exams
  * You must have a valid excuse to schedule a make up exam

---

## Exceptions

* Inform me ahead of time of special circumstances
  * Meaning non-emergency situations
* If you have an emergency, please don't stop to email me
  * You can self-report after the fact

---

## Appropriate Conversations

* I can help with problems related to this class
* Can probably help with professional questions
* I'm not a psychologist. I probably can't help with other issues.
  * I am also required to report some topics, so don't assume everything you tell me will remain private

---

## Resources

* iLab
  * [https://resources.cs.rutgers.edu/docs/instructional-lab/](https://resources.cs.rutgers.edu/docs/instructional-lab/)
* Ubuntu Linux 24.04
* gcc
* [https://resources.cs.rutgers.edu/docs/new-users/beginners-info/](https://resources.cs.rutgers.edu/docs/new-users/beginners-info/)
  * iLab information, Linux editors, C programming, etc

---

## References

* [Computer Systems: A Programmer’s Perspective $CS:APP, 3rd ed.$](https://csapp.cs.cmu.edu/)
* [cppreference.com/w/c.html](https://cppreference.com/w/c.html)

---

## Text Editor

What I see

</div>
<div class="col">

* Linux philosophy
  * small, powerful, single-purpose programs
* Try a text editor on linux, code is just text
  * gedit, sublime, etc
  * vim
  * emacs
* Just give your programs the .c extension
* Think about it!

</div>
</div>

---

## Today's Topics

* Basic C syntax
  * Should feel like a review after Java
* Explanation of a program

---

## Starting Point

basic.c:
```C
/*
 * This is an example program.
 * It prints out "Hello world!"
 */
#include <stdio.h>

int main(int argc, char** argv) {
    // Say hello
    printf("Hello world!");
    // Return a number
    return 123;
}
```

<div style="text-align: left; margin-left: 40px;">
Compile with: `gcc basic.c -o basic`

Run with: ./basic
</div>

---

## Comments in C

* Comments are notes you leave to the future
  * Should express the programmer's intent
* Two forward slashes begin a line comment:
```C
// I am a line comment
```

---

## Comments in C

* A forward slash and an asterisk begin a multi-line comment
* An asterisk and a forward slash end a multi-line comment
```C
/*
 I have many things to say.
 * To be pretty, I can align the comments.
          ~But I don't have to.~
*/
```

---

## stdio

* A C `library`
  * Code that someone else wrote, saving your time
  * [https://cppreference.com/w/c/header/stdio.html](https://cppreference.com/w/c/header/stdio.html)
* Large libary list here:
  * [https://cppreference.com/w/c/header.html](https://cppreference.com/w/c/header.html)
* I/O (input/output) means talking with the OS
  * OS passes messages to the hardware

---

## A More Interesting Program

```C
/*
 * This is an example program!
 * To compile code:
 * gcc example1.c -o example1
 */

#include <stdio.h>

int main(int argc, char** argv) {
    // Say hello.
    printf("Hello world!\n");
    // Print out argc, the count of the program arguments
    printf("There are %d arguments.\n", argc);
    // What's the first argument?
    printf("The first argument is %s.\n", argv[0]);
    // Return something.
    return 123;
}
```

---

## Variables

* Create a variable with a `declaration`:
```C
int a = 3;
```
* There is now a `variable` named 'a'
  * 'a' is of type `int`
  * 'a' is set equal to 3
* Declarations in C end with a semicolon (`;`)

---

## Statements

* Statements don't declare anything

```C
//This declares a as an integer and sets it to 3
int a = 3;
//This statement changes a's value to 4
a = 4;
```

---

## More on statements

```C
int main(void)
{ // start of a compound statement
    int n = 1;             // declaration (not a statement)
    n = n+1;               // expression statement
    printf("n = %d\n", n); // expression statement
    return 0;              // return statement
} // end of compound statement, end of function body
```

Adapted from [https://cppreference.com/w/c/language/statements.html](https://cppreference.com/w/c/language/statements.html)

---

## C Has Many Primitive Types

* `Primitive` types exist in the hardware
  * For example, in the CPU
* `int`, `unsigned int`, etc
  * Whole numbers, with or without negatives
* `float`, `double`
  * Fractional numbers
* `bool`
  * `true` or `false` (1 or 0)
* `char`
* `void`

---

## Functions

* `Functions` are blocks of code with any number of statements
* A block of code is enclosed in curly braces: `{` and `}`
* The `type signature` of a function is
  * A `return type`
    * the kind of data returned by the function
  * An `argument list`
    * the kinds of variables the function needs

---

## An Example Function

```C
//This function takes in an int and returns twice that value
int doubleInt(int a) {
  return 2*a;
}
```

---

## Using a Function

```C
/*
 * This is an example program!
 * To compile code:
 * gcc example2.cpp -o example
 */

#include <stdio.h>

//Doubles any integer
int doubleInt(int theNumber) {
	return 2*theNumber;
}

int main(int argc, char** argv) {
	//Your program goes here.

//Declaring a variable!
	int a = 4;
	a = doubleInt(a);
	a = doubleInt(a);
	printf("a is %i\n", a);
	//New line character!
	char newline = '\n';
	printf("The name of the program is %s\n", argv[0]);
	printf("The first argument is %s\n", argv[1]);
	return argc;
}
```

---

## Every Program Begins with Main

* Same as in Java, there is a special function called `main`

```C
int main(int argc, char** argv) {
   ...
}
```

* The program begins inside of main
* When main returns the program (usually) ends
* You'll also see `main(void)` if the arguments won't be used

---

## Compiling

* Once you have written a C program you must `compile` it
  * This looks like compiling in Java, but java does not compile into machine code
* Compiled code converts your text into a binary file
  * `links` your binary with your system libraries
  * We call this an executable

---

## Compiling Details

* When you execute a program the OS helps
  * Converts assembly code into machine instructions for your CPU
  * Sets up memory for your program to use
  * Sets the current execution point of your program to the beginning of the main function

---

## Generating Assembly

* You can generate human-readable assembly code
  * Pass the "-S" argument to gcc
* Gives you an idea of what OS loads and converts into machine code for your CPU.

> gcc -S basic.c -o basic.s

---

## The Code

basic.c:
```C
/*
 * This is an example program.
 * It prints out "Hello world!"
 */
#include <stdio.h>

int main(int argc, char** argv) {
    // Say hello
    printf("Hello world!");
    // Return a number
    return 123;
}
```

---

# Assembly Example

```assembly
	.file	"basic.c"
	.text
	.section	.rodata
.LC0:
	.string	"Hello world!"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	endbr64
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movl	%edi, -4(%rbp)
	movq	%rsi, -16(%rbp)
	leaq	.LC0(%rip), %rax
	movq	%rax, %rdi
	movl	$0, %eax
	call	printf@PLT
	movl	$123, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0"
	.section	.note.GNU-stack,"",@progbits
	.section	.note.gnu.property,"a"
	.align 8
	.long	1f - 0f
	.long	4f - 1f
	.long	5
```

-v-

## More Internals

* This is FYI!
  * You can also use `objdump` to learn more
  * And eventually we will do that!

-v-

## Something for Later

* Compile with debug symbols on (`-g` option)
  * Use the `-c` option to compile, but into binary
  * This skips linking with your local libraries
* Lists instructions after their addresses
  * Original C code is interleaved for readability

> gcc -g -c basic.c\
  objdump -d -M intel -S basic.o

-v-

## Objdump

```C
basic.o:     file format elf64-x86-64

Disassembly of section .text:

0000000000000000 <main>:
#include <stdio.h>

int main(int argc, char** argv) {
   0:	f3 0f 1e fa          	endbr64
   4:	55                   	push   rbp
   5:	48 89 e5             	mov    rbp,rsp
   8:	48 83 ec 10          	sub    rsp,0x10
   c:	89 7d fc             	mov    DWORD PTR [rbp-0x4],edi
   f:	48 89 75 f0          	mov    QWORD PTR [rbp-0x10],rsi
    printf("Hello world!");
  13:	48 8d 05 00 00 00 00 	lea    rax,[rip+0x0]        # 1a <main+0x1a>
  1a:	48 89 c7             	mov    rdi,rax
  1d:	b8 00 00 00 00       	mov    eax,0x0
  22:	e8 00 00 00 00       	call   27 <main+0x27>
    return 123;
  27:	b8 7b 00 00 00       	mov    eax,0x7b
}
  2c:	c9                   	leave
  2d:	c3                   	ret
```

---

## Program Exit Status

* The number returned by main is a program's `exit status`
* From the linux (or Mac) shell the exit status of the previous program is stored in the \$? variable

---

## Take a Deep Breath!

* Now is the time to ask a question!

---

## Math

```C
#include <stdio.h>

int main(void) {
    int a = 4;
    float b = 4.3;
    float a_over_b_f = a / b;
    int a_over_b_i = a / b;
    printf("%i / %f = %f\n", a, b, a_over_b_f);
    printf("%i / %f = %i\n", a, b, a_over_b_i);
    return 0;
}
```

---

## Truncation

* `int` types cannot hold fractions, so they are `truncated`
  * Any fractional value is lost

```
$ ./a.out
4 / 4.300000 = 0.930233
4 / 4.300000 = 0
```

---

## Casting

* Some languages will automatically convert types
  * So dividing one int by another could yield a float
* Typing in C is strict, so operations involving ints will remain ints
  * To change that, you would `cast`, converting a value into a new type
    * `float c = (float)a / 3;`

---

## Modulo arithmetic

* The remainder function, `%`, find the remainder
  * If it is nonzero, then an `int` operation will truncate something
  * But it does not work with `float` values!
* Examples
  * `4 % 4 = 0`
  * `8 % 4 = 0`
  * `9 % 4 = 1`
  * `-9 % 4 = -1`
  * `-12 % -5 = -2`

---

## Dividing by zero

* Avoid it

```C
#include <stdio.h>

int main(void) {
    int a = 4;
    float b = 4.3;
    // This will crash your code
    // The error will be:
    //     Floating point exception (core dumped)
    //printf("%i / 0 = %i\n", a, a/0);
    printf("%f / 0 = %f\n", b, b/0);
    return 0;
}
```

> 4.300000 / 0 = inf

---

## Special values

* `inf` and `NaN` (not a number) are special floating point values
* You'll see them when you've done something wrong
  * Infinitely small or large values
  * Unrepresentable math

---

## Next Class

* Arrays and control flow
  * required to do anything interesting

---

## Homework

* Make sure that your iLab account works
  * Will assign a basic hello world homework next Monday
  * So try to verify that your ilab login is working

> ssh netid@ilab.cs.rutgers.edu

* Replace "netid" with your actual netid