Soma-notes - User contributions [en]

SystemsSec 2018W Lecture 12

2018-02-20T19:38:47Z

Jagger:

==Audio==

[https://homeostasis.scs.carleton.ca/~soma/systemssec-2018w/lectures/comp4108-2018w-lec12-14Feb2018.m4a Lecture 12 Audio]

==Notes==

Potential Assignment Topics:
*Crypto
**What does it buy you?
**What can’t it do?
*Obfuscation
*Memory corruption
*Logic errors
*Back doors
*Certificates

SQL Injections
*Query is unsanitized

In the browser what interpreters do we have?
*Javascript
*HTML
*CSS

What does it mean to exploit it?
*To use a vulnerability to your advantage

In the webpage, there are all kinds of content. There are advertisements, search bars, twitter feeds, facebook like buttons, etc.

Everything on a webpage has access to the document object model.

Setuid programs -> How much do you have to trust?

Anyone that you allow to become root can do way too much.

Sammy Attack:
*Happened during the days of myspace
*Forces users to send samy a friend request
*Harmless

In the comment section, there is a possibility of malicious code.

CSRF
*Have the victim visit a random webpage
*Have the ability to make your web browser do all sorts of network traffic

You can pull any arbitrary content over the internet and stick it into a webpage.

Cookies:
*Stored on the web browser
*Remembers information about the person browsing the website

Some websites let you stay logged in for a long time. Some don’t.

XML HTTP Request -> Developed by microsoft

Why did microsoft do this?
*Outlook client access

What people want to do with the web impacts security design.

Can you embed arbitrary html in facebook? -> No

Either you filter out the bad things, or you escape the bad things.

How can we minimize people from running code on your web browser?
*Idea of least privilege

Same Origin Policy
*The only person that is allowed to get access to your web browser is the origin server.

CSP
*Prevents stuff from coming from arbitrary sources
*It does not help with you visiting untrusted sources
*Keeps a list of who is trusted and who is not trusted

Web browsers -> The modern operating system

Web browsers have a different trust model than the operating system does.

Web browsers sandboxes code

Phone operating systems:
*Deal with similar threat model to the web

IOS strategy for dealing with threats:
*Sandbox the hell out of everything

Android Model:
*Access control using capabilities list

Everytime you install an app on android, it would need to do a security analysis. You would get questions regarding your current location, camera access, microphone access, etc. Why does it do that? For advertisement content.

Snaps and flat packs
*Standards for packaging linux applications to run on systems.
*They also include sandboxing

If you want to run skype on your linux system, you can get a “snap” for it. But you have to install it on classic mode.

How are you going to make sure that you are going to be provided with safety while running untrusted code?
*Access control
*Sandboxing

Usability of security systems

Questions:
*What can we do to restrict people from putting arbitrary code onto the website you are visiting?
*What is browser exploit? How do we prevent it?
*What is the program with fine grained permissions?

SystemsSec 2018W Lecture 9

2018-02-06T04:21:20Z

Jagger: Create page and add notes section

==Notes==

<pre>
Software Vulnerabilities
======

Sandboxing: [ dangerous ] safe
(untrusted) (trusted)

Firewalls: [ safe ] dangerous

What else? Access control?

Conceptually, a software vulnerability is when the barriers (trust boundaries) are bypassed.

How do we detect when trust boundaries are defied?
- classic example, logging ("Hey that's an IP from Eastern Europe")

Classic Attack Vectors (not related to vulns)
- insider attacks
- social engineering

Mobile phone threat modeling
======
How can an attacker get access to your device?

The web.

Your phone in this example is not listening on any ports, but it is easy to get bits onto your phone. Send the victim an email. Buy targeted ads. etc. i.e. get them to talk to you.

Now that the bits are on the device, how will they "escape"?
There are classficiations like:
- remote code execution
- priviledge escalation
- etc.

I/O devices (bit entrypoints)
======
- removable storage
- network
- video/audio input (webcam, microphone)
- peripherals (mouse, keyboard, touch screen)
- mobile specific inputs (accelerometer, gyroscope, compass, barometer, GPS)

What are all these things, at their core?

[ a device ] <-> [ driver ] <-> [ kernel ] <-> [ process ]
[ CPU and memory ] <- Spectre and Meltdown live here

Each step along the chain is a potential place to attack.

How can each step (software) fail? Rough categories:
- memory corruption (buffer overruns) (more hard nowadays)
- "interpreter" abuse
- logic errors
- race condition (TOCTTOU: time of check to time of use)
- information leak (people can hear you through the wall, but can't otherwise get through it)
</pre>

Computer Systems Security (Winter 2018)

2018-02-06T04:16:51Z

Jagger: /* Schedule */

==Course Outline==

[[Computer Systems Security: Winter 2018 Course Outline|Course Outline]]

==Experiences==

You are required to complete 9 experiences throughout the semester.

* [[Computer Systems Security: Winter 2018 Experiences|List of Experiences]]

==Assignments==

Assignments will be posted here as they become available

* [[Computer Systems Security: Winter 2018 Assignment 1|Assignment 1]]
* Assignment 2
* Assignment 3
* Assignment 4

==Resources==

Here are some resources you may find useful:

* [http://homeostasis.scs.carleton.ca/~soma/systemssec-2018w/comp4108-2018w.ova A Virtualbox OVF image for Ubuntu 17.10.1]
* [https://openstack.scs.carleton.ca The SCS openstack cluster]. Note that you can only access this from the Carleton network. To access from elsewhere, [https://carleton.ca/its/help-centre/remote-access/ VPN in] to the university. (On Linux you can also use openconnect rather than the Cisco software provided by Carleton.)

If you cannot access openstack, try [http://www.scs.carleton.ca/webacct changing your SCS password].

==Schedule==

===January 8, 2018===

[[SystemsSec 2018W Lecture 1|Introduction]]

===January 10, 2018===

[[SystemsSec 2018W Lecture 2|Threat Modelling]]

===January 15, 2018===

[[SystemsSec 2018W Lecture 3|Common tools]]

===January 17, 2018===

[[SystemsSec 2018W Lecture 4|passwd]]

===January 22, 2018===

[[SystemsSec 2018W Lecture 5|Networking 1]]

===January 24, 2018===

[[SystemsSec 2018W Lecture 6|Virtual machines 1]]

===January 29, 2018===

[[SystemsSec 2018W Lecture 7|Cryptography 1]]

===January 31, 2018===

[[SystemsSec 2018W Lecture 8|Networking 2]]

Assignment 1 due

===February 5, 2018===

[[SystemsSec 2018W Lecture 9|Software Vulnerabilities 1]]

===February 14, 2018===

Assignment 2 due

===February 19 & 21, 2018===

Winter break, no classes

===February 26, 2018===

Mid-term review

===February 28, 2018===

Mid-term Exam

===March 19, 2018===

Assignment 3 due

===April 4, 2018===

Assignment 4 due

===April 9, 2018===

Last day of class

Operating Systems 2017F: Tutorial 5

2017-11-05T22:22:06Z

Jagger: /* A simple kernel module */

In this tutorial you will be creating filesystems and installing kernel modules. It is '''highly recommended''' that you use a comp3000 openstack instance for the exercises below for two reasons. In particular you may have difficulties compiling kernel modules on other systems. You will need root access to install kernel modules and mount filesystems. These operations are potentially dangerous and mistakes could '''destroy all data''' on the Linux system. Consider yourself warned!

==Filesystems==

# Run <tt>ls -lai</tt> (by itself or for a specific directory). What are the numbers appearing in the left column?
# dd if=/dev/zero of=foo bs=8192 count=32K What is the logical size of the file? How much space does it consume on disk? (Hint: Look at the size option to ls.)
# Run <tt>mkfs.ext4 foo</tt>. (If asked, say "yes" to operating on a regular file.) Does foo consume any more space?
# Run <tt>dumpe2fs foo</tt>. What does the output of this command mean?
# What command do you run to check the filesystem in foo for errors?
# Run <tt>sudo mount foo /mnt</tt>. How does this command change what files are accessible?
# Run <tt>df</tt>. What device is mounted on /mnt? What is this device?
# Run <tt>rsync -a -v /etc /mnt</tt>. What does this command do? Explain the arguments as well.
# Run <tt>sudo umount /mnt</tt>. What files can you still access, and what have gone away?
# Run <tt>dd if=/dev/zero of=foo conv=notrunc count=10 bs=512</tt>. How does the "conv=notrunc" change dd's behavior (versus the command in question 1)?
# Run <tt>sudo mount foo /mnt</tt>. What error do you get?
# What command can you run to make foo mountable again? What characteristic of the file system enables this command to work?
# Run the command <tt>truncate -s 1G bar</tt>. What is the logical size of bar, and how much space does it consume on disk? How does this compare with foo?
# How does the logical size of bar change when you create an ext4 filesystem in it? What about the space consumed on disk?

==A simple kernel module==

# Download the source for [http://homeostasis.scs.carleton.ca/~soma/os-2015f/code/simple.zip this simple module], unpack, and build it by typing "make". Use <code>wget</code>
# Install the module using "sudo insmod simple.ko". The hello message is recorded in the kernel logs. How do you view the kernel logs?
# Check to see that the module has been loaded. How do you do this?
# Remove the module from the kernel. What did you do?

==A character device kernel module==

# Download the source for [http://homeostasis.scs.carleton.ca/~soma/os-2015f/code/ones.zip ones], a kernel module implementing a character device that ouputs an unbounded string of "1"'s. Build, compile, and run it as before.
# What kernel messages does the module generate? Does it create any new files (other than /dev/ones)? If so, where?
# What happens when you "cat" the device /dev/ones? How can you limit the output?
# How can you modify your module to generate a kernel "Oops" as reported in the kernel logs or outright crash the kernel?

==Simple module==

===simple.c===

<source lang="c">
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>

static int __init simple_init(void)
{
printk ("Hello kernel world!\n");
return 0;
}

static void __exit simple_exit(void)
{
printk ("Goodbye kernel world.\n");
return;
}

module_init(simple_init);
module_exit(simple_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Anil Somayaji <soma@scs.carleton.ca>");
MODULE_DESCRIPTION("A simple module");
</source>

===Makefile===

<source lang="make">
obj-m := simple.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
</source>

==Ones module==

===ones.c===
<source lang="c">
/* Code derived from:
https://appusajeev.wordpress.com/2011/06/18/writing-a-linux-character-device-driver/
and
http://pete.akeo.ie/2011/08/writing-linux-device-driver-for-kernels.html
*/

#include <linux/module.h>
#include <linux/string.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <asm/uaccess.h>

#define dbg(format, arg...) do { if (debug) pr_info(CLASS_NAME ": %s: " format, __FUNCTION__, ## arg); } while (0)
#define err(format, arg...) pr_err(CLASS_NAME ": " format, ## arg)
#define info(format, arg...) pr_info(CLASS_NAME ": " format, ## arg)
#define warn(format, arg...) pr_warn(CLASS_NAME ": " format, ## arg)

#define DEVICE_NAME "ones"
#define CLASS_NAME "comp3000"

static struct class* ones_class = NULL;
static struct device* ones_device = NULL;
static int ones_major;

static int ones_open(struct inode *the_inode, struct file *f)
{
return 0;
}

static ssize_t ones_read(struct file *f, char *buf, size_t len, loff_t *offset)
{
size_t i;

for (i = 0; i < len; i++) {
put_user('1', buf++);
}

return i;
}

static int ones_release(struct inode *the_inode, struct file *f)
{
printk(KERN_ALERT "Ones device closed\n");
return 0;
}

static struct file_operations ones_fops = {
.open = ones_open,
.read = ones_read,
.release = ones_release,
};

static char *ones_devnode(struct device *dev, umode_t *mode)
{
if (mode)
*mode = 0444;
return NULL;
}

static int __init ones_init(void)
{
int retval;

ones_major = register_chrdev(0, DEVICE_NAME, &ones_fops);
if (ones_major < 0) {
err("failed to register device: error %d\n", ones_major);
retval = ones_major;
goto failed_chrdevreg;
}

ones_class = class_create(THIS_MODULE, CLASS_NAME);
if (IS_ERR(ones_class)) {
err("failed to register device class '%s'\n", CLASS_NAME);
retval = PTR_ERR(ones_class);
goto failed_classreg;
}

ones_class->devnode = ones_devnode;

ones_device = device_create(ones_class, NULL, MKDEV(ones_major, 0),
NULL, DEVICE_NAME);

if (IS_ERR(ones_device)) {
err("failed to create device '%s'\n", DEVICE_NAME);
retval = PTR_ERR(ones_device);
goto failed_devreg;
}

info("Ones device registered using major %d.\n", ones_major);

return 0;

failed_devreg:
class_unregister(ones_class);
class_destroy(ones_class);
failed_classreg:
unregister_chrdev(ones_major, DEVICE_NAME);
failed_chrdevreg:
return -1;
}

static void __exit ones_exit(void)
{
device_destroy(ones_class, MKDEV(ones_major, 0));
class_unregister(ones_class);
class_destroy(ones_class);
unregister_chrdev(ones_major, "ones");
info("Unloading Ones module.\n");
return;
}

module_init(ones_init);
module_exit(ones_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Anil Somayaji <soma@scs.carleton.ca>");
MODULE_DESCRIPTION("A write ones character device module");
</source>

===Makefile===
<source lang="make">
obj-m := ones.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
</source>

Operating Systems 2017F Lecture 7

2017-10-04T05:16:50Z

Jagger: Significant formatting improvement, some content omissions, spelling errors

==Video==

Video from the lecture given on September 28, 2017 [http://homeostasis.scs.carleton.ca/~soma/os-2017f/lectures/comp3000-2017f-lec07-28Sep2017.mp4 is now available].

==Code==

Code and files from the lecture (captured as they were at the end) are available [http://homeostasis.scs.carleton.ca/~soma/os-2017f/code/lec07/ here].

==Notes==

3000 Sep28
Next week: Anil is away from Sunday to Thursday morning. Review section.

Topic today: File systems

===What is a file?===
It is a key - value pair.

*Key: hierarchical filename (pathname)
*Value: arbitrary number of bytes

'''In principle, you can use files to store very small values'''
* most filesystems have a minimum file size of at least 1k, often 4K or more
* a file containing one byte of data wastes a lot of real disk space
'''A set of files 'stored' together, sharing a common hierarchical root, is a filesystem.'''
Why quote 'stored'?
* Because there is no storage for virtual filesystems (such as /proc and /sys)
* when you first start a UNIX system, you start with the ‘root’ filesystem. (have nothing to do with root user.)
* other filesystems can be put on top by "mount"-ing them.

====Demonstration====

Run <code>mount</code>, it shows
/dev/vda1 on / type ext4 (rw, relatetime,data=ordered)

* /dev is root filesystem
* / is the top of hierarchy
* ‘rw’ means read write
* /def/vda1 is a Special file, files in /dev are special files.

(Special files are actual files, historically they might have been stored on disk, nowadays they are not.)

Run <code>df .</code> (df is for displaying the amount of available disk space for file systems on which the invoking user has appropriate read access.)
* There is a filesystem called ‘udev’, which is a virtual file system with zero space used, since it is created automatically on run time

Run <code>who</code> in another terminal
* it displays <code>soma tty7 2017-09-28 12:59 (:0)</code>

Run <code>ls /dev</code>
*Instead of ''vda'', it shows ''sda''. The ‘v’ in ''vda'' stands for ‘virtual’. The ‘s’ in ''sda'' stands for SCSI (The Small Computer System Interface).
*Any device you want to access on unix system has /dev

Run <code>ls -a</code> in <code>/dev</code>

*Looking at the permissions (e.g ‘crw--rw----’), first letter for normal file is blank , directory is ‘d’, ‘c’ is for Character Devices, ‘b’ is for Block Devices

*Character devices example: keyboard, mouse, /dev/random
:-read/write a single byte (character) at a time
*What makes b-disk different? Caches.
:-Hard drives are optical drives are examples of block devices
*Character and block devices are accessed via special files, denoted by 'c' and 'b' in the file metadata
*Block devices are for block storage, to cache results
:-It is faster to read or write large chunks of data (e.g. 4KiB) than it would be one byte at a time
:-Traditional filesystems are stored in block devices
*However, a filesystem can be anything that provides a filesystem interface.

'''file interface basics:'''

*open, read, write, seek, close
*open directory, read/write directory, close directory

'''Block size issues:'''

*larger blocks, less overhead
:-there is a fixed cost for each block access
:-large files span many blocks
*smaller blocks, more efficient space usage
:-you end up with fewer files that are smaller than one block

'''filesystem interface basics:'''

-mount and unmount

filesystem block size is a multiple of disk block (sometimes called sector or cluster) size
e.g. an SSD has a 512 byte sectors with an EXT3 filesystem with 8,192 byte (8K) blocks

===Inodes===

How do you structure a filesystem? First, you have to understand inodes.

====Demonstration====

1. Run <code>cp lec07.txt test.txt</code>
:- There is no difference between those files
2. Run <code>ln test.txt duplicate.txt</code>
:- There is difference between duplicate.txt and test.txt: A number for test.txt changed from ‘1’ to ‘2’. That number is inode count
:- <code>ln</code> stands for ''link''
3. Run <code>ln duplicate.txt alsodup.txt</code>
:- Inode count number changed ‘2’ from ‘3’
4. Run <code>ln -s duplicate.txt another.txt</code>
:- There is no different between another.txt lec07.txt
5. Run <code>ls -la</code>has diffrence’
:- It shows another.txt -> duplicate.txt (symbolic link pointing one to the other
6.Run <code>rm duplicate.txt</code>
:- The arrow is still pointing, but inode count number goes down. (From ‘3’ to ‘2’)
7. Run <code>cat another.txt</code>
:- It shows there is such file, because the file that pointing to is not exist

* ‘ln’ creates hard links to an item by default.
* File name is a pointer to an inodes.
* ‘rm’ is not remove, just unlink, which reduces the link count for inode
* When you clear storage, when inode inbound number go to 0, is not link to other file,system will remove it.
* When the user open a file, reference count is incremented.
* A file sys doesn’t have to be a block device? It can store anywhere as long as you provide the api.
* A file system can be made in a file (the basic of virtual machine)

One other file api: mmap

'''Inode store permission'''

mmap, munmap: map or unmap files or devices into memory, this is the piece that unify the file sys with process memory.

What ‘read’ does: read directly into RAM

Run <code>top</code>:

:-There are ‘VIRT’, ‘RES’ and ‘SHR’:
VIRT stands for the virtual size of a process
RES stands for the resident size, which is an accurate representation of how much actual physical memory a process is consuming.
SHR indicates how much of the VIRT size is actually sharable (memory or libraries).

Operating Systems 2017F Lecture 2

2017-10-04T03:55:15Z

Jagger: fix hello world syntax highlighting

==Video==

Video from the lecture given on September 12, 2017 [http://homeostasis.scs.carleton.ca/~soma/os-2017f/lectures/comp3000-2017f-lec02-12Sep2017.mp4 is now available].

==Code==

Code and files from the lecture (captured as they were at the end) are available [http://homeostasis.scs.carleton.ca/~soma/os-2017f/code/lec02/ here].

==Notes==
'''What is a file?'''
- A hierarchical name with a value mapping, accessed using the API "open, read, close, seek" (roughly). Open and close are used for efficiency; read and write do all of the work.

'''Why is Unix and Linux interchangeable?'''
- Linux is a variant of the Unix, it contains the Unix kernel with custom built layers on top.

'''What is the architecture of the Unix kernel?'''
- A system of hierarchical files that represent all of the different hardware devices
for example: writing to stdout or reading from stdin. These are the computer monitor and keyborad file descriptors.

'''How do we add new devices to the system?'''
- We tell the operating system to mount the new device. The operating system responds with a file descriptor for the new device. Accessing the device means writing to its file.
- There are many files that represent a device. We can trace these files by calling the command "lspci" which gets the PCI bus hardware device info from the kernel. Using the
command "strace lspci" we can trace all of the system calls performed by lspci. Now we know exactly which files make up each device on the PCI bus.
- file descriptors like /dev or /sys are conduits to the kernel. The kernel then performs operations on the hardware.

The key point(s): The kernel abstracts the hardware by assigning file descriptors for every device. A program can gain information about the device using system calls to the kernel.

'''Virtualizing Memory'''
- Hard disks file descriptors appear as:
- /dev/sda -> unencrypted drive
- /dev/mapper… -> encrypted drive
- We can see the filesystem using the "df" command or view the size of files using "df."
- Why are some of the files showing a size of 0 bytes?
- When memory is virtualized, the kernel builds the file system as it goes.

'''Processes'''
- '''What is a Process?'''
- A running program
- Just like the devices, every process gets a directory in the files system "/proc"
- To view running process use the command "ps"
- To stop a running process use the command "Kill <process id>"
- '''What happens when multiple processes are created?'''
- The operating system shares the resources between the processes using time sharing -- also called virtualizing the resources.
- '''What is a shell in Linux?'''
- Just another program that can access the operating system and run other programs
- A shell can run multiple programs (processes), only control returns to the shell after the process has finished. To give the shell priority use the "&" to send the current process to
the background. This idea demonstrates how the CPU is virtualized because it is being shared by the shell and the running process. The concept was demonstrated using xclock.
- Use the "jobs" command to see which processes are running
- Use the "ps aux" command to view the full command line of all running processes.
- Use the "getpid()" function call in a c program to find the process id for the current process.
- Use the "getppid()" function call in a c program to find the parents process id for the current process.
- '''How do I make a process?'''
- by copying the current process
- fork(): a system call the clones the currently running process. The new process (child) begins executing from the statement that contained the call to fork().
- fork() returns zero it means the child process is running.
- fork() returns > 0 it means the parent process is running.
- fork() returns < 0 it means the fork() failed.

Using fork() in a c program

<syntaxhighlight lang="c">
/* hello-world.c */

#include <stdio.h>
#include <unistd.h>

int main() {
fork();
fork();

printf("Hello world! I'm %d. My parent is %d\n", getpid(), getppid());
return 42;
}
</syntaxhighlight>

'''What does the program do?'''
- The first call to fork() clones a child process running the hello-world program. The child begins operating as if it just called fork(). Only the value returned from fork()
is different for the child than the parent. The child process returns a zero.
- Now there are two processes running concurrently, executing the same code. A parent process and a child process.
- The parent process calls fork() again creating another child process, and the first child process also creates a child process. Now there are 4 processes running concurrently.
- All 4 processes will print their process id and their parent's process id.
- finally a return value of 42 is delivered to the parent of each process as it exits.
- Important: The order of execution for each process is not deterministic. We do not know which process will run next because the operating system decides.

Operating Systems (Fall 2017)

2017-09-29T22:02:14Z

Jagger:

==Course Outline==

[[Operating Systems (Fall 2017) Course Outline|Here]] is the course outline for COMP 3000: Operating Systems.

==Lectures and Exams==

Note that the topics below are primarily chapters from the class textbook, [http://pages.cs.wisc.edu/~remzi/OSTEP/ Operating Systems: Three Easy Pieces]. Note that while introductory and summary dialogues are not linked below, they are worth reading for an informal take on the material.

Assigned readings are subject to change, please check this page each week.

<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Date
</th>
<th>
Topic
</th>
</tr>
<tr>
<td>
Sept. 7

</td>
<td>
[[Operating Systems 2017F Lecture 1|Lecture 1]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/intro.pdf Introduction]

</td>
</tr>
<tr>
<td>
Sept. 12

</td>
<td>
[[Operating Systems 2017F Lecture 2|Lecture 2]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-intro.pdf Processes], [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-api.pdf Process API]

</td>
</tr>
<tr>
<td>
Sept. 14

</td>
<td>
[[Operating Systems 2017F Lecture 3|Lecture 3]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-mechanisms.pdf Limited Direct Execution], [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-sched.pdf CPU Scheduling], [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-sched-mlfq.pdf MLFQ] 
</td>
</tr>
<tr>
<td>
Sept. 19

</td>
<td>
[[Operating Systems 2017F Lecture 4|Lecture 4]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-intro.pdf Address Spaces], [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-api.pdf Memory API]

</td>
</tr>
<tr>
<td>
Sept. 21

</td>
<td>
[[Operating Systems 2017F Lecture 5|Lecture 5]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/file-disks.pdf Hard Disk Drives], [http://pages.cs.wisc.edu/~remzi/OSTEP/file-intro.pdf File and Directories]

</td>
</tr>
<tr>
<td>
Sept. 26

</td>
<td>
[[Operating Systems 2017F Lecture 6|Lecture 6]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/file-devices.pdf I/O Devices], [http://pages.cs.wisc.edu/~remzi/OSTEP/file-journaling.pdf FSCK and Journaling]

</td>
</tr>
<tr>
<td>
Sept. 28

</td>
<td>
[[Operating Systems 2017F Lecture 7|Lecture 7]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/file-implementation.pdf File System Implementation]
</td>
</tr>
<tr>
<td>
Oct. 3

</td>
<td>
[[Operating Systems 2017F Lecture 8|Lecture 8]]: Assignment/Tutorial help session (Akhil)
</td>
</tr>
<tr>
<td>
Oct. 5

</td>
<td>
[[Operating Systems 2017F Lecture 9|Lecture 9]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-intro.pdf Concurrency and Threads], [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-locks.pdf Locks]
</td>
</tr>
<tr>
<td>
Oct. 10

</td>
<td>
[[Operating Systems 2017F Lecture 10|Lecture 10]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-locks-usage.pdf Concurrent Data Structures], [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-sema.pdf Semaphores]

</td>
</tr>
<tr>
<td>
Oct. 12

</td>
<td>
[[Operating Systems 2017F Lecture 11|Lecture 11]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-mechanism.pdf Address Translation], [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-tlbs.pdf TLBs]
</td>
</tr>
<tr>
<td>
Oct. 17

</td>
<td>
[[Operating Systems 2017F Lecture 12|Lecture 12]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-segmentation.pdf Segmentation], [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-freespace.pdf Free space management]
</td>
</tr>
<tr>
<td>
Oct. 19

</td>
<td>
[[Operating Systems 2017F Lecture 13|Lecture 13]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-paging.pdf Paging]
</td>
</tr>
<tr>
<td>
Oct. 31

</td>
<td>
[[Operating Systems 2017F Lecture 14|Lecture 14]]: Midterm Review
</td>
</tr>
<tr>
<td>
Nov. 2

</td>
<td>
[[Operating Systems 2017F Lecture 15|Lecture 15]]: Midterm Exam

</td>
</tr>
<tr>
<td>
Nov. 7

</td>
<td>
[[Operating Systems 2017F Lecture 16|Lecture 16]]

</td>
</tr>
<tr>
<td>
Nov. 9

</td>
<td>
[[Operating Systems 2017F Lecture 17|Lecture 17]]

</td>
</tr>
<tr>
<td>
Nov. 14

</td>
<td>
[[Operating Systems 2017F Lecture 18|Lecture 18]]

</td>
</tr>
<tr>
<td>
Nov. 16

</td>
<td>
[[Operating Systems 2017F Lecture 19|Lecture 19]]

</td>
</tr>
<tr>
<td>
Nov. 21

</td>
<td>
[[Operating Systems 2017F Lecture 20|Lecture 20]]

</td>
</tr>
<tr>
<td>
Nov. 23

</td>
<td>
[[Operating Systems 2017F Lecture 21|Lecture 21]]: TBD (US Thanksgiving)

</td>
</tr>
<tr>
<td>
Nov. 28

</td>
<td>
[[Operating Systems 2017F Lecture 22|Lecture 22]]

</td>
</tr>
<tr>
<td>
Nov. 30

</td>
<td>
[[Operating Systems 2017F Lecture 23|Lecture 23]]

</td>
</tr>
<tr>
<td>
Dec. 5

</td>
<td>
[[Operating Systems 2017F Lecture 24|Lecture 24]]

</td>
</tr>
<tr>
<td>
Dec. 7

</td>
<td>
[[Operating Systems 2017F Lecture 25|Lecture 25]]

</td>
</tr>
</table>

==Tutorials==

Each week you will get a progress grade from 0-4, given to you by a TA. If you are being diligent, you should be able to get 4's every week. The easiest way to get your grade is to come to tutorial and meet with your TA; alternately, you can meet a TA in their office hours or, at their discretion, discuss things with them online.

<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Date
</th>
<th>
Tutorials
</th>
</tr>
<tr>
<td>
Sept. 18,20

</td>
<td>
[[Operating Systems 2017F: Tutorial 1|Processes and System Calls]]

</td>
</tr>
<tr>
<td>
Sept. 25, 27

</td>
<td>
[[Operating Systems 2017F: Tutorial 2|3000shell.c]]

</td>
</tr>
<tr>
<td>
Oct. 2, 4

</td>
<td>
[[Operating Systems 2017F: Tutorial 3|TBA]]

</td>
</tr>
<tr>
<td>
Oct. 16, 18

</td>
<td>
[[Operating Systems 2017F: Tutorial 4|TBA]]

</td>
</tr>
<tr>
<td>
Nov. 6, 8

</td>
<td>
[[Operating Systems 2017F: Tutorial 5|TBA]]

</td>
</tr>
<tr>
<td>
Nov. 13, 15

</td>
<td>
[[Operating Systems 2017F: Tutorial 6|TBA]]

</td>
</tr>
<tr>
<td>
Nov. 20, 22

</td>
<td>
[[Operating Systems 2017F: Tutorial 7|TBA]]

</td>
</tr>
<tr>
<tr>
<td>
Nov. 27, 29

</td>
<td>
[[Operating Systems 2017F: Tutorial 8|TBA]]

</td>
</tr>
</table>

==Assignments==
<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Due Date
</th>
<th>
Assignments
</th>
</tr>
<tr>
<td>
Oct. 9

</td>
<td>
[[Operating Systems 2017F: Assignment 1|Assignment 1]]

</td>
</tr>
<tr>
<td>
Oct. 23

</td>
<td>
[[Operating Systems 2017F: Assignment 2|Assignment 2]]

</td>
</tr>
<tr>
<td>
Nov. 20

</td>
<td>
[[Operating Systems 2017F: Assignment 3|Assignment 3]]

</td>
</tr>
<tr>
<td>
Dec. 4

</td>
<td>
[[Operating Systems 2017F: Assignment 4|Assignment 4]]

</td>
</tr>
</table>

==Course Software==

In this course we will primarily working with [http://www.ubuntu.com/ Ubuntu], a widely-used family of Linux distributions. We will be using Ubuntu Server on the SCS's [http://openstack.scs.carleton.ca/ Openstack installation] (accessible only from the Carleton network).

You may use other Linux distributions to complete the assigned work; there will be differences, however, in some aspects (such as installing software), particularly if you use a distribution not based on Ubuntu or Debian.

==Contributing Notes==

The instructions and guidelines for contributing notes to the wiki can be [[Contributing:Operating_Systems_(Fall_2017)|found here]].

Contributing:Operating Systems (Fall 2017)

2017-09-29T22:00:52Z

Jagger: Add extra steps on how to make an account, some other rephrasing

=Contributing Notes=

Extra credit is available for students who contribute lecture notes to the class wiki. You can earn up to an additive 4% bonus to your final grade by contributing notes and improving existing notes.

==How to contribute==
First you need to create an account to edit the wiki. [[Operating_Systems_(Fall_2017)_Course_Outline#Course_Information|Email Jagger De Leo or Anil Somayaji]] to have one of us make an account for you.

Please provide the following information:
* Your full name
* Desired username (to see if it's available, check the user page ''homeostasis.scs.carleton.ca/wiki/index.php/User:'''<USERNAME>''''')
* An email address (so you can reset your password)

Then, after your are sent your temporary password and set a new one, you can log in and click the edit button on the lecture page you want to contribute to. (''example: [[Operating_Systems_2017F_Lecture_1|Lecture 1]]'')

==What to contribute==
* Bullet point summaries of topics covered in class
* Code samples from class plus comments or extra explanation
* Time marks to important points in lecture audio/videos
* Links to reliable supplementary information (e.g. page numbers in ''Operating Systems: Three Easy Pieces'')

'''Important''': read up on how Mediawiki formatting works before editing, and use the ''Show Preview'' button before saving your edits.

==How do I get my bonus marks?==
TAs will be monitoring your changes and will see what you have added. If you make significant contributions that do not need to be edited or improved, you will get roughly 1% per lecture. Large contributions that need some small edits will get you somewhere between 0.5% and 1% bonus. Good smaller edits and contributions will get you around 0.5%. Things like fixing typos and formatting are appreciated but are not worth any extra marks. Bonus marks are granted at the TA's discretion and will show up in CuLearn.

If you're not sure if something is appropriate to be added to the wiki, or you have a question about the bonus marks, ask a TA.

User:Jagger

2017-09-29T19:23:18Z

Jagger: Created page with "[https://www.jagger.co jagger.co]"

[https://www.jagger.co jagger.co]

Contributing:Operating Systems (Fall 2017)

2017-09-28T16:08:31Z

Jagger: link to example

=Contributing Notes=

Extra credit is available for students who contribute lecture notes to the class wiki. You can earn up to an additive 4% bonus to your final grade by contributing notes and improving existing notes.

==How to contribute==
First you need to create an account to edit the wiki. Email Jagger De Leo or Anil Somayaji to have an account made for you.

Then, you can log in and click the edit button on the lecture page you want to contribute to. (''example: [[Operating_Systems_2017F_Lecture_1|Lecture 1]]'')

==What to contribute==
* Bullet point summaries of topics covered in class
* Code samples from class plus comments or extra explanation
* Time marks to important points in lecture audio/videos
* Links to reliable supplementary information (e.g. page numbers in ''Operating Systems: Three Easy Pieces'')

'''Important''': read up on how Mediawiki formatting works before editing, and use the ''Show Preview'' button before saving your edits.

==How do I get my bonus marks?==
TAs will be monitoring your changes and will see what you have added. If you make significant contributions that do not need to be edited or improved, you will get roughly 1% per lecture. Large contributions that need some small edits will get you somewhere between 0.5% and 1% bonus. Good smaller edits and contributions will get you around 0.5%. Things like fixing typos and formatting are appreciated but are not worth any extra marks. Bonus marks are granted at the TA's discretion and will show up in CuLearn.

If you're not sure if something is appropriate to be added to the wiki, or you have a question about the bonus marks, ask a TA.

Contributing:Operating Systems (Fall 2017)

2017-09-28T16:05:53Z

Jagger: /* Contributing Notes */

=Contributing Notes=

Extra credit is available for students who contribute lecture notes to the class wiki. You can earn up to an additive 4% bonus to your final grade by contributing notes and improving existing notes.

==How to contribute==
First you need to create an account to edit the wiki. Email Jagger De Leo or Anil Somayaji to have an account made for you.

Then log in and hit the edit button on the lecture page you want to contribute to.

==What to contribute==
* Bullet point summaries of topics covered in class
* Code samples from class plus comments or extra explanation
* Time marks to important points in lecture audio/videos
* Links to reliable supplementary information (e.g. page numbers in ''Operating Systems: Three Easy Pieces'')

'''Important''': read up on how Mediawiki formatting works before editing, and use the ''Show Preview'' button before saving your edits.

==How do I get my bonus marks?==
TAs will be monitoring your changes and will see what you have added. If you make significant contributions that do not need to be edited or improved, you will get roughly 1% per lecture. Large contributions that need some small edits will get you somewhere between 0.5% and 1% bonus. Good smaller edits and contributions will get you around 0.5%. Things like fixing typos and formatting are appreciated but are not worth any extra marks. Bonus marks are granted at the TA's discretion and will show up in CuLearn.

If you're not sure if something is appropriate to be added to the wiki, or you have a question about the bonus marks, ask a TA.

Operating Systems (Fall 2017)

2017-09-28T16:03:26Z

Jagger: Add link to Contributing:Operating_Systems_(Fall_2017)

==Course Outline==

[[Operating Systems (Fall 2017) Course Outline|Here]] is the course outline for COMP 3000: Operating Systems.

==Lectures and Exams==

Note that the topics below are primarily chapters from the class textbook, [http://pages.cs.wisc.edu/~remzi/OSTEP/ Operating Systems: Three Easy Pieces]. Note that while introductory and summary dialogues are not linked below, they are worth reading for an informal take on the material.

The guidelines for contribution to the wiki can be [[Contributing:Operating_Systems_(Fall_2017)|found here]].

Assigned readings are subject to change, please check this page each week.

<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Date
</th>
<th>
Topic
</th>
</tr>
<tr>
<td>
Sept. 7

</td>
<td>
[[Operating Systems 2017F Lecture 1|Lecture 1]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/intro.pdf Introduction]

</td>
</tr>
<tr>
<td>
Sept. 12

</td>
<td>
[[Operating Systems 2017F Lecture 2|Lecture 2]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-intro.pdf Processes], [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-api.pdf Process API]

</td>
</tr>
<tr>
<td>
Sept. 14

</td>
<td>
[[Operating Systems 2017F Lecture 3|Lecture 3]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-mechanisms.pdf Limited Direct Execution], [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-sched.pdf CPU Scheduling], [http://pages.cs.wisc.edu/~remzi/OSTEP/cpu-sched-mlfq.pdf MLFQ] 
</td>
</tr>
<tr>
<td>
Sept. 19

</td>
<td>
[[Operating Systems 2017F Lecture 4|Lecture 4]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-intro.pdf Address Spaces], [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-api.pdf Memory API]

</td>
</tr>
<tr>
<td>
Sept. 21

</td>
<td>
[[Operating Systems 2017F Lecture 5|Lecture 5]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/file-disks.pdf Hard Disk Drives], [http://pages.cs.wisc.edu/~remzi/OSTEP/file-intro.pdf File and Directories]

</td>
</tr>
<tr>
<td>
Sept. 26

</td>
<td>
[[Operating Systems 2017F Lecture 6|Lecture 6]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/file-devices.pdf I/O Devices], [http://pages.cs.wisc.edu/~remzi/OSTEP/file-journaling.pdf FSCK and Journaling]

</td>
</tr>
<tr>
<td>
Sept. 28

</td>
<td>
[[Operating Systems 2017F Lecture 7|Lecture 7]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/file-implementation.pdf File System Implementation]
</td>
</tr>
<tr>
<td>
Oct. 3

</td>
<td>
[[Operating Systems 2017F Lecture 8|Lecture 8]]: Assignment/Tutorial help session (Akhil)
</td>
</tr>
<tr>
<td>
Oct. 5

</td>
<td>
[[Operating Systems 2017F Lecture 9|Lecture 9]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-intro.pdf Concurrency and Threads], [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-locks.pdf Locks]
</td>
</tr>
<tr>
<td>
Oct. 10

</td>
<td>
[[Operating Systems 2017F Lecture 10|Lecture 10]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-locks-usage.pdf Concurrent Data Structures], [http://pages.cs.wisc.edu/~remzi/OSTEP/threads-sema.pdf Semaphores]

</td>
</tr>
<tr>
<td>
Oct. 12

</td>
<td>
[[Operating Systems 2017F Lecture 11|Lecture 11]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-mechanism.pdf Address Translation], [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-tlbs.pdf TLBs]
</td>
</tr>
<tr>
<td>
Oct. 17

</td>
<td>
[[Operating Systems 2017F Lecture 12|Lecture 12]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-segmentation.pdf Segmentation], [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-freespace.pdf Free space management]
</td>
</tr>
<tr>
<td>
Oct. 19

</td>
<td>
[[Operating Systems 2017F Lecture 13|Lecture 13]]: [http://pages.cs.wisc.edu/~remzi/OSTEP/vm-paging.pdf Paging]
</td>
</tr>
<tr>
<td>
Oct. 31

</td>
<td>
[[Operating Systems 2017F Lecture 14|Lecture 14]]: Midterm Review
</td>
</tr>
<tr>
<td>
Nov. 2

</td>
<td>
[[Operating Systems 2017F Lecture 15|Lecture 15]]: Midterm Exam

</td>
</tr>
<tr>
<td>
Nov. 7

</td>
<td>
[[Operating Systems 2017F Lecture 16|Lecture 16]]

</td>
</tr>
<tr>
<td>
Nov. 9

</td>
<td>
[[Operating Systems 2017F Lecture 17|Lecture 17]]

</td>
</tr>
<tr>
<td>
Nov. 14

</td>
<td>
[[Operating Systems 2017F Lecture 18|Lecture 18]]

</td>
</tr>
<tr>
<td>
Nov. 16

</td>
<td>
[[Operating Systems 2017F Lecture 19|Lecture 19]]

</td>
</tr>
<tr>
<td>
Nov. 21

</td>
<td>
[[Operating Systems 2017F Lecture 20|Lecture 20]]

</td>
</tr>
<tr>
<td>
Nov. 23

</td>
<td>
[[Operating Systems 2017F Lecture 21|Lecture 21]]: TBD (US Thanksgiving)

</td>
</tr>
<tr>
<td>
Nov. 28

</td>
<td>
[[Operating Systems 2017F Lecture 22|Lecture 22]]

</td>
</tr>
<tr>
<td>
Nov. 30

</td>
<td>
[[Operating Systems 2017F Lecture 23|Lecture 23]]

</td>
</tr>
<tr>
<td>
Dec. 5

</td>
<td>
[[Operating Systems 2017F Lecture 24|Lecture 24]]

</td>
</tr>
<tr>
<td>
Dec. 7

</td>
<td>
[[Operating Systems 2017F Lecture 25|Lecture 25]]

</td>
</tr>
</table>

==Tutorials==

Each week you will get a progress grade from 0-4, given to you by a TA. If you are being diligent, you should be able to get 4's every week. The easiest way to get your grade is to come to tutorial and meet with your TA; alternately, you can meet a TA in their office hours or, at their discretion, discuss things with them online.

<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Date
</th>
<th>
Tutorials
</th>
</tr>
<tr>
<td>
Sept. 18,20

</td>
<td>
[[Operating Systems 2017F: Tutorial 1|Processes and System Calls]]

</td>
</tr>
<tr>
<td>
Sept. 25, 27

</td>
<td>
[[Operating Systems 2017F: Tutorial 2|3000shell.c]]

</td>
</tr>
<tr>
<td>
Oct. 2, 4

</td>
<td>
[[Operating Systems 2017F: Tutorial 3|TBA]]

</td>
</tr>
<tr>
<td>
Oct. 16, 18

</td>
<td>
[[Operating Systems 2017F: Tutorial 4|TBA]]

</td>
</tr>
<tr>
<td>
Nov. 6, 8

</td>
<td>
[[Operating Systems 2017F: Tutorial 5|TBA]]

</td>
</tr>
<tr>
<td>
Nov. 13, 15

</td>
<td>
[[Operating Systems 2017F: Tutorial 6|TBA]]

</td>
</tr>
<tr>
<td>
Nov. 20, 22

</td>
<td>
[[Operating Systems 2017F: Tutorial 7|TBA]]

</td>
</tr>
<tr>
<tr>
<td>
Nov. 27, 29

</td>
<td>
[[Operating Systems 2017F: Tutorial 8|TBA]]

</td>
</tr>
</table>

==Assignments==
<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Due Date
</th>
<th>
Assignments
</th>
</tr>
<tr>
<td>
Oct. 9

</td>
<td>
[[Operating Systems 2017F: Assignment 1|Assignment 1]]

</td>
</tr>
<tr>
<td>
Oct. 23

</td>
<td>
[[Operating Systems 2017F: Assignment 2|Assignment 2]]

</td>
</tr>
<tr>
<td>
Nov. 20

</td>
<td>
[[Operating Systems 2017F: Assignment 3|Assignment 3]]

</td>
</tr>
<tr>
<td>
Dec. 4

</td>
<td>
[[Operating Systems 2017F: Assignment 4|Assignment 4]]

</td>
</tr>
</table>

==Course Software==

In this course we will primarily working with [http://www.ubuntu.com/ Ubuntu], a widely-used family of Linux distributions. We will be using Ubuntu Server on the SCS's [http://openstack.scs.carleton.ca/ Openstack installation] (accessible only from the Carleton network).

You may use other Linux distributions to complete the assigned work; there will be differences, however, in some aspects (such as installing software), particularly if you use a distribution not based on Ubuntu or Debian.

Contributing:Operating Systems (Fall 2017)

2017-09-28T15:55:02Z

Jagger: Initial creation

=Contributing Notes=

Extra credit is available for students who contribute lecture notes to the class wiki. You can earn up to an additive 4% bonus to your final grade.

==How to contribute==
First you need to create an account to edit the wiki. Email Jagger De Leo or Anil Somayaji to have an account made for you.

Then log in and hit the edit button on the lecture page you want to contribute to.

==What to contribute==
* Bullet point summaries of topics covered in class
* Code samples from class plus comments or extra explanation
* Time marks to important points in lecture audio/videos
* Links to reliable supplementary information (e.g. page numbers in ''Operating Systems: Three Easy Pieces'')

'''Important''': read up on how Mediawiki formatting works before editing, and use the ''Show Preview'' button before saving your edits.

==How do I get my bonus marks?==
TAs will be monitoring your changes and will see what you have added. If you make significant contributions that do not need to be edited or improved, you will get roughly 1% per lecture. Large contributions that need some small edits will get you somewhere between 0.5% and 1% bonus. Good smaller edits and contributions will get you around 0.5%. Things like fixing typos and formatting are appreciated but are not worth any extra marks. Bonus marks are granted at the TA's discretion and will show up in CuLearn.

If you're not sure if something is appropriate to be added to the wiki, or you have a question about the bonus marks, ask a TA.

Operating Systems 2017F Lecture 1

2017-09-28T04:56:04Z

Jagger: Add notes (thanks Shaun!)

==Audio==

Audio from the lecture given on September 7, 2017 [http://homeostasis.scs.carleton.ca/~soma/os-2017f/lectures/comp3000-2017f-lec01-07Sep2017.m4a is now available].

==Notes==
''The following notes are based on those provided by a student. They do not necessarily cover all material. If you think something is missing, let us know!''
==== What is an Operating System (OS)? ====

* Resource Manager for all applications.
* Abstracts the hardware and provides an easy way for programs to access the virtualized hardware

====Where did Operating Systems begin?====
* Started in the 60's when mainframes became popular

====What is the goal of an Operating System?====
* Facilitates the sharing of resources (Hard disks, CPU, RAM, etc.) among many concurrent programs.
* Uses time slices to allocate resources and enforces usage rules so programs don't hog 100% of the available resources. Time was equivalent to cash during early computing.
* Store files persistently[[#ref1|1]]
* Handle problems related to concurrency (multiple programs running at the same time).[[#ref1|1]]

===Architecture===
* Kernel:
** This is the first program that launches when we turn on a computer. The kernel provides the hardware abstraction and is the part of the operating system that dictates how the hardware is managed and accessed. The Kernel has absolute power over the hardware.
** The kernel controls program execution, for example with signals
*** Kill: stops execution immediately
*** Terminate: allows the program to stop gracefully
*** Stop: pauses execution
*** Continue: resumes execution
* Hypervisor:
** A Kernel that manages other kernels. An operating system may have several kernels that perform specific tasks; a hypervisor manages these kernels.
* Processes (An executable):
** One or more threads plus address space
** A thread is a function that runs in the same memory space as other functions
* Memory:
** A contiguous array of bytes. Every byte has a physical address.
** On modern machines, memory is virtualized so that it can be divided into segments. All of the segments are mapped to the physical memory space.
** Every time an operation occurs the memory map (MMU) is consulted.
** Each program is given a segment of memory; this is called virtual memory. All of the programs share the same physical memory.
* Interrupts:
** Allows the kernel to interrupt the CPU when other tasks take priority. The kernel uses a table to manage the various types of interrupts available. One example is a timer interrupt, it determines CPU time usage.
* Signals:
** Inter-Process communication; How the kernel communicates with a process.
** Can be initiated by the kernel or sent by programs to control other processes.
* System Calls:
** Special calls to the kernel. This is how the application asks for more resources.
** Not a function call, though higher level languages may wrap them in convenience functions.
** When called, transfer control to the OS and raises the hardware privilege level[[#ref1|1]]

==References==
1. Arpaci-Dusseau, Operating Systems: Three Easy Pieces, ''Introduction'', p. 11-13 http://pages.cs.wisc.edu/~remzi/OSTEP/intro.pdf

Operating Systems 2017F: Tutorial 1

2017-09-20T17:02:45Z

Jagger: Fix small typo: execp to execvp

In this tutorial you will be learning about 1) the difference between system calls, function calls, and library calls and 2) how processes are created.

==Getting started==

To do the following exercises, bring up a terminal on a system running Linux, preferably Ubuntu Linux 16.04.

For further help, please talk to the TAs in your lab.

Local copies of Ubuntu Linux 16.04 [http://homeostasis.scs.carleton.ca/~soma/os-2017f/ubuntu-16.04.3-desktop-amd64.iso Desktop] and [http://homeostasis.scs.carleton.ca/~soma/os-2017f/ubuntu-16.04.3-server-amd64.iso Server] are available. Download the Desktop version if you have a fast enough machine and want to use a GUI. If your machine is slower, download the Server version, it is smaller and will take fewer resources (but only has a text interface by default).

==Function calls, library calls, and system calls==

For [http://homeostasis.scs.carleton.ca/~soma/os-2017f/code/tut1/hello.c hello.c], [http://homeostasis.scs.carleton.ca/~soma/os-2017f/code/tut1/syscall-hello.c syscall-hello.c], and later [http://homeostasis.scs.carleton.ca/~soma/os-2017f/code/tut1/csimpleshell.c csimpleshell.c] (after you've done the part below on csimpleshell) do the following (substituting the appropriate source file for prog.c):
# Compile the program prog.c using <tt>gcc -O2 prog.c -o prog-dyn</tt> and run prog-dyn. What does it do?
# Statically compile and optimize prog.c by running <tt>gcc -O2 -static prog.c -o prog-static</tt>. How does the size compare with <tt>prog</tt>?
# See what system calls prog-static produces by running <tt>strace -o syscalls-static.log ./prog-static</tt>. Do the same for <tt>prog-dyn</tt>. Which version generates more system calls?
# See what library calls prog-static produces by running <tt>ltrace -o library-static.log ./prog-static</tt>. Do the same for <tt>prog-dyn</tt>. Which version generates more library calls? (If ltrace isn't installed, run <tt>sudo apt-get install ltrace</tt>)
# Using the <tt>nm</tt> command, see what symbols are defined in prog-static and prog-dyn.
# Run the command <tt>gcc -c -O2 prog.c</tt> to produce an object file. What file was produced? What symbols does it define?
# Look at the assembly code of the program by running <tt>gcc -S -O2 prog.c</tt>. What file was produced? Identify the following:
#* A function call
#* A system call (if any)
#* A global/static variable (if any)
#* A local variable
# Disassemble the object file using <tt>objdump -d</tt>. How does this disassembly compare with the output from gcc -S?
# Examine the headers of object file, dynamically linked executable, and the statically linked executable using <tt>objdump -h</tt>
# Examine the contents of object file, dynamically linked executable, and the statically linked executable using <tt>objdump -s</tt>
# Re-run all of the previous gcc commands adding the "-v" flag. What is all of that output?
# (optional) Look up the documentation for each of the system calls made by the static versions of the programs. You may need to append a 2 or 3 to the manpage invocation, e.g. "man 2 write" gets you the write system call documentation.

==Creating processes, running executables==

For this part you will be playing with and modifying [http://homeostasis.scs.carleton.ca/~soma/os-2017f/code/tut1/csimpleshell.c csimpleshell.c] by [https://web.archive.org/web/20170223203852/http://rik0.altervista.org/snippets/csimpleshell.html Enrico Franchi]. The source is also listed below.

# In csimpleshell, change the prompt to be the current user (e.g., "student $"), as reported by the USER environment variable.
# Make csimpleshell not call <tt>wait()</tt> on the command if there is an & as the last argument to a command; instead, just return another prompt. Can you see the zombies that are now produced?
# Change the <tt>execvp()</tt> call to [http://pubs.opengroup.org/onlinepubs/9699919799/functions/execve.html execve()]. Where do you get the extra argument? (NOTE: When you switch to execve() you will have to specify the full path to commands, e.g. /bin/ls not ls.)
# Add an environment variable called LASTCOMMAND that contains the last command that was executed by csimpleshell. This environment variable should be passed on to each new program that is run. How can you check that your code works?
# Use [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sigaction.html sigaction()] and [http://pubs.opengroup.org/onlinepubs/9699919799/functions/wait.html waitpid()] to create a signal handler for SIGCHLD that prevents the creation of zombies for background commands.
# (Advanced) Implement I/O redirection for STDIN (<) and STDOUT (>). Do the same for arbitrary file descriptors (e.g., 2>).

==Code==

===hello.c===
<source lang="c">
#include <stdio.h>

int main(int argc, char *argv[]) {

printf("Hello world!\n");

return 0;
}
</source>

===syscall-hello.c===
<source lang="c">
#include <unistd.h>
#include <sys/syscall.h>

char *buf = "Hello world!\n";

int main(int argc, char *argv) {
size_t result;

/* "man 2 write" to see arguments to write syscall */
result = syscall(SYS_write, 1, buf, 13);

return (int) result;
}
</source>

===csimpleshell.c===
<source line lang="C">
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#define BUFFER_SIZE 1<<16
#define ARR_SIZE 1<<16

void parse_args(char *buffer, char** args,
size_t args_size, size_t *nargs)
{
char *buf_args[args_size]; /* You need C99 */
char **cp;
char *wbuf;
size_t i, j;

wbuf=buffer;
buf_args[0]=buffer;
args[0] =buffer;

for(cp=buf_args; (*cp=strsep(&wbuf, " \n\t")) != NULL ;){
if ((*cp != '\0') && (++cp >= &buf_args[args_size]))
break;
}

for (j=i=0; buf_args[i]!=NULL; i++){
if(strlen(buf_args[i])>0)
args[j++]=buf_args[i];
}

*nargs=j;
args[j]=NULL;
}

int main(int argc, char *argv[], char *envp[]){
char buffer[BUFFER_SIZE];
char *args[ARR_SIZE];

int *ret_status;
size_t nargs;
pid_t pid;

while(1){
printf("$ ");
fgets(buffer, BUFFER_SIZE, stdin);
parse_args(buffer, args, ARR_SIZE, &nargs);

if (nargs==0) continue;
if (!strcmp(args[0], "exit" )) exit(0);
pid = fork();
if (pid){
printf("Waiting for child (%d)\n", pid);
pid = wait(ret_status);
printf("Child (%d) finished\n", pid);
} else {
if( execvp(args[0], args)) {
puts(strerror(errno));
exit(127);
}
}
}
return 0;
}
</source>

Operating Systems (Fall 2017) Course Outline

2017-09-18T14:54:05Z

Jagger:

==Course Information==

*'''Course Number:''' COMP 3000
*'''Term:''' Fall 2017
*'''Title:''' Operating Systems
*'''Institution:''' Carleton University, School of Computer Science
*'''Instructor:''' [http://people.scs.carleton.ca/~soma Anil Somayaji] (anil.somayaji at carleton.ca): Mon., Wed. 2:30-3:30 PM in HP 5137
*'''Teaching Assistants:''' (in new TA room 4125 HP)
**Jean-Elie Jean-Gilles (jeaneliejeangilles at cmail.carleton.ca): Tuesday and Thursday 2:30-3:30 PM
**Jagger De Leo (jagger.deleo at carleton.ca): Wed. 3:30-4:30 PM, Fri. 10:00-11:00 AM
**Yuting Wang (yvonnewang at cmail.carleton.ca): Tuesday and Wednesday 11:30-12:30 AM
*'''Lectures:''' Tues. and Thurs. 1:05-2:25 PM in AT 102
*'''Tutorials (in HP 4155):''' Monday 11:35-12:55 PM Monday 1:05-2:25 PM Wednesday 8:35-9:55 AM
*'''Course Website''': http://homeostasis.scs.carleton.ca/wiki/index.php/Operating_Systems_%28Fall_2017%29

==Official Course Description==

Operating system implementation course stressing fundamental issues in design and how they relate to modern computer architectures. Assignments involve the modification and extension of a multitasking operating system.

==Learning Outcomes==

By the end of this course, students should:
* be able to write C code that uses low-level Linux services and should be able to implement simple Linux kernel extensions (modules),
* have a strong conceptual model of how an operating system works that allows them to determine the relative role of application and operating system code when debugging software, and
* understand the basic use and architecture of virtual-machine based cloud architectures.

Note that in order to achieve these objectives students should have come into this course with a strong background in C programming and general application development.

==Grading==

The marking scheme for this course is:

* 20% for tutorial participation
* 20% for the assignments
* 25% for the midterm on November 2 (Thursday) during class
* 35% for the final exam (date TBA)

I also calculate grades using alternative marking schemes at the end of the semester, assigning the highest grade for each student from any of the marking schemes. Thus your final grade may be higher than might be suggested by strict following of the above scheme.

==Communication==

This wiki page is the canonical source of information on this course. Please refer to it for updates. When significant changes are made to this document it will be either announced in lecture and/or posted in the course discussion forum.

Course discussions will be on [https://culearn.carleton.ca cuLearn]. While you may discuss assignments there, do not post outright answers to them. You may post in either the Questions and Answers forum or the General Discussion forum.

You may get an account on class wiki so you can edit content there. Email Prof. Somayaji to get one with your preferred username and email address to which a password should be sent. (Note this is not a requirement.)

==Collaboration==

Collaboration on all work is allowed except for the two tests. Collaboration, however, should be clearly acknowledged.

For assignments, while you may get help from others and even collaboratively solve technical problems, the code and answers submitted should all be your own work. For example, you may not divide an assignment into parts, give a part to another student or anyone else to solve, and then submit that work as your own. You have to have participated in the creation of every part of your submitted work. An easy way to make sure this happens is never share files regarding coursework or copy and paste answers into email. Instead, meet together to work on an assignment and then separate to write up your solutions.

The final project may be a group project, but again there it should be clearly documented what contribution was made by each group member.

Similarity between submitted assignments and projects that has not been appropriately documented will be treated as plagiarism - the same as copying on a midterm or a final - and will be submitted to the Dean for disciplinary action.

==Course Notes/Multimedia==

Audio and sometimes video from lectures will be available via the [[Operating Systems (Fall 2017)|lecture pages on the main course website]]. These same pages will also contain notes.

Do not rely upon the lectures and notes to cover all material related to this class. You are expected to keep up with the assigned textbook readings and material covered in the tutorials.

==Required Textbooks==

The course will be using the textbook [http://pages.cs.wisc.edu/~remzi/OSTEP/ Operating Systems: Three Easy Pieces]. The chapters of this textbook are available for free online; you can also buy a full epub, PDF, or paper copy if you wish.

Individual chapters will be linked with the lectures associated with them. You should plan on reading the assigned chapters '''before''' coming to class, as the material in lectures will be easier to understand then. The lectures are designed to supplement the textbook, not replace them.

==Course Software==

In this course we will primarily working with [http://www.lubuntu.net/ Lubuntu], a low-resource variant of [http://www.ubuntu.com/ Ubuntu] Linux distribution. You may use other Linux distributions in the tutorials to complete the assigned work; there will be differences, however, in some aspects (such as installing software), particularly if you use a distribution not based on Ubuntu or Debian.

==University Policies & Resources==

===Undergraduate Academic Advisor===

The undergraduate advisor for the School of Computer Science is available in Room
5302C HP, by telephone at 520-2600, ext. 4364 or by email at
undergraduate_advisor@scs.carleton.ca. The advisor can assist with information about
prerequisites and preclusions, course substitutions/equivalencies, understanding your
academic audit and the remaining requirements for graduation. The undergraduate
advisor will also refer students to appropriate resources such as the Science Student
Success Centre, Learning Support Services and the Writing Tutorial Services.

===Student Academic Integrity Policy===

Every student should be familiar with the Carleton University student academic integrity policy. A student found in violation of academic integrity standards may be awarded penalties which range from a reprimand to receiving a grade of F in the course or even being expelled from the program or University. Some examples of offences are: plagiarism and unauthorized co-operation or collaboration. Information on this policy may be found in the Undergraduate Calendar.

===Plagiarism===

As defined by Senate, "plagiarism is presenting, whether intentional or not, the ideas, expression of ideas or work of others as one's own". Such reported offences will be reviewed by the office of the Dean of Science.

===Unauthorized Co-operation or Collaboration===

Senate policy states that "to ensure fairness and equity in assessment of term work, students shall not co-operate or collaborate in the completion of an academic assignment, in whole or in part, when the instructor has indicated that the assignment is to be completed on an individual basis".

Please see above for the specific collaboration policy for this course.

===Academic Accommodations for Students with Disabilities===

The Paul Menton Centre for Students with Disabilities (PMC) provides services to students with Learning Disabilities (LD), psychiatric/mental health disabilities, Attention Deficit Hyperactivity Disorder (ADHD), Autism Spectrum Disorders (ASD), chronic medical conditions, and impairments in mobility, hearing, and vision. If you have a disability requiring academic accommodations in this course, please contact PMC at 613-520-6608 or pmc@carleton.ca for a formal evaluation. If you are already registered with the PMC, contact your PMC coordinator to send me your Letter of Accommodation at the beginning of the term, and no later than two weeks before the first in-class scheduled test or exam requiring accommodation (if applicable). After requesting accommodation from PMC, meet with me to ensure accommodation arrangements are made. Please consult the PMC website for the deadline to request accommodations for the formally-scheduled exam (if applicable) at https://www.carleton.ca/pmc/new-and-current-students/dates-and-deadlines

===Religious Obligation===

Write to the instructor with any requests for academic accommodation during the first two weeks of class, or as soon as possible after the need for accommodation is known to exist. For more details visit the Equity Services website: https://www.carleton.ca/equity/

===Pregnancy Obligation===

Write to the instructor with any requests for academic accommodation during the first two weeks of class, or as soon as possible after the need for accommodation is known to exist. For more details visit the Equity Services website: https://www.carleton.ca/equity/

===Medical Certificate===

The following is a link to the official medical certificate accepted by Carleton University for the deferral of final examinations or assignments in undergraduate courses. To access the form, please go to https://www.carleton.ca/registrar/forms

Operating Systems (Fall 2017) Course Outline

2017-09-18T14:50:28Z

Jagger:

==Course Information==

*'''Course Number:''' COMP 3000
*'''Term:''' Fall 2017
*'''Title:''' Operating Systems
*'''Institution:''' Carleton University, School of Computer Science
*'''Instructor:''' [http://people.scs.carleton.ca/~soma Anil Somayaji] (anil.somayaji at carleton.ca): Mon., Wed. 2:30-3:30 PM in HP 5137
*'''Teaching Assistants:''' (in new TA room 4125 HP) Jean-Elie Jean-Gilles (jeaneliejeangilles at cmail.carleton.ca): Tuesday and Thursday 2:30-3:30 PM Jagger De Leo (jagger.deleo at carleton.ca): Wed. 3:30-4:30 PM, Fri. 10:00-11:00 AM 
*'''Lectures:''' Tues. and Thurs. 1:05-2:25 PM in AT 102
*'''Tutorials (in HP 4155):''' Monday 11:35-12:55 PM Monday 1:05-2:25 PM Wednesday 8:35-9:55 AM
*'''Course Website''': http://homeostasis.scs.carleton.ca/wiki/index.php/Operating_Systems_%28Fall_2017%29

==Official Course Description==

Operating system implementation course stressing fundamental issues in design and how they relate to modern computer architectures. Assignments involve the modification and extension of a multitasking operating system.

==Learning Outcomes==

By the end of this course, students should:
* be able to write C code that uses low-level Linux services and should be able to implement simple Linux kernel extensions (modules),
* have a strong conceptual model of how an operating system works that allows them to determine the relative role of application and operating system code when debugging software, and
* understand the basic use and architecture of virtual-machine based cloud architectures.

Note that in order to achieve these objectives students should have come into this course with a strong background in C programming and general application development.

==Grading==

The marking scheme for this course is:

* 20% for tutorial participation
* 20% for the assignments
* 25% for the midterm on November 2 (Thursday) during class
* 35% for the final exam (date TBA)

I also calculate grades using alternative marking schemes at the end of the semester, assigning the highest grade for each student from any of the marking schemes. Thus your final grade may be higher than might be suggested by strict following of the above scheme.

==Communication==

This wiki page is the canonical source of information on this course. Please refer to it for updates. When significant changes are made to this document it will be either announced in lecture and/or posted in the course discussion forum.

Course discussions will be on [https://culearn.carleton.ca cuLearn]. While you may discuss assignments there, do not post outright answers to them. You may post in either the Questions and Answers forum or the General Discussion forum.

You may get an account on class wiki so you can edit content there. Email Prof. Somayaji to get one with your preferred username and email address to which a password should be sent. (Note this is not a requirement.)

==Collaboration==

Collaboration on all work is allowed except for the two tests. Collaboration, however, should be clearly acknowledged.

For assignments, while you may get help from others and even collaboratively solve technical problems, the code and answers submitted should all be your own work. For example, you may not divide an assignment into parts, give a part to another student or anyone else to solve, and then submit that work as your own. You have to have participated in the creation of every part of your submitted work. An easy way to make sure this happens is never share files regarding coursework or copy and paste answers into email. Instead, meet together to work on an assignment and then separate to write up your solutions.

The final project may be a group project, but again there it should be clearly documented what contribution was made by each group member.

Similarity between submitted assignments and projects that has not been appropriately documented will be treated as plagiarism - the same as copying on a midterm or a final - and will be submitted to the Dean for disciplinary action.

==Course Notes/Multimedia==

Audio and sometimes video from lectures will be available via the [[Operating Systems (Fall 2017)|lecture pages on the main course website]]. These same pages will also contain notes.

Do not rely upon the lectures and notes to cover all material related to this class. You are expected to keep up with the assigned textbook readings and material covered in the tutorials.

==Required Textbooks==

The course will be using the textbook [http://pages.cs.wisc.edu/~remzi/OSTEP/ Operating Systems: Three Easy Pieces]. The chapters of this textbook are available for free online; you can also buy a full epub, PDF, or paper copy if you wish.

Individual chapters will be linked with the lectures associated with them. You should plan on reading the assigned chapters '''before''' coming to class, as the material in lectures will be easier to understand then. The lectures are designed to supplement the textbook, not replace them.

==Course Software==

In this course we will primarily working with [http://www.lubuntu.net/ Lubuntu], a low-resource variant of [http://www.ubuntu.com/ Ubuntu] Linux distribution. You may use other Linux distributions in the tutorials to complete the assigned work; there will be differences, however, in some aspects (such as installing software), particularly if you use a distribution not based on Ubuntu or Debian.

==University Policies & Resources==

===Undergraduate Academic Advisor===

The undergraduate advisor for the School of Computer Science is available in Room
5302C HP, by telephone at 520-2600, ext. 4364 or by email at
undergraduate_advisor@scs.carleton.ca. The advisor can assist with information about
prerequisites and preclusions, course substitutions/equivalencies, understanding your
academic audit and the remaining requirements for graduation. The undergraduate
advisor will also refer students to appropriate resources such as the Science Student
Success Centre, Learning Support Services and the Writing Tutorial Services.

===Student Academic Integrity Policy===

Every student should be familiar with the Carleton University student academic integrity policy. A student found in violation of academic integrity standards may be awarded penalties which range from a reprimand to receiving a grade of F in the course or even being expelled from the program or University. Some examples of offences are: plagiarism and unauthorized co-operation or collaboration. Information on this policy may be found in the Undergraduate Calendar.

===Plagiarism===

As defined by Senate, "plagiarism is presenting, whether intentional or not, the ideas, expression of ideas or work of others as one's own". Such reported offences will be reviewed by the office of the Dean of Science.

===Unauthorized Co-operation or Collaboration===

Senate policy states that "to ensure fairness and equity in assessment of term work, students shall not co-operate or collaborate in the completion of an academic assignment, in whole or in part, when the instructor has indicated that the assignment is to be completed on an individual basis".

Please see above for the specific collaboration policy for this course.

===Academic Accommodations for Students with Disabilities===

The Paul Menton Centre for Students with Disabilities (PMC) provides services to students with Learning Disabilities (LD), psychiatric/mental health disabilities, Attention Deficit Hyperactivity Disorder (ADHD), Autism Spectrum Disorders (ASD), chronic medical conditions, and impairments in mobility, hearing, and vision. If you have a disability requiring academic accommodations in this course, please contact PMC at 613-520-6608 or pmc@carleton.ca for a formal evaluation. If you are already registered with the PMC, contact your PMC coordinator to send me your Letter of Accommodation at the beginning of the term, and no later than two weeks before the first in-class scheduled test or exam requiring accommodation (if applicable). After requesting accommodation from PMC, meet with me to ensure accommodation arrangements are made. Please consult the PMC website for the deadline to request accommodations for the formally-scheduled exam (if applicable) at https://www.carleton.ca/pmc/new-and-current-students/dates-and-deadlines

===Religious Obligation===

Write to the instructor with any requests for academic accommodation during the first two weeks of class, or as soon as possible after the need for accommodation is known to exist. For more details visit the Equity Services website: https://www.carleton.ca/equity/

===Pregnancy Obligation===

Write to the instructor with any requests for academic accommodation during the first two weeks of class, or as soon as possible after the need for accommodation is known to exist. For more details visit the Equity Services website: https://www.carleton.ca/equity/

===Medical Certificate===

The following is a link to the official medical certificate accepted by Carleton University for the deferral of final examinations or assignments in undergraduate courses. To access the form, please go to https://www.carleton.ca/registrar/forms

Fundamentals of Web Applications (Winter 2016)

2016-01-15T20:55:08Z

Jagger: /* Course Software */

==Course Outline==

[[Fundamentals of Web Applications: Winter 2016 Course Outline|Here]] is the course outline.

==Lectures and Exams==

<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Date
</th>
<th>
Topic
</th>
</tr>
<tr>
<td>
Jan. 7

</td>
<td>
[[WebFund 2016W Lecture 1|Lecture 1]]

</td>
</tr>
<tr>
<td>
Jan. 12

</td>
<td>
[[WebFund 2016W Lecture 2|Lecture 2]]

</td>
</tr>
<tr>
<td>
Jan. 14

</td>
<td>
[[WebFund 2016W Lecture 3|Lecture 3]]

</td>
</tr>
<tr>
<td>
Jan. 19

</td>
<td>
[[WebFund 2016W Lecture 4|Lecture 4]]

</td>
</tr>
<tr>
<td>
Jan. 21

</td>
<td>
[[WebFund 2016W Lecture 5|Lecture 5]]

</td>
</tr>
<tr>
<td>
Jan. 26

</td>
<td>
[[WebFund 2016W Lecture 6|Lecture 6]]

</td>
</tr>
<tr>
<td>
Jan. 28

</td>
<td>
[[WebFund 2016W Lecture 7|Lecture 7]]

</td>
</tr>
<tr>
<td>
Feb. 2

</td>
<td>
[[WebFund 2016W Lecture 8|Lecture 8]]

</td>
</tr>
<tr>
<td>
Feb. 4

</td>
<td>
[[WebFund 2016W Lecture 9|Lecture 9]]

</td>
</tr>
<tr>
<td>
Feb. 9

</td>
<td>
[[WebFund 2016W Lecture 10|Midterm Review]]

</td>
</tr>
<tr>
<td>
Feb. 11

</td>
<td>
Midterm (in class)

</td>
</tr>
<tr>
<td>
Feb. 23

</td>
<td>
[[WebFund 2016W Lecture 11|Lecture 11]]

</td>
</tr>
<tr>
<td>
Feb. 25

</td>
<td>
[[WebFund 2016W Lecture 12|Lecture 12]]

</td>
</tr>
<tr>
<td>
Mar. 1

</td>
<td>
[[WebFund 2016W Lecture 13|Lecture 13]]

</td>
</tr>
<tr>
<td>
Mar. 3

</td>
<td>
[[WebFund 2016W Lecture 14|Lecture 14]]

</td>
</tr>
<tr>
<td>
Mar. 8

</td>
<td>
[[WebFund 2016W Lecture 15|Lecture 15]]

</td>
</tr>
<tr>
<td>
Mar. 10

</td>
<td>
[[WebFund 2016W Lecture 16|Lecture 16]]

</td>
</tr>
<tr>
<td>
Mar. 15

</td>
<td>
[[WebFund 2016W Lecture 17|Lecture 17]]

</td>
</tr>
<tr>
<td>
Mar. 17

</td>
<td>
[[WebFund 2016W Lecture 18|Lecture 18]]

</td>
</tr>
<tr>
<td>
Mar. 22

</td>
<td>
[[WebFund 2016W Lecture 19|Lecture 19]]

</td>
</tr>
<tr>
<td>
Mar. 24

</td>
<td>
[[WebFund 2016W Lecture 20|Lecture 20]]

</td>
</tr>
<tr>
<td>
Mar. 29

</td>
<td>
[[WebFund 2016W Lecture 21|Lecture 21]]

</td>
</tr>
<tr>
<td>
Mar. 31

</td>
<td>
[[WebFund 2016W Lecture 22|Lecture 22]]

</td>
</tr>
<tr>
<td>
Apr. 5

</td>
<td>
[[WebFund 2016W Lecture 23|Lecture 23]]

</td>
</tr>
<tr>
<td>
April 7

</td>
<td>
[[WebFund 2016W Lecture 24|Lecture 24]]

</td>
</tr>
<tr>
<td>
TBA

</td>
<td>
Final Exam

</td>
</tr>
</table>

==Tutorials==

Each week you will get a progress grade from 0-4, given to you by a TA. If you are being diligent, you should be able to get 4's every week. The easiest way to get your grade is to come to tutorial and meet with your TA; alternately, you can meet a TA in their office hours or, at their discretion, discuss things with them online.

<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Date
</th>
<th>
Tutorials
</th>
</tr>
<tr>
<td>
Jan. 13, 14, 15, 18

</td>
<td>
[[WebFund 2016W: Tutorial 1|Asynchronous Code in JavaScript]]

</td>
</tr>
<tr>
<td>
Jan. 20, 21, 22, 25

</td>
<td>
[[WebFund 2016W: Tutorial 2|Tiny web server]]

</td>
</tr>
<tr>
<td>
Jan. 27, 28, 29, Feb. 1

</td>
<td>
[[WebFund 2016W: Tutorial 3|Express, Form demo]]

</td>
</tr>
<tr>
<td>
Feb. 3, 4, 5, 8

</td>
<td>
[[WebFund 2016W: Tutorial 4|TBA]]

</td>
</tr>
<tr>
<td>
Feb. 24, 25, 26, 29

</td>
<td>
[[WebFund 2016W: Tutorial 5|TBA]]

</td>
</tr>
<tr>
<td>
Mar. 2, 3, 4, 7

</td>
<td>
[[WebFund 2016W: Tutorial 6|TBA]]

</td>
</tr>
<tr>
<td>
Mar. 9, 10, 11, 14

</td>
<td>
[[WebFund 2016W: Tutorial 7|TBA]]

</td>
</tr>
<tr>
<tr>
<td>
Mar. 16, 17, 18, 21

</td>
<td>
[[WebFund 2016W: Tutorial 8|TBA]]

</td>
</tr>
<tr>
<td>
Mar. 23, 24, 25, 28

</td>
<td>
[[WebFund 2016W: Tutorial 9|TBA]]

</td>
</tr>
<tr>
<td>
Mar. 30, 31, Apr. 1, 4

</td>
<td>
[[WebFund 2016W: Tutorial 10|TBA]]

</td>
</tr>
</table>

==Assignments==
<table style="width: 100%;" border="1" cellpadding="4" cellspacing="0">
<tr valign="top">
<th>
Due Date
</th>
<th>
Assignments
</th>
</tr>
<tr>
<td>
Jan. 20

</td>
<td>
[[WebFund 2016W: Assignment 1|Assignment 1]]

</td>
</tr>
<tr>
<td>
Jan. 27

</td>
<td>
[[WebFund 2016W: Assignment 2|Assignment 2]]

</td>
</tr>
<tr>
<td>
Feb. 3

</td>
<td>
[[WebFund 2016W: Assignment 3|Assignment 3]]

</td>
</tr>
<tr>
<td>
Feb. 9, 2:30 PM

</td>
<td>
[[WebFund 2016W: Assignment 4|Assignment 4]]

</td>
</tr>
<tr>
<td>
Mar. 2

</td>
<td>
[[WebFund 2016W: Assignment 5|Assignment 5]]

</td>
</tr>
<tr>
<td>
Mar. 9

</td>
<td>
[[WebFund 2016W: Assignment 6|Assignment 6]]

</td>
</tr>
<tr>
<td>
Mar. 16

</td>
<td>
[[WebFund 2016W: Assignment 7|Assignment 7]]

</td>
</tr>
<tr>
<td>
Mar. 23

</td>
<td>
[[WebFund 2016W: Assignment 8|Assignment 8]]

</td>
</tr>
<tr>
<td>
Mar. 30

</td>
<td>
[[WebFund 2016W: Assignment 9|Assignment 9]]

</td>
</tr>
<tr>
<td>
Apr. 6

</td>
<td>
[[WebFund 2016W: Assignment 10|Assignment 10]]

</td>
</tr>
</table>

==Course Software==

In this course we will be developing web applications using [http://nodejs.org/ node.js] and [http://www.mongodb.org/ mongoDB]. You are welcome to use whatever operating system and development tools you like; however, we will supporting the use of a course virtual machine appliance running [http://www.lubuntu.net/ Lubuntu], a low-resource variant of [http://www.ubuntu.com/ Ubuntu] Linux distribution.

===In the labs===

In the SCS labs you should be able to run the course VM by starting Virtualbox (listed in the Applications menu) and selecting the COMP 2406 virtual machine image. After the VM has fully booted up you can login to the student account using the password "tneduts!". This account has administrative privileges; in addition, there is the admin account in case your student account gets corrupted for any reason. The password for it is "nimda!".

We highly recommend running your VM in full-screen mode (select from the menu, not by maximizing the window). Do all of your work inside of the VM; it should be fast enough and you won't have any issues with sharing files or with firewalls/network connectivity.

You can save the work you do from the course VM (in the student account) to your SCS account and restore it to any other copy of the class VM (on your machines or in the labs) by running using the following commands:

save2406 <SCS username>
restore2406 <SCS username>
compare2406 <SCS username>

If you use these commands, '''use them consistently'''. That means run <tt>restore2406</tt> when you first log in, and run <tt>save2406</tt> just before logging out. If you don't do this, you will '''erase''' the work that you had done previously when you save.

If you forgot to restore and you want to save, try running this:

rsync -a -v --progress ~/ <SCS username>@access.scs.carleton.ca:COMP2406/

This is the same as the <tt>save2406</tt> command minus the options (--delete and --force) that deletes files in the destination that don't exist in the source. As a check, you may want to add the <tt>-n</tt> option to do a dry run.

===Running the VM on your own machines===

If you want to run the VM appliance on your own system (running essentially any desktop operating system you want), just download the [http://homeostasis.scs.carleton.ca/~soma/VMs/COMP%202406,%20Winter%202016.ova virtual appliance file] and import into [http://www.virtualbox.org VirtualBox] or VMware Workstation/Fusion ([https://secure.scs.carleton.ca/vmware/ free to Carleton SCS students]). The SHA1 hash of this file is:

97fc4de4544505178b580d27487085a20961e91e [http://homeostasis.scs.carleton.ca/~soma/VMs/COMP%202406,%20Winter%202016.ova COMP 2406, Winter 2016.ova]

On Windows you can compute this hash for your downloaded file using the command <a href="http://support.microsoft.com/kb/889768"><tt>FCIV -sha1 COMP 2406 & 3000, Fall 2015.ova</tt></a>. If the hash is different from above, your download has been corrupted.

If your virtualization platform is not VirtualBox, you'll need to:
* Have the VM platform ignore any errors in the structure of the appliance found during the import process;
* Uninstall the VirtualBox guest additions by typing starting a terminal application and running
sudo /opt/VBoxGuestAdditions-*/uninstall.sh
* Install your platform's own Linux guest additions, if available.

===Configuring Linux===

If you already run Linux and you want to use the same packages we do in class, you should do the following:

* Install the latest node.js version using [https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager a package manager]. (You generally don't use the version that comes with your distribution, it is probably too old.)
* Install [http://www.mongodb.org/ mongoDB] - it probably goes by mongodb in your package manager. The version doesn't matter too much.

Note that the binary of the node.js executable may be <tt>node</tt>, <tt>nodejs</tt>, or something similar.

That's it!

===Configuring Windows===

It is also possible to do everything in this class in Windows. Here are some tips on getting things running.

* You can just install the [http://nodejs.org/download/ windows node package] to get basic node and npm functionality.
* [[Run MongoDB on Windows]].
* If you want to run Emacs on Windows, look at the [[Running Emacs on Windows|following tips]].

===Configuring Mac OS X===

It is possible, and recommended, to configure Node and mongoDB to run on your Mac.

====Homebrew method (recommended)====
Homebrew is a package manager for OS X that works similarly to Linux-style package managers like <tt>apt</tt>. Homebrew provides access to thousands of Linux and BSD packages to install natively on your Mac. You have a perfectly capable UNIX system in front of you. Make good use of it!

* Install [http://brew.sh/ Homebrew] (copy the installation text on that page to Terminal.app)
* Install Node and mongoDB

Run the following commands in your terminal:

brew update
brew install node
brew install mongo

That's it!

====Manual method====
Alternatively, you can download and install Node and mongo directly.

* Download and install the ''Mac OS X Installer'' from [https://nodejs.org/en/download/stable/ the download page].
* Download the binaries from [https://www.mongodb.org/downloads#production MongoDB's download page]
* Follow [https://docs.mongodb.org/manual/tutorial/install-mongodb-on-os-x/#install-mongodb-community-edition-manually these instructions]

==Resources==

In general any text published by [http://www.oreilly.com/ O'Reilly] is worth your time. Many (but not all) of the texts below are published by them.

===JavaScript===

[http://shop.oreilly.com/product/9780596517748.do JavaScript: The Good Parts] by Douglas Crockford is an excellent text on JavaScript and it is short. We highly suggest you obtain a copy and read it.

The easiest way to get started with JavaScript and get basic understanding of web technologies is to go through the interactive lessons on [http://codeacademy.com Code Academy]. I suggest you go through their JavaScript, Web Fundamentals, and jQuery tracks. They shouldn't take you very long to do given that you already know how to program.

Crockford also has a lot of online resources on JavaScript, including videos of talks he's given that cover much of the content in his book. Look at his [http://javascript.crockford.com/ JavaScript page] and this [http://yuiblog.com/crockford/ page of his videos].

Another good book is [http://eloquentjavascript.net/ Eloquent JavaScript: A Modern Introduction to Programming] by Marijn Haverbeke. A version of this book is available online for free. The for-sale version is apparently updated and edited.

The standard reference for JavaScript is [http://shop.oreilly.com/product/9780596805531.do JavaScript: The Definitive Guide] by David Flanagan. It is a big book, but it is comprehensive.

===Node===

[http://shop.oreilly.com/product/0636920024606.do Learning Node] by Shelley Powers is the recommended resource for learning about Node.

Another introduction to node.js is [http://www.nodebeginner.org/ The Node Beginner Book] by Manuel Kiessling.

[http://evanhahn.com/understanding-express-js/ This page by Evan Hahn] has a good overview of the express/connect/node software stack.

===MongoDB===

[http://shop.oreilly.com/product/0636920028031.do MongoDB: The Definitive Guide] by Kristina Chodorow (1st or 2nd ed) is the recommended text for learning more about MongoDB.

==Lecture Notes Guidelines==

As specified in the course outline you can get up to 6% extra credit on your final grade (2% per time) for writing up notes from lecture. Here are the guidelines for those notes.

Lee Croft (LeeCroft at cmail.carleton.ca) will be handling course notes. Please contact him if you would like to volunteer. Note that you should email him in advance and he will give you the next available slot. There are over 200 students in class and only 20 lectures so opportunities may go fast!

Lee or Anil will set you up with an account on this wiki. You'll enter your initial draft notes here and then work with Lee to make sure they are of sufficient quality. This may require a few rounds of revisions; however, if you follow the guidelines below it shouldn't be too bad.

You should plan on organizing your notes as follows:
* Organize them in at least the following sections: Topics & Readings, Audio & Video, and Notes.
* The Topics & Readings section lists the main topics covered in the course, e.g. "Scoping rules in JavaScript". Please use an unordered bulleted list (using *'s in wiki markup). In this section also list readings relevant to the lecture that were mentioned in class.
* Leave the Audio and Video section blank. Anil will fill this out.
* Put your notes in the Notes section.

Use (nested) lists if appropriate for the notes; however, please have some text that isn't bulleted. Please try to make the notes even if you did not attend lecture; however, you don't need to cover every small bit of information that was covered. In particular the notes do not need to include digressions into topics only tangentially related to the course. Complete sentences are welcome but not required.