10 |
11 |
12 | 
13 |
14 | 
90 |
91 | When attempting to enroll in such a course:
92 | - Click the blue "Enroll" or "Enroll Now" button.
93 | - A pop-up will appear.
94 | - **Do not click** "Start Free Trial", unless you do want to pay.
95 | - Find the text that says "Audit this course" at the bottom.
96 | - Click **Audit**.
97 |
98 | 
99 |
100 | ### Is it necessary to purchase the Verified Upgrade for edX courses?
101 |
102 | If you just want to watch the videos, it is never necessary for any edX course on our curriculum. Note that a number of edX courses only allow students to audit a course for the estimated number of weeks it takes to complete. Students should not begin a course until they are prepared to focus and complete the course.
103 |
104 | ### What are the alt links?
105 |
106 | Sometimes a course is on multiple platforms that are reasonably similar in quality so we have an alt or two linked in case the main one isn't being offered at the time or you prefer the other one. Both are just as good, go with whichever you prefer or whichever is available when you want to take the course.
107 |
108 | ### Why doesn't the curriculum cover/ignore topic X?
109 |
110 | You can read more about our curricular guidelines and the qualifications of the guidelines' authors [here](CURRICULAR_GUIDELINES.md). If you find a topic that is required by our guidelines and is not included in the curriculum, we should make a change! Read more about [contributing to a change](CONTRIBUTING.md).
111 |
112 | ### Why is the curriculum missing some pre-requisites?
113 |
114 | The curriculum assumes two things:
115 | - You are reasonably fluent in English.
116 | - You have gotten through a standard high school curriculum that included physics and pre-calculus.
117 |
118 | Without these assumptions, the curriculum would be out of control with trying to fill in your knowledge gaps.
119 | For those who want to study math pre-requisites, read more [here](#how-can-i-review-the-math-prerequisites)
120 |
121 | Of course, if you find that the curriculum is missing a pre-requisite for a course that isn't part of a normal high school curriculum, please let us know!
122 |
123 | ### Why require experience with a sizable project before the Software Engineering courses?
124 | Software engineering tries to solve the problem of dealing with large programs. Building a sizable program before taking the SE courses will help you understand what SE is trying to solve. We recommend the Jack-to-VM-code compiler project from the nand2tetris course because it's the first project in the curriculum that is complex enough to see value in a SE course. That said, any sizable project will do and can come from outside of the OSSU curriculum. The idea is that you've done some large enough project where the pieces started to feel unmanageable. This experience will expose pain points and lead to a better understanding of SE.
125 |
126 | ### How can I find a course on a particular subject?
127 | After completing Core CS, learners are ready to pursue computer science
128 | topics of their own interest. How can one find a course on a given topic?
129 | For MOOCs an excellent resource is [Class Central](https://www.classcentral.com/).
130 | For materials from university courses that are online (but not organized)
131 | into a MOOC, [awesome-courses](https://github.com/prakhar1989/awesome-courses) and
132 | [cs-video-courses](https://github.com/Developer-Y/cs-video-courses)
133 | are good resources. For textbooks, [Goodreads](https://www.goodreads.com/genres/computer-science)
134 | is a great platform for reader ratings and reviews.
135 | For learning a particular programming language or framework,
136 | [see this question](#what-is-a-good-course-to-learn-a-particular-language).
137 |
--------------------------------------------------------------------------------
/HELP.md:
--------------------------------------------------------------------------------
1 | # Getting help
2 | ## Check the FAQ!
3 | Please check our [Frequently Asked Questions](FAQ.md) to see if your question has been addressed.
4 | ## Ask in the chat room
5 | [](https://discord.gg/5pUhfpX) Join the OSSU [Discord server](https://discord.gg/5pUhfpX)! Discord is an online chat service, similar to Slack or IRC where you can chat with other students and get help.
6 | ### Specific problems
7 | If you need help successfully completing the content of a course or are having general technical difficulties, first reach out to the resources provided by the course (e.g. the course forum on Coursera, edX, etc). If you need additional help after that, post in Discord. **In your post, mention what steps you have already taken to try and solve the problem**.
8 | ### General problems
9 | If you have general problems with the program not specific to any course, such as preferring textbook-style learning over MOOCs, Discord is a good place to reach out to people who may have great suggestions. You might form a working group that makes the next improvement to OSSU CS! Read more about contributing [here](CONTRIBUTING.md).
10 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 |
3 | Copyright (c) 2015-2022 Open Source Society University
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/PROJECTS.md:
--------------------------------------------------------------------------------
1 | # Projects
2 | > Here, we are providing a list of projects done by the community for the final projects. You may use these as inspirations for your own final project!
3 |
4 | Projects created by OSSU's students for each course of our [**Computer Science**](https://github.com/ossu/computer-science) curriculum.
5 |
6 | For more project ideas, check the [Mega Project List](https://github.com/karan/Projects).
7 |
8 | - [Introduction to Computer Science](#introduction-to-computer-science)
9 | - [Programming](#programming)
10 | - [Math](#math)
11 | - [Systems](#systems)
12 | - [Theory](#theory)
13 | - [Applications](#application)
14 |
15 | ## Introduction to Computer Science
16 | Project Title | Description | Author(s) | Repository
17 | :-- | :-- | :--: | :--
18 | StalkHub | Stalk Github beautifully | [Aman Roy](https://github.com/aman-roy) | [StalkHub](https://github.com/aman-roy/StalkHub)
19 | Webliza | ELIZA in python with web interface | [Vipin Kumar](https://github.com/VipinindKumar) | [Webliza](https://github.com/VipinindKumar/Webliza)
20 |
21 |
22 | ## Programming
23 | Project Title | Description | Author(s) | Repository
24 | :-- | :-- | :--: | :--
25 |
26 | ## Math
27 | Project Title | Description | Author(s) | Repository
28 | :-- | :-- | :--: | :--
29 |
30 | ## Systems
31 | Project Title | Description | Author(s) | Repository
32 | :-- | :-- | :--: | :--
33 |
34 | ## Theory
35 | Project Title | Description | Author(s) | Repository
36 | :-- | :-- | :--: | :--
37 |
38 | ## Application
39 | Project Title | Description | Author(s) | Repository
40 | :-- | :-- | :--: | :--
41 | Observatory | Interactively displays temperatures and deviations all around the world from 1975 to 2015 | [spamegg](https://github.com/spamegg1) | [ScalaCapstone](https://github.com/spamegg1/ScalaCapstone)
42 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 |
3 | 5 | Path to a free self-taught education in Computer Science! 6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
`
452 | - Use our [community](#community) channels to announce it to your fellow students.
453 |
454 | Solicit feedback from your OSSU peers.
455 | You will not be "graded" in the traditional sense — everyone has their own measurements for what they consider a success.
456 | The purpose of the evaluation is to act as your first announcement to the world that you are a computer scientist
457 | and to get experience listening to feedback — both positive and negative.
458 |
459 | The final project evaluation has a second purpose: to evaluate whether OSSU,
460 | through its community and curriculum, is successful in its mission to guide independent learners in obtaining a world-class computer science education.
461 |
462 | ### Cooperative work
463 |
464 | You can create this project alone or with other students!
465 | **We love cooperative work**!
466 | Use our [channels](#community) to communicate with other fellows to combine and create new projects!
467 |
468 | ### Which programming languages should I use?
469 |
470 | My friend, here is the best part of liberty!
471 | You can use **any** language that you want to complete the final project.
472 |
473 | The important thing is to **internalize** the core concepts and to be able to use them with whatever tool (programming language) that you wish.
474 |
475 | ## Congratulations
476 |
477 | After completing the requirements of the curriculum above, you will have completed the equivalent of a full bachelor's degree in Computer Science. Congratulations!
478 |
479 | What is next for you? The possibilities are boundless and overlapping:
480 |
481 | - Look for a job as a developer!
482 | - Check out the [readings](extras/readings.md) for classic books you can read that will sharpen your skills and expand your knowledge.
483 | - Join a local developer meetup (e.g. via [meetup.com](https://www.meetup.com/)).
484 | - Pay attention to emerging technologies in the world of software development:
485 | + Explore the **actor model** through [Elixir](https://elixir-lang.org/), a new functional programming language for the web based on the battle-tested Erlang Virtual Machine!
486 | + Explore **borrowing and lifetimes** through [Rust](https://www.rust-lang.org/), a systems language which achieves memory- and thread-safety without a garbage collector!
487 | + Explore **dependent type systems** through [Idris](https://www.idris-lang.org/), a new Haskell-inspired language with unprecedented support for type-driven development.
488 |
489 | 
490 |
491 | # Code of conduct
492 | [OSSU's code of conduct](https://github.com/ossu/code-of-conduct).
493 |
494 | ## How to show your progress
495 |
496 | 1. Create an account in [Trello](https://trello.com/).
497 | 1. Copy [this](https://trello.com/b/IScNSzsI/ossu-compsci) board to your personal account.
498 | See how to copy a board [here](https://help.trello.com/article/802-copying-cards-lists-or-boards).
499 |
500 | Now that you have a copy of our official board, you just need to pass the cards to the `Doing` column or `Done` column as you progress in your study.
501 |
502 | We also have **labels** to help you have more control through the process.
503 | The meaning of each of these labels is:
504 |
505 | - `Main Curriculum`: cards with that label represent courses that are listed in our curriculum.
506 | - `Extra Resources`: cards with that label represent courses that were added by the student.
507 | - `Doing`: cards with that label represent courses the student is currently doing.
508 | - `Done`: cards with that label represent courses finished by the student.
509 | Those cards should also have the link for at least one project/article built with the knowledge acquired in such a course.
510 | - `Section`: cards with that label represent the section that we have in our curriculum.
511 | Those cards with the `Section` label are only to help the organization of the Done column.
512 | You should put the *Course's cards* below its respective *Section's card*.
513 |
514 | The intention of this board is to provide our students a way to track their progress, and also the ability to show their progress through a public page for friends, family, employers, etc.
515 | You can change the status of your board to be *public* or *private*.
516 |
517 | # Team
518 |
519 | * **[Eric Douglas](https://github.com/ericdouglas)**: founder of OSSU
520 | * **[Josh Hanson](https://github.com/joshmhanson)**: lead technical maintainer
521 | * **[Waciuma Wanjohi](https://github.com/waciumawanjohi)**: lead academic maintainer
522 | * **[Contributors](https://github.com/ossu/computer-science/graphs/contributors)**
523 |
--------------------------------------------------------------------------------
/coursepages/ostep/Project-1B-initial-xv6.md:
--------------------------------------------------------------------------------
1 | ## Project 1B
2 |
3 | ### all thanks to [palladian](https://github.com/palladian1)
4 |
5 | ### Linux Installation
6 |
7 | * Make sure you have a compatible compiler toolchain; if you're on Linux, gcc should work perfectly.
8 | * Install qemu-system-x86 (may be called qemu-system-i386 or qemu-system-x86_64; note that on some distros, qemu is the wrong package).
9 | * Install Perl.
10 | * Install gawk.
11 | * Install expect.
12 | * Make a src/ directory in the same directory as the project's test script.
13 | * Clone xv6 github repo and copy the source code in to your src/ directory.
14 | * Inside src/, run `make qemu-nox` to test whether xv6 is working. Exit xv6 with `Ctrl-a x`; if you forget this, you can also kill the qemu process. It's worth checking `top` or `htop` to make sure qemu isn't running anymore; sometimes it can keep going after you exit and consume a lot of resources.
15 | * Modify the Makefile to set `CPUS := 1`.
16 | * Run `make qemu-nox` again to test that xv6 still works.
17 |
18 | ### Instructions
19 |
20 | * Your task is to create a new system call for xv6, `getreadcount()`, that will return the number of `read` syscalls that have previously taken place. Note that the count should be a global count, not a per-process count.
21 |
22 | ### Suggested Approach
23 |
24 | * Download the xv6 source code PDF (it's better organized there than in the code you downloaded). Read the table of contents to understand how sheets, pages, and lines are numbered. Then glance at the cross-references after that so you know how to find parts of the code if you need to.
25 | * Take a (very) quick look at the portions of the xv6 source code listed under `processes` and `system calls` on the table of contents, as well as `usys.S` in the `user-level` section. Don't worry about understanding it yet; you just need to see where each file is in the PDF so that you can follow along with the discussion video later, since the professor's code has a different directory layout than yours will.
26 | * Watch the video for discussion 2 on Project P1B, and follow along with your PDF copy of the xv6 code. Annotate it as the professor explains what each part does.
27 | * Read the background section linked on the project's Github page, annotating the xv6 code PDF.
28 | * Read through the xv6 PDF one more time, this time to get a general understanding of the `processes` and `system calls` sections, as well as `usys.S` and `user.h` (NOTE: the last one isn't included in the xv6 PDF, so you'll have to look at the actual code you downloaded). Don't worry about understanding every last line of code, just make sure you know where system calls are defined, how they're called, etc.
29 | * Modify the xv6 source code to add the new `getreadcount()` syscall. You will need to modify several files; I suggest marking your modifications with `// OSTEP project` to make it easy to find them later for debugging.
30 | * There is one other place you'll have to add code, which isn't included in the xv6 PDF: `user.h`.
31 | * Once you're done, run the test script. Test 1 runs a function that will make several `read` calls, then calls `getreadcount`. In order for your code to work, you must correctly keep track of the total number of `read` calls made by all processes.
32 | * If your code passes test 1, congratulations! You're done for now. Don't worry about test 2 until after you've watched the lectures on concurrency.
33 | * If your code didn't pass test 1, you can compare the expected output in `tests/1.out` with your test's actual output in `tests-out/1.out`. You can also look at `tests-out/1.err` to check for any error messages.
34 | * You can also test your code by loading up xv6 in your terminal with `make qemu-nox`. Type `ls` to see all files; you should see `test_1` and `test_2`. Run test 1 with `./test_1` to see what it prints out; you can compare that manually with the expected output.
35 | * Once you've watched the lectures on threads, concurrency, and locks: test 2 checks whether your implementation of `getreadcount` is thread-safe. It probably wasn't before, so in order to fix that, you'll have to add a lock. Then you can run the test script again and check that your code now passes both tests.
36 |
--------------------------------------------------------------------------------
/coursepages/ostep/Project-2A-processes-shell.md:
--------------------------------------------------------------------------------
1 | ## Project 2A
2 | ### all thanks to [Palladian](https://github.com/palladian1/)
3 |
4 | - [x] Interactive mode
5 | - [x] Batch mode
6 | - [x] exit
7 | - [x] cd
8 | - [x] path
9 | - [x] Redirection
10 | - [x] Parallel commands
11 |
12 | ### Tips
13 |
14 | * Watch the video for discussion 3 on the Unix shell.
15 | * Read chapter 5 in the OSTEP book.
16 | * Start by implementing a shell that only does one thing: prints the prompt, then exits when you type `exit`. Then add `cd`, then `path`. Then implement the ability to execute commands with `execv`, then add batch mode, then redirection, and finally parallel commands.
17 | * All of the test scripts will use batch mode and redirection, so until you've got those done, you'll have to test your shell manually.
18 | * When you implement the `path` command, make sure you can handle both absolute and relative paths (i.e., `path tests` as well as `path /usr/bin`.
19 | * It's tricky to get the errors down right, so just add error messages wherever it seems reasonable, then run the test scripts and modify your code until you're reporting errors exactly when you're supposed to. If you're running test `i`, you can check `tests/i.err` and `tests/i.rc` to see how many errors your shell should generate and compare to `tests-out/i.err` and `tests-out/i.rc`.
20 | * If you run into issues with test 3 where the test expects something like `ls: cannot access ...` and your shell ouputs `/bin/ls: cannot access ...` or `/usr/bin/ls: cannot access ...`, try modifying your $PATH environment variable to start with `/bin`. If that doesn't work, just modify `tests/3.err` to match the output your system gives. You can't modify your system's output without messing with the implementation of `ls` and/or `execv`, so it's okay to skip this test as long as it's working in spirit.
21 | * I had to edit `/tests/3.pre` to use `/bin/ls` due to how it's set up on my system, in order to pass all the tests. Alternatively you can add `export PATH="/bin:$PATH"` to your `.profile` or `.bashrc` file.
22 |
23 | ### Memory Management Traps and Pitfalls
24 |
25 | * This assignment makes it really easy to create pointers to stack variables that will no longer exist once they're out of scope, thus causing a segmentation fault. Make sure that if you set a pointer to point to a string, that string is something you allocated on the heap, and not on the stack.
26 |
27 | * That said, if you do use a string on the stack, you can copy it into a heap-allocated string using `strcpy()`, `strncpy()`, `strcat()`, and `strncat()`.
28 |
29 | * Only use `strcpy()` and `strcat()` for fixed-size strings and make sure the buffer you're copying into has enough space to hold the string, plus an extra character for `\0`.
30 |
31 | * For `strncpy()` and `strncat()`, make sure `n` is large enough to fit the `\0` terminator, or add it manually.
32 |
33 | * Watch out for use-after-frees, especially in the implementation of `path`.
34 |
35 | * Make sure you free any strings from `getline()` and `strdup()`, but watch out for double-frees, e.g. don't free a substring of a string you already freed.
36 |
37 | * Avoid the C library function `strtok()`; it's not thread-safe. Use `strsep()` instead.
38 |
39 | * When you use `strsep()`, make sure you keep a copy of the original pointer to the string around so that you can free it later, because `strsep()` will modify the pointer, so if you free that later on, you'll corrupt the page table.
40 |
41 | * After calling `strsep(&buf, delim)`, check whether `buf` is `NULL` before dereferencing it.
42 | * General C coding practice: if you allocate memory for a data structure inside a function, you should free it in the same function. If you allocate memory in a dedicated `create_xxx` function, you should have a corresponding `destroy_xxx` function. That way, you always allocate and free memory at the same function depth, which makes it easier to avoid memory errors.
43 | * After every call to `malloc`, `calloc`, or `realloc`, check whether the result is `NULL`.
44 | * Use `calloc` instead of `malloc` if you're creating an array of pointers to avoid creating pointers to garbage values.
45 | * in `update_path` I had to fix that issue where most of the tests do `path /bin /usr/bin`, but one of them did `path tests`. So i just assumed that if your path starts with a slash, it's an absolute path and you should copy it in as is; if it doesn't, it's a relative path and you should add a ./ at the beginning.
46 |
--------------------------------------------------------------------------------
/coursepages/ostep/README.md:
--------------------------------------------------------------------------------
1 | # Operating Systems: Three Easy Pieces
2 |
3 | Credit goes to [palladian](https://github.com/palladian1)
4 | ## Introduction
5 |
6 | First, we should be frank: it's really hard to find a good self-contained online course on operating systems. OSTEP is the best course we've found so far, but it does have some issues.
7 |
8 | This is the first course in the OSSU curriculum for which you'll need to learn some prerequisites on your own before starting it, in addition to the courses that come before it in the curriculum. You might also run into some issues running the scripts for homework demos and for testing your solutions to the projects (although we hope we've solved most of those by now).
9 |
10 | What this means for you is that if you're under a significant time crunch, or you're just not all that interested in systems programming and OS development, there's no shame in skipping this course and coming back to it later. You could also do only a part of the course (e.g. you might choose to skip the homework and/or projects).
11 |
12 | That said, if you're able to commit the time required for the prerequisites, we believe the reward is well worth the effort: this course is exciting, interesting, and quite useful for other fields of computer science and programming. One big attraction of this course is the opportunity to see a simplified but fully-functional Unix-like operating system in action and understand the concepts and design decisions that went into it as well as the low-level implementation details.
13 |
14 | In order to satisfy OSSU's curricular guidelines, you should either watch all the lecture videos or read chapters 1 through 47 in the textbook (don't worry, the chapters are usually just a few pages long) as well as finish the projects listed below. We also strongly encourage you to do the homework exercises as they're assigned on the course website or in the book chapters; think of these like the "check-your-understanding" questions that pop up in the middle of lecture videos on sites like Coursera or edX.
15 |
16 | ## Prerequisites
17 |
18 | This class requires a lot of experience programming in C. You should finish one of the C books listed in the [resources below](#c) *before* starting this course; if you try to learn C at the same time as the course material, you're likely to feel overwhelmed. If you haven't used C before, you should expect to spend a lot of time on this; it's hard to predict how long it might take for each person, but a rough estimate might be 8-10 hours per week for 3-5 weeks. You can always learn C alongside another OSSU course or even redo the exercises for other courses in C to gain practice with it.
19 |
20 | You should also finish both parts of Nand2Tetris before starting this course. OSTEP focuses on the real-world x86 and x86_64 architectures, so you'll have to fill in some gaps in order to translate the concepts you learned in Nand2Tetris to a new architecture. You can do that with the x86 resources below, but note that they all assume you know C, so learn that first. This should take around 6-8 hours in total.
21 |
22 | ## Course Links
23 |
24 | * [Course website](https://pages.cs.wisc.edu/~remzi/Classes/537/Spring2018/)
25 | * [Book](https://pages.cs.wisc.edu/~remzi/OSTEP/)
26 | * [Lecture videos](https://pages.cs.wisc.edu/~remzi/Classes/537/Spring2018/Discussion/videos.html)
27 | * [Homework](https://pages.cs.wisc.edu/~remzi/OSTEP/Homework/homework.html)
28 | * [Homework repo](https://github.com/remzi-arpacidusseau/ostep-homework)
29 | * [Projects](https://github.com/remzi-arpacidusseau/ostep-projects)
30 | * [xv6](https://github.com/mit-pdos/xv6-public)
31 |
32 | ## Roadmap
33 |
34 | This course was originally taught as CS 537 at the University of Wisconsin by the author of the OSTEP textbook, so the projects are assigned in the course according to the best times to give UWisconsin students access to on-campus resources like recitation sections and office hours. That means they don't match up perfectly with the material being covered at that time in the lectures or textbook chapters. We recommend doing the course in the following order instead.
35 |
36 | [Reading order](Reading-order.md)
37 |
38 | * Read chapters 1 and 2 of the OSTEP textbook and watch the first half (the introduction) of lecture 1.
39 | * Do the `initial-utilities` project; it's intended as a litmus test for you to make sure you're comfortable enough with C before taking this class. You can watch discussion 1 for help. If it takes you more than 2 hours to write the code (not counting the discussion time and any time spent debugging), you should consider spending more time learning C before moving on in the course. (If you want more practice, you can do `initial-reverse` too, but it's not required.)
40 | * Watch lectures 1 through 5 and read chapters 3 through 24 of the OSTEP textbook. We recommend doing the homework assignments as they come up in the course calendar or book chapters.
41 | * Watch discussion 3 and reread chapter 5, then do the `processes-shell` project.
42 | * Read the annotated guide to xv6 linked in the resources section below, starting from the beginning and stopping after the `System Calls: Processes` section.
43 | * Watch discussion 2, then do the `initial-xv6` project.
44 | * Watch discussion 5, then do the `scheduling-xv6-lottery` project.
45 | * Watch discussion 7, then do the `vm-xv6-intro` project.
46 | * Watch lectures 6 through 9 (and optionally, the review lecture) and read chapters 25 through 34; again, you're encouraged to do the homework.
47 | * Watch discussion 10, then do the `concurency-xv6-threads` project.
48 | * Watch discussions 11 and 12, then do the `concurrency-mapreduce` project.
49 | * Watch lectures 10 through 14 (and optionally, the second review lecture) and read chapters 35 through 47; remember to do the homework along with the lectures or chapters.
50 | * Do the `filesystems-checker` project.
51 |
52 | ### Running the Projects
53 |
54 | This course was originally taught as CS 537 at the University of Wisconsin by the author of the OSTEP textbook, which means that the homework and projects were written with those students as a target audience and designed to be run on UWisconsin lab computers with specific software versions pre-installed for students. We hope this section fixes that so you can run them on other computers, but we haven't tested this on every computer, so if you run into other issues, let us know on the [Discord channel](https://discord.gg/MJ9YXyV) and we'll try to help out.
55 |
56 | In order to run the homework and projects on Linux or macOS, you'll need to have all of the following programs installed:
57 |
58 | * `gcc`
59 | * `gas`
60 | * `ld`
61 | * `gdb`
62 | * `make`
63 | * `objcopy`
64 | * `objdump`
65 | * `dd`
66 | * `python`
67 | * `perl`
68 | * `gawk`
69 | * `expect`
70 | * `git`
71 |
72 | You will also need to install `qemu`, but we recommend using the patched version provided by the xv6 authors; see [this link](https://pdos.csail.mit.edu/6.828/2018/tools.html) for details.
73 |
74 | On macOS, you'll need to install a cross-compiler `gcc` suite capable of producing x86 ELF binaries; see the link above for details as well.
75 |
76 | On Windows, you can use a Linux virtual machine for the homework and projects. Some of these packages are not yet supported on Apple M1 computers, and virtual machine software has not yet been ported to the new processor architecture; some students have used a VPS to do the homework and projects instead.
77 |
78 | Next, clone the `ostep-homework` and `ostep-projects` repositories:
79 | ```sh
80 | git clone https://github.com/remzi-arpacidusseau/ostep-homework/
81 | git clone https://github.com/remzi-arpacidusseau/ostep-projects/
82 | cd ostep-projects
83 | ```
84 |
85 | You'll have to clone [the `xv6-public` repository](https://github.com/mit-pdos/xv6-public) into the directory for each xv6-related OSTEP project. You could use the same copy for all the projects, but we recommend using separate copies to avoid previous projects causing bugs for later ones. Run the following commands in *each* of the `initial-xv6`, `scheduling-xv6-lottery`, `vm-xv6-intro`, `concurrency-xv6-threads`, and `filesystems-checker` directories.
86 |
87 | ```sh
88 | mkdir src
89 | git clone https://github.com/mit-pdos/xv6-public src
90 | ```
91 |
92 | ### Hints and tips for Projects
93 |
94 | - `initial-reverse`: the error messages that are needed to pass the tests were wrong! The provided text said `"error: ..."` but the tests expected `"reverse: ..."` so make sure to match the tests' expectations in your code.
95 | - [hints and tips for `processes-shell`](Project-2A-processes-shell.md)
96 | - [hints for Project 1B: `initial-xv6`](Project-1B-initial-xv6.md)
97 | - [hints for `scheduling-xv6-lottery`](Scheduling-xv6-lottery.md)
98 | - [hints for `vm-xv6-intro`](vm-xv6-intro.md)
99 |
100 |
101 | ## Resources
102 |
103 | ### C
104 |
105 | Please don't try to learn C from sites like GeeksforGeeks, TutorialsPoint, or Hackr.io (we're not even gonna link to them here). Those are great resources for other languages, but C has way too many pitfalls, and C tutorials online are often filled with dangerous errors and bad coding practices. We looked at many C resources for the recommendations below and unfortunately found *many* bad or unsafe ones; we'll only include the best ones here, so look no further!
106 |
107 | We recommend learning C by working through (the entirety of) Jens Gustedt's *Modern C*, which is [freely available online](https://hal.inria.fr/hal-02383654/file/ModernC.pdf). This book is relatively short and will bring you up to speed on the C language itself as well as modern coding practices for it. Make sure to do all the exercises in the footnotes!
108 |
109 | While the book above is our default recommendation, we also recommend K.N. King's [*C Programming: A Modern Approach*](http://www.knking.com/books/c2/) as a second, more beginner-friendly option. It has some disadvantages: it's much longer (almost 850 pages), it's not available for free (and copies can be hard to find), and it's not quite as recent as *Modern C* (but still relevant nonetheless). That said, it has more exercises if you want extra practice, and the Q&A sections at the end of each chapter are filled with pearls of C wisdom and answers to C FAQs. It also covers almost the entirety of the C language and standard library, so it doubles as a reference book.
110 |
111 | CS 50 doesn't quite cover enough C for OSTEP, but if you've already taken CS 50, you can supplement it with the books above.
112 |
113 | Additional (***optional***) resources include:
114 | * [CS 50 Manual Pages](https://manual.cs50.io): a great reference for looking up C library functions; most functions include both the usual manual as well as a beginner-friendly "less comfortable" option (just note that the "less comfortable" version uses `string` as an alias for `char *`.)
115 | * [cdecl](https://cdecl.org): a tool to translate C gibberish into English.
116 | * [C track on exercism.org](https://exercism.org/tracks/C): additional practice exercises.
117 | * [Secure Coding Practices in C and C++](https://www.amazon.com/dp/0321822137): if you want to understand why other C resources are so unsafe.
118 | * [*The C Programming Language*](https://www.amazon.com/dp/0131103628): the original book on C by its creators. Too outdated for OSTEP, but a good read if you manage to find a copy.
119 |
120 | ### x86 Architecture and Assembly Language
121 |
122 | Nand2Tetris has already introduced most of the concepts you'll need to understand systems and computer architectures, so now you just need to port that knowledge to the real-world (32-bit) x86 architecture.
123 |
124 | The easiest way to do that is by watching a subset of the lectures from the *Computer Systems: A Programmer's Perspective* course (or reading the matching chapters in the [textbook](https://www.amazon.com/dp/013409266X) of the same name). The lectures you'll need are:
125 |
126 | * [Machine-Level Programming I: Basics](https://scs.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=6e410255-3858-4e85-89c7-812c5845d197)
127 | * [Machine-Level Programming II: Control](https://scs.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=fc93c499-8fc9-4652-9a99-711058054afb)
128 | * [Machine-Level Programming III: Procedures](https://scs.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=2994255f-923b-4ad4-8fb4-5def7fd802cd)
129 | * [Machine-Level Programming IV: Data](https://scs.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=03308c94-fc20-40d8-8978-1a9b81c344ed)
130 | * [Machine-Level Programming V: Advanced Topics](https://scs.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=3f0bf9ca-d640-4798-b91a-73aed656a10a)
131 | * [Linking](https://scs.hosted.panopto.com/Panopto/Pages/Viewer.aspx?id=0aef84fc-a53b-49c6-bb43-14cb2b175249)
132 |
133 | Additional (***optional***) resources include:
134 | * [CPU Registers x86](https://wiki.osdev.org/CPU_Registers_x86): good for looking up specific registers.
135 | * [*PC Assembly Language*](https://pdos.csail.mit.edu/6.828/2018/readings/pcasm-book.pdf): a short book on x86 assembly.
136 | * [GCC Inline Assembly HOWTO](https://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html): a guide to writing assembly code inside a C program.
137 | * [*Intel 80386 Programmer's Reference Manual*](https://pdos.csail.mit.edu/6.828/2018/readings/i386.pdf): the official (and huge) resourcefrom Intel.
138 |
139 | ### xv6
140 |
141 | You don't need to read anything about xv6 until after you start OSTEP; in fact, we recommend holding off on the xv6-related projects until you've finished the entire section on virtualization. After that, you'll need a guide to walk you through the source code.
142 |
143 | The xv6 authors provide a [book](https://pdos.csail.mit.edu/6.828/2018/xv6/book-rev11.pdf) that you can read alongside the source code. There's also a handy line-numbered [PDF version](https://pdos.csail.mit.edu/6.828/2018/xv6/xv6-rev11.pdf) of the code with an index to see exactly where each function or constant gets used.
144 |
145 | However, that book glosses over a lot of the details in the code that you might find challenging, including the advanced C features used, the x86 architecture- specific instructions, and the concurrency aspects (if you haven't finished that section of OSTEP before starting the xv6 projects). To solve this problem, we provide an [annotated guide to xv6](https://github.com/palladian1/xv6-annotated) that goes over the entire xv6 code and analyzes it line-by-line with explanations of the C features, hardware specs, and x86 conventions used. That means it's longer than the official xv6 book, so you don't have to read all of it (and you can probably skip the optional sections unless you care about device drivers), but you can use it as a reference if you're scratching your head about some part of the code.
146 |
147 | Also [here](https://www.youtube.com/playlist?list=PLbtzT1TYeoMhTPzyTZboW_j7TPAnjv9XB) is an excellent video series walking through much of the xv6 code.
148 |
149 | ### Miscellaneous
150 |
151 | You'll need a general sense of how Makefiles work in order to use the Makefile for xv6. [This tutorial](https://makefiletutorial.com) covers much more than you need; just read the "Getting Started" and "Targets" sections and come back to the rest later if you need to look something up (but you shouldn't have to).
152 |
153 | Additional (optional) resources include:
154 | * [GCC Command Options](https://gcc.gnu.org/onlinedocs/gcc-11.1.0/gcc/Invoking-GCC.html#Invoking-GCC): a guide to command-line flags for the GNU C compiler `gcc`.
155 | * [Linker Scripts](https://sourceware.org/binutils/docs/ld/Scripts.html#Scripts): a guide to writing scripts for the GNU linker `ld`.
156 | * [OSDev Wiki](https://wiki.osdev.org): a great resource for all kinds of OS concepts and implementation details.
157 | * [*Linux Kernel Development*](https://www.amazon.com/dp/0672329468): if you want to apply your xv6 knowledge toward contributing to the Linux kernel, this is a great read after OSTEP.
158 |
--------------------------------------------------------------------------------
/coursepages/ostep/Reading-order.md:
--------------------------------------------------------------------------------
1 | ### all thanks to [palladian](https://github.com/palladian1)
2 |
3 | * Before starting the course: `initial-utilities` (aka, project 1a) and `initial-reverse` (not assigned in class)
4 | * Chapter 5: `processes-shell` (project 2a)
5 | * Chapter 6: `initial-xv6` (project 1b, but only worry about test 1)
6 | * Chapter 9: `scheduling-xv6-lottery` (project 2b)
7 | * Chapter 24: `vm-xv6-intro` (project 3b)
8 | * Chapter 28: `initial-xv6` (now pass test 2)
9 | * Chapter 29: `concurrency-xv6-threads` (project 4b)
10 | * Chapter 30: `concurrency-mapreduce` (project 4a)
11 | * Chapter 33: `concurrency-webserver` (not assigned in class)
12 | * Chapter 42: `filesystems-checker` (project 5a)
13 | * (there is no 5b, and there are no projects for chapters 43-51)
14 |
--------------------------------------------------------------------------------
/coursepages/ostep/Scheduling-xv6-lottery.md:
--------------------------------------------------------------------------------
1 | ## all thanks to [palladian](https://github.com/palladian1)
2 |
3 | ### General Tips
4 |
5 | * Read chapter 9 in the OSTEP book and watch the video for discussion 5. Lottery ticket schedulers aren't discussed in the lectures, so you really do have to read the book for this one.
6 |
7 | * In general, you can't use C standard library functions inside the kernel, because the kernel has to initialize before it can execute library binaries.
8 |
9 | * The xv6 kernel has a "kernel version" of `printf`; it takes an additional integer argument that tells it whether to print to `stdout` or `stderr`. Note that it can only handle basic format strings like `"%d"` and not more complex ones like `"%6.3g"`; you can deal with this by manually adding spaces instead. It also has another similar function, `cprintf`.
10 |
11 | * If you do want to use other library functions that aren't available inside the kernel (pseudo random number generators), you can see how those functions are implemented in P.J. Plauger's book, The Standard C Library, and then implement them yourself.
12 |
13 | ### Implementation
14 |
15 | * You'll have to modify the same files you did in Project 1b in order to add the two new system calls.
16 | * In order to understand how processes are created, remember that they start in the `EMBRYO` state before they become `RUNNABLE`--you'll have to find where that happens.
17 | * System calls always have argument type `void`, so take a look at how system calls like `kill` and `read` manage to work around that limitation and get arguments (like integers and pointers) from user space. You might have to back a few steps in the chain that executes them.
18 | * Make sure you're including `types.h` and `defs.h` wherever you need to access code from other parts of the kernel.
19 | * In order to create the xv6 command `ps`, look at how `cat`, `ls`, and `ln` are implemented. Make sure to modify the Makefile to include the source code for your `ps` command.
20 |
21 |
22 | ## Spoilers below!
23 |
24 | ### Solution walk through
25 |
26 | - Start from a fresh copy of the `xv6` source code.
27 |
28 | - `argint` and `argptr` are important functions. So `syscall`s take no arguments, but in reality, in user code you want to pass arguments to them.
29 |
30 | - So the way you do that is the kernel will call the `syscall`, say, `sys_kill()` with no arguments, then `sys_kill` will use `argint()` to get the arguments from the call stack, then pass that to a function `kill(int pid)`.
31 |
32 | - So you can see there's a bunch of `extern int sys_whatever` function declarations below that; that means that these functions are defined in another file and should be pulled in from there as function pointers.
33 |
34 | - And these `sys_whatever` functions are basically just wrappers for the real `syscall`, which doesn't have the `sys_` at the beginning. So you need to add `sys_settickets` and `sys_getpinfo` to that list of function declarations.
35 |
36 | - Then there's an array of function pointers; it's using this old-school C way of initializing arrays where you can do `int arr[] = { [0] 5, [1] 7}`.
37 |
38 | - And the names inside the square brackets `SYS_fork`, etc. are defined as preprocessor macros in another header file `syscall.h`.
39 |
40 | - So you need to add two more entries in the array with function pointers to `sys_settickets` and `sys_getpinfo`, and then you need to define `SYS_settickets` and `SYS_getpinfo` in the relevant header file.
41 |
42 | - So then all these `sys_` wrapper functions are defined in `sysproc.c`.
43 |
44 | - So there, you need to create `int sys_settickets(void)` and `int sys_getpinfo(void)`.
45 |
46 | - The real `settickets` function will need an int argument, so you need to use `argint` there to grab it from the call stack and pass it to `settickets`; similarly, `getpinfo` will need a pointer, so you'll use `argptr`.
47 |
48 | - Also, there's an extra condition in the if statement for `sys_settickets`; that's because you're not allowed to use a number of tickets below 1.
49 |
50 | - So then there's some assembly code that needs to run for each of the system calls; luckily, it's just a pre-written macro, so you don't have to write any assembly. that's in `usys.S`.
51 |
52 | - So you just add two lines at the bottom to create macros for `SYSCALL(settickets)` and `SYSCALL(getpinfo)`
53 |
54 | - Last part for the `syscalls`: you need to declare them in a header file for user code to be able to call them. that's in `user.h`.
55 |
56 | - So `struct pstat` will be properly defined in `pstat.h`, but you need to declare it in `user.h` as well so that user code doesn't complain when it sees it.
57 |
58 | - Basically, any user code that uses `syscalls` or C (really, `xv6`) standard library functions will have to include `user.h`.
59 |
60 | - So, so far, that's everything for the two system calls as far as the OS is concerned; now we just have to actually implement them with the regular functions `settickets` and `getpinfo`, then implement the scheduler and the `ps` program.
61 |
62 | - `pstat.h` is not for the scheduler, but for the `ps` program, which will work somewhat like the Linux `ps`. `pstat.h` is just to define the `struct pstat`, but there's no `.c` file to go with it.
63 |
64 | - So the scheduler will work by assigning 1 ticket by default to each process when it's created; then processes can set their own tickets using the `settickets` system call.
65 |
66 | - so first we need to make sure each process tracks its own tickets, then we need to assign a default of 1 ticket when creating them, then we need to write `settickets`.
67 |
68 | - the first part is in `proc.h`: processes are represented as a `struct proc`, so we add a new member for `int tickets`.
69 |
70 | - the `int ticks` member is for `ps`; I'll come back to that.
71 |
72 | - One other thing to note in `proc.h` is the `enum procstate`: you can see all the possible process states there. `EMBRYO` means it's in the process of creation; so what i did was `grep` for `EMBRYO` to find where the process was created in order to set the default tickets to 1. Turns out it's in `proc.c`.
73 |
74 | - Inside `proc.c`, there's a function `allocproc`, which initializes a process.
75 |
76 | - There's a process table called `ptable`, and `allocproc` looks through it to find an unused process.
77 |
78 | - Then when it does find it, it goes to create it; i added `p->tickets = 1;` there.
79 |
80 | - okay so the next change is to fit one of the requirements: child processes need to inherit the number of tickets from their parent process.
81 |
82 | - So child processes are created with `fork`, which is in the same file.
83 |
84 | - In `fork`, `curproc` is the current process, and `np` is the new process.
85 |
86 | - So i set `np->tickets = curproc->tickets`.
87 |
88 | - So the scheduler needs to generate a pseudo random number, then it should iterate through the process table with a counter initialized to 0, adding the number of tickets for each process to the counter. once the counter is greater than the pseudo random number, it stops and runs that process.
89 |
90 | - So I ended up looking in P.J. Plauger's The Standard C Library, which is just a big book of all the source code for the C library with commentary. It's pretty good; I don't know if it's still written that way though because the book is from the 80s.
91 |
92 | - So i just implemented C's `rand` and `srand` functions. `srand` sets a random seed (not so random, as you'll see later), then `rand` turns it into a pseudo random integer.
93 |
94 | - There's a bunch of type magic going on there between changes back and forth from integers to unsigned integers; that's to avoid signed integer overflow, which causes undefined behavior. unsigned integer overflow is okay though.
95 |
96 | - I only made one change to make it faster, which was to write `& 32767` instead of `% 32768`.
97 |
98 | - So you'll see the "random" seed i used: the number of `ticks`, which i think counts the number of timer interrupts so far.
99 |
100 | - Which is totally not random at all, since the first time this program gets run, it'll be 0, then 1, then 2, etc.
101 |
102 | - So there's some lines about counting `ticks`; that was for `ps`, not the scheduler.
103 |
104 | - The main change to make it a lottery scheduler is the counter variable.
105 |
106 | - And adding a for loop to count the total number of tickets that have been distributed.
107 |
108 | - So then at the very bottom of this file is the implementation of `settickets` and `getpinfo`.
109 |
110 | - So after initializing `counter` and `totaltickets`, there's for loop that counts the total numbers of tickets that have gone out to processes.
111 |
112 | - Then we get the winning ticket.
113 |
114 | - Let's discuss the original source code first. So first you acquire the lock. You'll release it at the very end. But in between, you have a for loop that iterates over all the processes in `ptable`.
115 |
116 | - Specifically, it iterates over only the processes in `RUNNABLE` state; if a process isn't `RUNNABLE`, it just `continue`s on to the next one. (This is for the round-robin scheduling mechanism that's already in the code.)
117 |
118 | - So now it's gonna switch to the very first `RUNNABLE` process it finds. Like, switching to executing it.
119 |
120 | - So first, `c` represents the current CPU. so it sets the current CPU to run the process it found with `c->proc = p;`.
121 |
122 | - Then it calls this function, `switchuvm(p)`, which sets up the virtual memory address space for `p`. Then it sets the process's state to `RUNNING`.
123 |
124 | - And then `swtch` is where the magic happens: that one swaps out the register contents of the OS and scheduler content with the saved-in-memory register contents of the process `p`.
125 |
126 | - So as soon as `swtch` executes, the CPU will continue executing instructions, but now they're the process's instructions. So this scheduler function just hangs there.
127 |
128 | - Eventually, when a timer interrupt goes off, the processor will use another `swtch` call but with the arguments reversed to swap the scheduler's register contents from memory into the CPU's registers and save the process's register contents. At which point execution will continue at this exact point.
129 |
130 | - So now `switchkvm` will set up the kernel's virtual memory address space.
131 |
132 | - These 5 lines are the context switch:
133 |
134 | ```c
135 | c->proc = p;
136 | switchuvm(p);
137 | p->state = RUNNING;
138 |
139 | swtch(&(c->scheduler), p->context);
140 | switchkvm();
141 | ```
142 |
143 | - So then we go on to the next iteration of the inner for loop, which finds the next `RUNNABLE` process and repeats.
144 |
145 | - Only once we've executed all the `RUNNABLE` processes do we exit the inner for loop and release the lock.
146 |
147 | - Original source code is structured like this (this is pseudocode):
148 |
149 | ```python
150 | while (1) {
151 | iterate over processes:
152 | if not runnable:
153 | continue
154 | run it
155 | ```
156 |
157 | - New code is structured like this (this is pseudocode):
158 |
159 | ```python
160 | while (1) {
161 | count the total tickets allotted to all processes // one for loop here
162 | get the winning ticket number
163 | iterate over processes: // another for loop here
164 | if not runnable:
165 | continue
166 | add its tickets to counter
167 | if counter <= winning ticket number:
168 | continue
169 | run it
170 | ```
171 |
172 | - We ignore the tickets of non-RUNNABLE processes.
173 |
174 | - So the tickets aren't numbered; each process just has a set amount of tickets, and we just count up until we've passed `n` tickets, where `n` is the winner.
175 |
176 | - For example if proc A has 5 tickets and proc B has 7, proc C has 2. if the winning number is 3, then A would run; if it's 8, then B would run; if it's 12, then C would run.
177 |
178 | - A winner in 0-4 would be A, 5-11 would be B, and 12-13 would be C.
179 |
180 | - So `settickets` is pretty basic: you just acquire a lock, set the tickets for the process, release the lock.
181 |
182 | - For `getpinfo` basically it works like this:
183 |
184 | - `p` is a pointer a `struct pstat`, as defined in `pstat.h`. each of its members is an array, with one entry per process.
185 |
186 | - Check for a null pointer.
187 |
188 | - Iterate over the process table and set `proc_i` to the i-th process.
189 |
190 | - Set the i-th entry of each member of `p` to the value for this process.
191 |
192 | - One last bookkeeping piece: we need to add declarations for `struct pstat` and the `settickets` and `getpinfo` system calls in `defs.h`.
193 |
194 | - And then the last file is `ps.c`, which implements the `ps` program, similar to Linux's `ps`. it just calls `getpinfo` to fill a `struct pstat`, then prints out the info for each process in use.
195 |
196 | - And then you just modify the Makefile to include `ps.c` in the compilation, and we're done!
197 |
198 | - Oh and this is why we needed the ticks in the scheduler: `ps` will print out how long each process has run.
199 |
200 | - So it needs to time the number of ticks that it actually executed.
201 |
202 | - FINALLY run `make qemu` in the `/src` directory to make sure it's all working.
203 |
--------------------------------------------------------------------------------
/coursepages/ostep/vm-xv6-intro.md:
--------------------------------------------------------------------------------
1 | Credit goes to [palladian](https://github.com/palladian1)
2 |
3 | ## Intro To xv6 Virtual Memory
4 |
5 | ### WARNING:
6 |
7 | ***The project doesn't match the currently available xv6 source code, which already has this project implemented in it!***
8 |
9 | [palladian](https://github.com/palladian1) tracked down a different xv6 source from the Github page of a U of Wisconsin student. We had to edit the `Makefile` to find the QEMU executable correctly. We added `null.c` to the `user` folder (also edited `makefile.mk` there), which demonstrates the lack of memory safety.
10 |
11 | Start with the code in [`start.zip`](https://github.com/spamegg1/reviews/raw/master/courses/OSTEP/ostep-projects/vm-xv6-intro/start.zip). Extract it and run `make clean` and `make qemu-nox`. Then inside the xv6 system run `null` to see the lack of safety! If you want to compare the results of `null` with the actual machine code, you can run `objdump -d user/null.o`.
12 |
13 | You might have to manually run `make clean` and `make qemu-nox` every time you make a change to the code.
14 |
--------------------------------------------------------------------------------
/extras/courses.md:
--------------------------------------------------------------------------------
1 | # Computer Science - Great Courses
2 |
3 | This is a list of high-quality courses that, for one reason or another, didn't make it into the curriculum.
4 | The most common reasons are that the course isn't available often enough,
5 | or that there was an alternative that fit better into the curriculum.
6 |
7 | ## Programming
8 |
9 | Courses | Duration | Effort
10 | :-- | :--: | :--:
11 | [Introduction to Computational Thinking and Data Science](https://www.edx.org/course/introduction-computational-thinking-data-mitx-6-00-2x-2#!)([alt](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-0002-introduction-to-computational-thinking-and-data-science-fall-2016/))| 10 weeks | 15 hours/week
12 | [Introduction to Computer Science - CS50](https://www.edx.org/course/introduction-computer-science-harvardx-cs50x#!) ([alt](https://cs50.harvard.edu/)) | 12 weeks | 10-20 hours/week
13 | [Introduction to Computer Science (Udacity)](https://www.udacity.com/course/intro-to-computer-science--cs101)| 7 weeks | 10-20 hours/week
14 | [An Introduction to Interactive Programming in Python (Part 1)](https://www.coursera.org/learn/interactive-python-1)| 5 weeks | -
15 | [An Introduction to Interactive Programming in Python (Part 2)](https://www.coursera.org/learn/interactive-python-2)| - | -
16 | [Computing In Python, Part I: Fundamentals and Procedural Programming](https://www.edx.org/course/computing-in-python-i-fundamentals-and-procedural-programming-0) | 5 weeks | 10 hours/week
17 | [Computing In Python, Part II: Control Structures](https://www.edx.org/course/computing-in-python-ii-control-structures-0) | 5 weeks | 10 hours/week
18 | [Computing In Python, Part III: Data Structures](https://www.edx.org/course/computing-in-python-iii-data-structures-0) | 5 weeks | 10 hours/week
19 | [Computing In Python, Part IV: Objects & Algorithms](https://www.edx.org/course/computing-in-python-iv-objects-algorithms-0) | 5 weeks | 10 hours/week
20 | [Programming Basics](https://www.edx.org/course/programming-basics-iitbombayx-cs101-1x)| 9 weeks | 8 hours/week
21 | [Object-Oriented Programming with Java](https://java-programming.mooc.fi/)| 14 weeks | 10 hours/week
22 | [Introduction to Programming with MATLAB](https://www.coursera.org/learn/matlab)| - | -
23 | [Introduction to Functional Programming](https://www.edx.org/course/introduction-functional-programming-delftx-fp101x-0)| 7 weeks | 4-6 hours/week
24 | [The Structure and Interpretation of Computer Programs](http://cs61a.org/) | - | -
25 | [Introduction to Haskell](https://www.seas.upenn.edu/~cis194/fall16/) | 14 weeks | 4 hours/week
26 |
27 | ## Math
28 |
29 | Courses | Duration | Effort
30 | :-- | :--: | :--:
31 | [Effective Thinking Through Mathematics](https://learning.edx.org/course/course-v1:UTAustinX+UT.9.10x+3T2016/home) | 4 weeks | 2 hours/week
32 | [Introduction to Mathematical Thinking](https://www.coursera.org/learn/mathematical-thinking) | 10 weeks | 10 hours/week
33 | [High School Math](https://www.khanacademy.org/math/high-school-math) | - | -
34 | [Precalculus](https://www.futurelearn.com/courses/precalculus) | 5 weeks | 6 hours/week
35 | [Advanced Precalculus](https://www.futurelearn.com/courses/advanced-precalculus) | 4 weeks | 5 hours/week
36 | [Introduction to Probability and Data](https://www.coursera.org/learn/probability-intro)| - | -
37 | [Linear Algebra (Strang)](https://ocw.mit.edu/courses/mathematics/18-06-linear-algebra-spring-2010/index.htm) | - | -
38 | [Introduction to Computational Thinking](https://computationalthinking.mit.edu/Spring21/#introduction_to_computational_thinking) | - | -
39 | [Multivariable Calculus](https://ocw.mit.edu/courses/mathematics/18-02sc-multivariable-calculus-fall-2010/index.htm) | 13 weeks | 12 hours/week
40 | [Introduction to Probability - The Science of Uncertainty](https://www.edx.org/course/introduction-probability-science-mitx-6-041x-2) | 18 weeks | 12 hours/week | [Multivariable Calculus](https://ocw.mit.edu/courses/mathematics/18-02sc-multivariable-calculus-fall-2010/index.htm)
41 |
42 | ## Systems
43 |
44 | Courses | Duration | Effort
45 | :-- | :--: | :--:
46 | [Cloud Computing / Distributed Programming](https://www.coursera.org/learn/cloud-computing) | 5 weeks | 5-10 hours/week
47 | [Introduction to Parallel Programming](https://classroom.udacity.com/courses/cs344) ([alt](https://www.youtube.com/playlist?list=PLGvfHSgImk4aweyWlhBXNF6XISY3um82_)) ([HW](https://colab.research.google.com/github/depctg/udacity-cs344-colab))| 12 weeks | 8-10 hours/week
48 | [Intro to Computer Systems](http://www.cs.cmu.edu/afs/cs.cmu.edu/academic/class/15213-f15/www/) ([Labs](http://csapp.cs.cmu.edu/3e/labs.html)) | 15 weeks | 12 hours/week
49 | [Great Ideas in Computer Architecture (Machine Structures)](https://inst.eecs.berkeley.edu/~cs61c/fa14/) ([Lectures](https://archive.org/details/ucberkeley_webcast_itunesu_915550404)) | 15 weeks | 12 hours/week
50 | [Computer Architecture](https://www.coursera.org/learn/comparch) | - | 5-8 hours/week
51 | [Operating System Engineering](http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-828-operating-system-engineering-fall-2012/) | - | -
52 | [Introduction to Operating Systems](https://www.udacity.com/course/introduction-to-operating-systems--ud923)| 8 weeks | 5-8 hours/week
53 | [Advanced Operating Systems](https://www.udacity.com/course/advanced-operating-systems--ud189)| 5 weeks | 5-8 hours/week
54 | [Computer Networking](https://www.udacity.com/course/computer-networking--ud436) | 12 weeks | 5-8 hours/week
55 |
56 | ## Theory
57 |
58 | Courses | Duration | Effort
59 | :-- | :--: | :--:
60 | [Algorithms, Part I](https://www.coursera.org/learn/algorithms-part1) | 6 weeks | 6-12 hours/week
61 | [Algorithms, Part II](https://www.coursera.org/learn/algorithms-part2) | 6 weeks | 6-12 hours/week
62 | [Analysis of Algorithms (Sedgewick)](https://www.coursera.org/learn/analysis-of-algorithms) | 6 weeks | 6-8 hours/week
63 | [Analysis of Algorithms (Skiena)](http://www3.cs.stonybrook.edu/~skiena/373/) | 15 weeks | 6-8 hours/week
64 | [Programming Challenges (Skiena)](http://www3.cs.stonybrook.edu/~skiena/392/) | 14 weeks | 6-8 hours/week
65 | [Data Structures and Algorithms (Specialization)](https://www.coursera.org/specializations/data-structures-algorithms) | 25 weeks | 3-10 hours/week
66 | [Algorithmic Thinking (Part 1)](https://www.coursera.org/learn/algorithmic-thinking-1/) | - | -
67 | [Algorithmic Thinking (Part 2)](https://www.coursera.org/learn/algorithmic-thinking-2/) | - | -
68 | [Statistical Mechanics: Algorithms and Computations](https://www.coursera.org/learn/statistical-mechanics/) | - | -
69 | [Approximation Algorithms Part I](https://www.coursera.org/learn/approximation-algorithms-part-1/) | - | -
70 | [Approximation Algorithms Part II](https://www.coursera.org/learn/approximation-algorithms-part-2/) | - | -
71 |
72 | ## Applications
73 |
74 | Courses | Duration | Effort
75 | :-- | :--: | :--:
76 | [Using Databases with Python](https://www.coursera.org/learn/python-databases) | 5 weeks | 2-3 hours/week
77 | [Database Systems](https://scs.hosted.panopto.com/Panopto/Pages/Sessions/List.aspx#folderID=%22ed2ee867-9610-4bad-94af-5d12c2ea47cd%22) | - | 27 hours
78 | [Database Management Essentials](https://www.coursera.org/learn/database-management) | 7 weeks | 4-6 hours/week
79 | [Intro to Artificial Intelligence](https://www.udacity.com/course/intro-to-artificial-intelligence--cs271)| 16 weeks | 6-10 hours/week
80 | [Intro to Machine Learning](https://www.udacity.com/course/intro-to-machine-learning--ud120)| 10 weeks | 6-10 hours/week
81 | [Machine Learning for Data Science and Analytics](https://www.edx.org/course/machine-learning-data-science-analytics-columbiax-ds102x-0)| 5 weeks | 7-10 hours/week
82 | [Big Data Science with the BD2K-LINCS Data Coordination and Integration Center](https://www.coursera.org/course/bd2klincs)| 7 weeks | 4-5 hours/week
83 |
84 | ## Tools
85 |
86 | Courses | Duration | Effort
87 | :-- | :--: | :--:
88 | [How to Use Git and GitHub](https://www.udacity.com/course/how-to-use-git-and-github--ud775) | 3 weeks | 2-3 hours/week
89 | [Kubernetes Certified Application Developer](https://www.udemy.com/course/certified-kubernetes-application-developer/) | 5 weeks | 2 hours/week
90 |
91 |
92 | # Online Learning - Great Courses
93 |
94 | Courses | Duration | Effort
95 | :-- | :--: | :--:
96 | [Learning How to Learn](https://www.coursera.org/learn/learning-how-to-learn) | 4 weeks | 2 hours/week
97 | [Mindshift](https://www.coursera.org/learn/mindshift) | 4 weeks | 2 hours/week
98 |
--------------------------------------------------------------------------------
/extras/other_curricula.md:
--------------------------------------------------------------------------------
1 | # Other curricula
2 |
3 | OSSU is one of a few efforts to inform learners how they can pursue computer science independently. Below are a few other such efforts.
4 |
5 | - [Google - Guide for Technical Development](https://www.google.com/about/careers/students/guide-to-technical-development.html)
6 | - [Teach Yourself Computer Science](https://teachyourselfcs.com/)
7 | - [Obtaining a Thorough CS Background Online](http://spin.atomicobject.com/2015/05/15/obtaining-thorough-cs-background-online/)
8 | - [P1xt](https://github.com/P1xt/p1xt-guides)
9 | - [Functional CS](https://functionalcs.github.io/curriculum/)
10 |
11 | What differentiates OSSU? OSSU is dedicated to how an individual can learn the undergraduate CS curriculum. This is why we use the [CS2013](../CURRICULAR_GUIDELINES.md) as our curricular guidelines. These guidelines are written by the two foremost professional organizations in computing.
12 |
13 | This approach has the benefit of clarifying to others the extent of a student's study and understanding. Students have gone from OSSU study into both tech industry employment and into Computer Science graduate school. We look forward to helping you do the same.
14 |
--------------------------------------------------------------------------------
/extras/puzzles-practice-plods.md:
--------------------------------------------------------------------------------
1 | # Computer Science - Puzzles, Practice and Plods
2 |
3 | **Some OSSUnians value sites that allow them to practice coding problems disconnected from a course.**
4 |
5 | > Solving "textbook" problems is easy because we've been prepped for them by the course. Solving a "real world" example is much more difficult because there is no hand-holding.
6 |
7 | [link](https://github.com/ossu/computer-science/issues/783#issuecomment-694187743)
8 |
9 | > So give us a problem where the parameters are laid out in x,y fashion, and we'll be able to code for it. But confront us with another problem, and it might stump us since we're still not practiced with thinking algorithmically or what have you.
10 |
11 | [link](https://github.com/ossu/computer-science/issues/783#issuecomment-694176898)
12 |
13 | **Others feel that its important not to get distracted by anxieties and puzzles.**
14 |
15 | > Consider this a love letter to all the beginners out there.
16 |
17 | > I think that when you are still in the beginner stages, it FEELS like you do not have enough competence to contributing to a project.
18 | It FEELS like taking classes, doing programming assignments etc. are not good enough in your eyes to be considered worthy of a "project".
19 | They feel too small and insignificant. You're not quite satisfied.
20 | (Part of the reason might be that early stuff is too easy for you, and you haven't taken a course that kicked your ass and wiped the floor with you yet.)
21 | Since this is online learning and there is nobody/nothing holding you back, the natural tendency is to spread wide and try to do many things all at once, get distracted.
22 | I'VE BEEN THERE, trust me.
23 | And naturally you are in a rush to become competent as fast as possible.
24 | You keep thinking, "when will I be ready to do something BIG?" And you don't want to wait.
25 | Similar to how children always seem like they are in a hurry to grow up and start imitating adults.
26 | The dissatisfaction and the impatience make for an uncomfortable combination.
27 | Let's call this: beginner's mind.
28 |
29 | > The fact is, you have to be patient.
30 | I would argue that early on in your studies, arguably, is NOT when it is most critical for you to contribute to a project...
31 |
32 | > I would recommend the slow, steady and patient approach of OSSU over the distracted, all over the place style of learning lots of others use, with various uncoordinated resources on the internet.
33 | Looking for a project? How about THE NEXT COURSE?
34 |
35 | > So I think that the problem is not really a problem, but a need to adjust expectations.
36 | I would recommend a shift in thinking, away from beginner's mind.
37 | Think long term, so that those small, insignificant exercises and programming assignments in each course should feel like they are crucial parts of your biggest, long-term project: YOU
38 |
39 | [link](https://github.com/ossu/computer-science/issues/783#issuecomment-690023645)
40 |
41 | So OSSUnian, read the above and then consider how much time you wish to put into these resources:
42 | - [Exercism](https://exercism.io/)
43 | - [LeetCode](https://leetcode.com/)
44 | - [HackerRank](https://www.hackerrank.com/)
45 | - [CodeWars](https://www.codewars.com/)
46 | - [100+ Python Coding Problems with Solutions](https://github.com/ProgrammingHero1/100-plus-python-coding-problems-with-solutions)
47 | - [Rosalind](http://rosalind.info/problems/locations/)
48 | - [Advent of Code](https://adventofcode.com/)
49 | - [GitHub projects for beginners](https://github.com/MunGell/awesome-for-beginners) - Projects that are specifically geared towards beginners to GitHub. Possibly intermediate to advanced coding issues to be solved.
50 |
--------------------------------------------------------------------------------
/extras/readings.md:
--------------------------------------------------------------------------------
1 | # Computer Science - Great Readings
2 |
3 | This document consists of great books or articles on computer science.
4 | Some are here because there is a course covering the same material;
5 | some are just great books that you should read at some point in your career.
6 |
7 | Once you have made it through most of the curriculum, knowing whether a book is worth your time will become easier.
8 | Or, if you are struggling in one of the courses, perhaps reading a book on the subject will help.
9 |
10 | ## Programming
11 |
12 | Name | Author(s)
13 | :-- | :--:
14 | [Introduction to Computation and Programming Using Python 3e](https://mitpress.mit.edu/books/introduction-computation-and-programming-using-python-third-edition) | John V. Guttag
15 | [Think Python 2e](http://greenteapress.com/wp/think-python-2e/) | Allen B. Downey
16 | [How to Design Programs 2e](https://www.htdp.org/) | Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi
17 | [Structure and Interpretation of Computer Programs 2e](https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book.html) | Hal Abelson, Jerry Sussman, Julie Sussman
18 | [Concepts, Techniques, and Models of Computer Programming](https://www.amazon.com/gp/product/0262220695) | Peter Van Roy, Seif Haridi
19 | [Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612) | Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides
20 | [Refactoring](https://www.refactoring.com/) | Martin Fowler
21 | [Clean Code](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) | Robert Martin
22 | [Code Complete 2e](https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670) | Steve McConnell
23 | [The Pragmatic Programmer 2e](https://pragprog.com/titles/tpp20/the-pragmatic-programmer-20th-anniversary-edition/) | Andrew Hunt, David Thomas
24 | [Programming Languages: Application and Interpretation](http://cs.brown.edu/~sk/Publications/Books/ProgLangs/) | Shriram Krishnamurthi
25 | [Programming and Programming Languages](https://papl.cs.brown.edu/2018/) | Shriram Krishnamurthi, Benjamin S. Lerner, Joe Gibbs Politz
26 | [Competitive Programming](https://cpbook.net/) | Steven Halim, Felix Halim
27 | [Introduction to computing in Java](https://introcs.cs.princeton.edu/java/home/) | Robert Sedgewick, Kevin Wayne
28 |
29 | ## Math
30 |
31 | Name | Author(s)
32 | :-- | :--:
33 | [Calculus Made Easy](http://www.gutenberg.org/ebooks/33283) | Silvanus P. Thompson
34 | [Ximera: Interactive Calculus Textbooks](https://ximera.osu.edu/) | [Ximera team](https://ximera.osu.edu/about/team)
35 | [Discrete Mathematics with Applications (4th Edition)](http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/) | Susanna S. Epp
36 | [Discrete Mathematics: An Open Introduction](http://discrete.openmathbooks.org/dmoi/) | Oscar Levin
37 | [Applied Discrete Structures](http://faculty.uml.edu/klevasseur/ads2/) | Alan Doerr, Ken Levasseur
38 | [Grinstead and Snell’s Introduction to Probability](https://math.dartmouth.edu/~prob/prob/prob.pdf) | Charles M. Grinstead, J. Laurie Snell
39 | [Linear Algebra for Everyone](https://math.mit.edu/~gs/everyone/) | Gilbert Strang
40 | [The Art of Linear Algebra](https://github.com/kenjihiranabe/The-Art-of-Linear-Algebra) | Kenji Hiranabe, Gilbert Strang
41 |
42 | ## Systems
43 |
44 | Name | Author(s)
45 | :-- | :--:
46 | [But How Do It Know?](http://www.buthowdoitknow.com/) | J. Clark Scott
47 | [Computer Systems: A Programmer's Perspective (3rd Edition)](http://csapp.cs.cmu.edu/) | Randal E. Bryant, David R. O'Hallaron
48 | [Modern Operating Systems (4th Edition)](http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X/) | Andrew S. Tanenbaum, Herbert Bos
49 | [Computer Organization and Design: The Hardware/Software Interface (6th Edition)](https://www.amazon.com/Computer-Organization-Design-MIPS-Architecture/dp/0128201096/) | David Patternson, John Hennessy
50 | [Computer Networks (5th Edition)](http://www.amazon.com/Computer-Networks-5th-Andrew-Tanenbaum/dp/0132126958/) | Andrew S. Tanenbaum, David J. Wetherall
51 | [Computer Networking: A Top-Down Approach (8th Edition)](https://gaia.cs.umass.edu/kurose_ross/index.html) | James F Kurose, Keith W Ross
52 | [Distributed Systems: Principles and Paradigms](https://www.amazon.com/Distributed-Systems-Principles-Andrew-Tanenbaum/dp/153028175X) | Andrew Tanenbaum
53 | [Operating Systems Design and Implementation](https://www.amazon.com/Operating-Systems-Design-Implementation-3rd/dp/0131429388) | Andrew S. Tanenbaum, Albert S. Woodhull
54 | [Crafting Interpreters](https://www.craftinginterpreters.com/contents.html) | Robert Nystrom
55 | [Principles of Compiler Design](https://www.amazon.com/Principles-Compiler-Addison-Wesley-information-processing/dp/0201000229) | Alfred Aho, Jeffrey Ullman
56 | [Distributed Systems Reading Group](http://dsrg.pdos.csail.mit.edu/papers/) | Various
57 | [System Design: Design large-scale systems](https://github.com/donnemartin/system-design-primer) | Various
58 |
59 | ## Theory
60 |
61 | Name | Author(s)
62 | :-- | :--:
63 | [Introduction to Computing: Explorations in Language, Logic, and Machines](http://www.computingbook.org/) | David Evans
64 | [Introduction to the Theory of Computation (3rd Edition)](https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X) | Michael Sipser
65 | [Introduction to Algorithms (3rd Edition)](http://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844/) | Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein
66 | [The Algorithm Design Manual (3rd Edition)](https://www.algorist.com/) | Steven Skiena
67 | [Algorithms (4th Edition)](https://algs4.cs.princeton.edu/home/) | Robert Sedgewick
68 | [Category Theory: A Gentle Introduction](http://www.logicmatters.net/resources/pdfs/GentleIntro.pdf) | Peter Smith
69 | [Category Theory for Programmers: The Preface](https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/) | Bartosz Milewski
70 | [An Introduction to Information Retrieval](https://nlp.stanford.edu/IR-book/pdf/irbookonlinereading.pdf) | Christopher D. Manning, Prabhakar Raghavan, Hinrich Schütze
71 | [Computer Science: An interdisciplinary approach](https://introcs.cs.princeton.edu/java/cs/) | Robert Sedgewick, Kevin Wayne
72 | [DSA CS3: Data Structures & Algorithms](https://opendsa-server.cs.vt.edu/OpenDSA/Books/CS3/html/) ([Coursenotes](https://opendsa-server.cs.vt.edu/OpenDSA/Books/CS3notes/html/) - [Slides](https://opendsa-server.cs.vt.edu/OpenDSA/Books/CS3slides/html/)) | The OpenDSA Project (supported by National Science Foundation)
73 |
74 | ## Applications
75 |
76 | Name | Author(s)
77 | :-- | :--:
78 | [Architecture of a Database System](http://db.cs.berkeley.edu/papers/fntdb07-architecture.pdf) | Joseph M. Hellerstein, Michael Stonebraker, James Hamilton
79 | [Readings in Database Systems (5th Edition)](http://www.redbook.io/) | Peter Bailis, Joseph M. Hellerstein, Michael Stonebraker, editors
80 | [Database Management Systems (3rd Edition)](https://www.amazon.com/gp/product/0072465638) | Raghu Ramakrishnan, Johannes Gehrke
81 | [Transaction Processing: Concepts and Techniques](https://www.amazon.com/Transaction-Processing-Concepts-Techniques-Management/dp/1558601902) | Jim Gray, Andreas Reuter
82 | [Data and Reality: A Timeless Perspective on Perceiving and Managing Information in Our Imprecise World (3rd Edition)](https://www.amazon.com/Data-Reality-Perspective-Perceiving-Information/dp/1935504215) | William Kent
83 | [The Architecture of Open Source Applications](http://aosabook.org/en/) | Michael DiBernardo (editor)
84 | [An Introduction to Statistical Learning](https://www-bcf.usc.edu/~gareth/ISL/) | Gareth James, Daniela Witten, Trevor Hastie and Robert Tibshirani
85 | [Deep Learning](http://www.deeplearningbook.org/) | Ian Goodfellow, Yoshua Bengio and Aaron Courville
86 | [Bayesian Reasoning and Machine Learning](http://web4.cs.ucl.ac.uk/staff/D.Barber/pmwiki/pmwiki.php?n=Brml.HomePage) | David Barber
87 | [Language Implementation Patterns](https://www.amazon.com/gp/product/193435645X) | Terence Parr
88 | [Compilers: Principles, Techniques, and Tools (2nd Edition)](http://www.amazon.com/Compilers-Principles-Techniques-Tools-2nd/dp/0321486811/) | Alfred V. Aho, Monica S. Lam, Ravi Sethi, Jeffrey D. Ullman
89 | [Compiler Construction](https://inf.ethz.ch/personal/wirth/CompilerConstruction/index.html) | Niklaus Wirth
90 | [The Mythical Man-Month](https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959/) | Fred Brooks, Jr.
91 | [Physically Based Rendering: From Theory To Implementation](http://www.pbr-book.org/) | Matt Pharr, Wenzel Jakob, and Greg Humphreys
92 |
93 |
94 | ## Tools
95 |
96 | Name | Author(s)
97 | :-- | :--:
98 | [The Linux Command Line](https://linuxcommand.org/tlcl.php) | by William Shotts
99 |
--------------------------------------------------------------------------------