gf4
/
OSSU-computer-science
mirror of https://git.hackliberty.org/Awesome-Mirrors/OSSU-computer-science
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'hanjiexi-overhaul'

pull/344/merge
Eric Douglas 2017-04-11 07:04:54 -03:00
parent 6b5358a730 1175161240
commit bd30d61d09
12 changed files with 778 additions and 1056 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
CHANGELOG.md
View File

@ -1,7 +1,104 @@
# Change Log
All notable changes to this project will be documented in this file.
This project adheres to [Semantic Versioning](http://semver.org/).
This project adheres *in spirit* to [Semantic Versioning](http://semver.org/):
- "MAJOR" updates correspond to changing the topics studied within a subject
- "MINOR" updates correspond to changing courses without changing the topics
- "PATCH" updates correspond to aesthetic and non-essential additions/removals or changing order of classes for better progression
## [7.1.0] 2017-04-10
### Updated
- Reverted reformat of programming languages course
### Added
- Reliable Distributed Algorithms courses
- New Introduction to CS course
## [7.0.2] 2017-03-30
### Updated
- Moved optional online learning courses to extras/courses in a new section
- Moved alternate computer architecture course to extras/courses
### Added
- Scala specialization under Advanced applications
### Removed
- Removed all but one choice for required readings to make the curriculum simpler
## [7.0.1] 2017-03-11
### Updated
- Fixed link to Bradfield's DIY computer science page
### Added
- Note under Calculus One with links to errata and course progression recommendations
- Optional courses under extras:
- Strang's course on linear algebra
- Berkeley's Structure and Interpretation of Computer Programs
- Optional readings under extras:
- Van Roy's advanced programming book
- P&H's computer architecture book
- Skiena's algorithms book
- Strang's linear algebra book
- Database Management Systems book
- Tarr's book on creating your own Domain-specific language
- Readings from various authors on distributed systems
## [7.0] 2017-03-09
Complete overhaul of program structure
### Updated
- Clarified contributor guidelines and moved them to separated file
- Switched from many subjects to just four subjects with many topics
- Consolidated free-books.md and paid-books.md into readings.md
- Consolidated free-courses.md and paid-courses.md into courses.md
- Replace old "How to Code" with new "How to Code" (Software Development MicroMasters)
- Replace Princeton Algorithms (moved to [alternative courses](#extras/courses.md)) with Stanford Algorithms
### Added
- Indicate prerequisites for all courses
- Requirements: subject/topic requirements and project requirements
- Required readings on Haskell, Prolog, Operating Systems
- Courses: Dan Grossman's Programming Languages
- Courses: From Nand to Tetris
- Elective course: Intro to Parallel Programming
- Elective course: LAFF: Programming for Correctness
- Elective course: Introduction to Mathematical Thinking
- Elective courses: Electricity and Magnetism
- Elective courses: MIT's Computation Structures
- Elective course: Multivariable Calculus
- Elective course: ops-class.org
- Elective course: Automata Theory
- Elective course: Introduction to Logic
- Elective course: Computational Geometry
- Elective course: Formal Concept Analysis
- Elective course: Game Theory
- Elective specializations:
- Robotics
- Data Minig
- Big Data
- Internet of Things
- Cloud Computing
- Full Stack Web Development
- Data Science
- Pro specializations:
- Mastering Software Development in R
- Artificial Intelligence Engineer
- Machine Learning Engineer
- Cybersecurity
- Android Developer
### Removed
- Removed many dead links and obsolete courses
- Removed per-course project requirement
- Course: Object-Oriented Programming in Java
- Course: Funtional Programming in Scala
- Course: Computer Architecture (but left as a footnote)
- Course: Intro to Theoretical Computer Science
- Course: Software Processes and Agile Practices
- Course: Operating Systems & System Programming
- Course: Introduction to Cyber Security
- Course: Parallel Computer Architecture and Programming
- Course: UX Design for Mobile Developers
## [6.0] 2016-10-09
### Updated

12
CONTRIBUTING.md Normal file
View File

@ -0,0 +1,12 @@
# Contributor guidelines
This project primarily uses GitHub for collaboration, however not all discussions are appropriate for GitHub.
Please follow these guidelines:
1. If you need help with the *academic* content of a course or are having general technical difficulties, please do not use GitHub for this.
The best place to ask these types of questions is on the [subreddit](https://www.reddit.com/r/opensourcesociety/).
2. If you have general problems with the program not specific to any course, such as preferring textbook-style learning over MOOCs,
the subreddit is recommended as there people may be able to give you suggested alternatives.
3. If you have *specific* and *substantive* criticisms of the curriculum, i.e. problems related to the progression/content of courses it would be appropriate to [open an issue](https://help.github.com/articles/creating-an-issue/) and give us your suggestions.
4. If you have *non-substantive* updates to make to the curriculum, such as a course's URL having been moved, spelling/syntax errors, etc., please send a [pull request](https://help.github.com/articles/using-pull-requests/) to fix any mistakes that you have found.
5. If you want to customize the curriculum for yourself, do of course [fork this project](https://help.github.com/articles/fork-a-repo/).
6. If you want to suggest a new resource, send a pull request adding such resource to the [extras](https://github.com/open-source-society/computer-science/tree/master/extras) section.

2
LICENSE
View File

@ -1,6 +1,6 @@
The MIT License (MIT)
Copyright (c) 2015 Open Source Society
Copyright (c) 2017 Open Source Society
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal

826
README.md
View File

@ -1,8 +1,8 @@
![Open Source Society University (OSSU)](http://i.imgur.com/GjEbgIJ.png)
![Open Source Society University (OSSU)](http://i.imgur.com/Cxv8DM4.png)
<h3 align="center">Open Source Society University</h3>
<p align="center">
Path to a free self-taught education in Computer Science!
Path to a self-taught education in Computer Science!
</p>
<p align="center">
<a href="https://github.com/sindresorhus/awesome">
@ -13,425 +13,500 @@
</a>
</p>
## Contents
# Contents
- [About](#about)
- [Motivation & Preparation](#motivation--preparation)
- [Summary](#summary)
- [Curriculum](#curriculum)
- [How to use this guide](#how-to-use-this-guide)
- [Prerequisite](#prerequisite)
- [How to collaborate](#how-to-collaborate)
- [Prerequisites](#prerequisites)
- [Intro CS](#intro-cs)
- [Core CS](#core-cs)
- [Advanced CS](#advanced-cs)
- [Final project](#final-project)
- [Pro CS](#pro-cs)
- [Community](#community)
- [Team](#team)
- [How to show your progress](#how-to-show-your-progress)
- [Team](#team)
- [References](#references)
## About
# Summary
This is a **solid path** for those of you who want to complete a **Computer Science** course on your own time, **for free**, with courses from the **best universities** in the World.
The OSSU curriculum is a **complete education in computer science** using online materials.
It's not merely for career training or professional development.
It's for those who want a proper, *well-rounded* grounding in concepts fundamental to all computing disciplines,
and for those who have the discipline, will, and (most importantly!) good habits to obtain this education largely on their own,
but with support from a worldwide community of fellow learners.
In our curriculum, we give preference to MOOC (Massive Open Online Course) style courses because these courses were created with our style of learning in mind.
It is designed according to the degree requirements of undergraduate computer science majors, minus general education (non-CS) requirements,
as it is assumed most of the people following this curriculum are already educated outside the field of CS.
The courses themselves are among the very best in the world, often coming from Harvard, Princeton, MIT, etc.,
but specifically chosen to meet the following criteria.
## Motivation & Preparation
**Courses must**:
- Be open for enrollment
- Run regularly (ideally in self-paced format, otherwise running at least once a month or so)
- Fulfill the [academic requirements](REQUIREMENTS.md) of OSSU
- Fit neatly into the progression of the curriculum with respect to topics and difficulty level
- Be of generally high quality in teaching materials and pedagogical principles
Here are two interesting links that can make **all** the difference in your journey.
When no course meets the above criteria, the coursework is supplemented with a book.
When there are courses or books that don't fit into the curriculum but are otherwise of high quality,
they belong in [extras/courses](extras/courses.md) or [extras/readings](extras/readings.md).
The first one is a motivational video that shows a guy that went through the "MIT Challenge", which consists of learning the entire **4-year** MIT curriculum for Computer Science in **1 year**.
**Organization**. The curriculum is designed as follows:
- *Intro CS*: for students to try out CS and see if it's right for them
- *Core CS*: corresponds roughly to the first three years of a computer science curriculum, taking classes that all majors would be required to take
- *Advanced CS*: corresponds roughly to the final year of a computer science curriculum, taking electives according to the student's interests
- *Final Project*: a project for students to validate, consolidate, and display their knowledge, to be evaluated by their peers worldwide
- *Pro CS*: graduate-level specializations students can elect to take after completing the above curriculum if they want to maximize their chances of getting a good job
- [MIT Challenge](https://www.scotthyoung.com/blog/myprojects/mit-challenge-2/)
**Duration**. It is possible to finish Core CS within about 2 years if you plan carefully and devote roughly 18-22 hours/week to your studies.
Courses in Core CS should be taken linearly if possible, but since a perfectly linear progression is rarely possible,
each class's prerequisites is specified so that you can design a logical but non-linear progression
based on the class schedules and your own life plans.
The second link is a MOOC that will teach you learning techniques used by experts in art, music, literature, math, science, sports, and many other disciplines. These are **fundamental abilities** to succeed in our journey.
**Cost**. All or nearly all course material prior to Pro CS is available for free,
however some courses may charge money for assignments/tests/projects to be graded.
Note that Coursera offers [financial aid](https://learner.coursera.help/hc/en-us/articles/209819033-Apply-for-Financial-Aid).
Decide how much or how little to spend based on your own time and budget;
just remember that you can't purchase success!
- [Learning How to Learn](https://www.coursera.org/learn/learning-how-to-learn)
**Content policy**. If you plan on showing off some of your coursework publicly, you must share only files that you are allowed to.
*Do NOT disrespect the code of conduct* that you signed in the beginning of each course!
**Are you ready to get started?**
**How to contribute**. Please see [CONTRIBUTING](CONTRIBUTING.md).
## Curriculum
# Curriculum
- [Introduction to Computer Science](#introduction-to-computer-science)
- [Math (Mathematical Thinking)](#math-mathematical-thinking)
- [Program Design](#program-design)
- [Math (Calculus & Discrete Math)](#math-calculus-and-discrete-math)
- [Algorithms](#algorithms)
- [Programming Paradigms](#programming-paradigms)
- [Software Testing](#software-testing)
- [Math (Calculus)](#math-calculus)
- [Software Architecture](#software-architecture)
- [Theory](#theory)
- [Software Engineering](#software-engineering)
- [Math (Probability)](#math-probability)
- [Computer Architecture](#computer-architecture)
- [Operating Systems](#operating-systems)
- [Computer Networks](#computer-networks)
- [Databases](#databases)
- [Cloud Computing](#cloud-computing)
- [Math (Linear Algebra)](#math-linear-algebra)
- [Cryptography](#cryptography)
- [Security](#security)
- [Compilers](#compilers)
- [Parallel Computing](#parallel-computing)
- [UX Design](#ux-design)
- [Computer Graphics](#computer-graphics)
- [Artificial Intelligence](#artificial-intelligence)
- [Machine Learning](#machine-learning)
- [Natural Language Processing](#natural-language-processing)
- [Big Data](#big-data)
- [Data Mining](#data-mining)
- [Internet of Things](#internet-of-things)
- [Specializations](#specializations)
**Curriculum version**: `7.1.0` (see [CHANGELOG](CHANGELOG.md))
- [Prerequisites](#prerequisites)
- [Intro CS](#intro-cs)
- [Core CS](#core-cs)
- [Core programming](#core-programming)
- [Core math](#core-math)
- [Core systems](#core-systems)
- [Core theory](#core-theory)
- [Core applications](#core-applications)
- [Advanced CS](#advanced-cs)
- [Advanced programming](#advanced-programming)
- [Advanced math](#advanced-math)
- [Advanced systems](#advanced-systems)
- [Advanced theory](#advanced-theory)
- [Advanced applications](#advanced-applications)
- [Final project](#final-project)
- [Pro CS](#pro-cs)
---
### Introduction to Computer Science
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Computer Science - CS50](https://www.edx.org/course/introduction-computer-science-harvardx-cs50x#!)| 12 weeks | 10-20 hours/week
### Math (Mathematical Thinking)
Courses | Duration | Effort
:-- | :--: | :--:
[Effective Thinking Through Mathematics](https://www.edx.org/course/effective-thinking-through-mathematics-utaustinx-ut-9-01x) | 9 weeks | 5 hours/week
### Program Design
Courses | Duration | Effort
:-- | :--: | :--:
[How to Code: Systematic Program Design - Part 1](https://www.edx.org/course/how-code-systematic-program-design-part-ubcx-spd1x)| 5 weeks | 8-12 hours/week
[How to Code: Systematic Program Design - Part 2](https://www.edx.org/course/how-code-systematic-program-design-part-ubcx-spd2x)| 5 weeks | 8-12 hours/week
[How to Code: Systematic Program Design - Part 3](https://www.edx.org/course/how-code-systematic-program-design-part-ubcx-spd3x)| 5 weeks | 8-12 hours/week
### Math (Calculus and Discrete Math)
Courses | Duration | Effort
:-- | :--: | :--:
[Calculus One](https://www.coursera.org/learn/calculus1)| 16 weeks | 8-10 hours/week
[Mathematics for Computer Science](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-spring-2015/index.htm)| 12 weeks | 5 hours/week
### Algorithms
Courses | Duration | Effort
:-- | :--: | :--:
[Algorithms, Part I](https://www.coursera.org/course/algs4partI)| 6 weeks | 6-12 hours/week
[Algorithms, Part II](https://www.coursera.org/course/algs4partII)| 6 weeks | 6-12 hours/week
### Programming Paradigms
Courses | Duration | Effort
:-- | :--: | :--:
[Functional Programming Principles in Scala](https://www.coursera.org/course/progfun)| 7 weeks | 5-7 hours/week
[Object Oriented Programming in Java](https://www.coursera.org/learn/object-oriented-java) | 6 weeks | 4-6 hours/week
### Software Testing
Courses | Duration | Effort
:-- | :--: | :--:
[Software Testing](https://www.udacity.com/course/software-testing--cs258)| 4 weeks | 6 hours/week
[Software Debugging](https://www.udacity.com/course/software-debugging--cs259)| 8 weeks | 6 hours/week
### Math (Calculus)
Courses | Duration | Effort
:-- | :--: | :--:
[Calculus Two: Sequences and Series](https://www.coursera.org/learn/advanced-calculus)| 7 weeks | 9-10 hours/week
### Software Architecture
Courses | Duration | Effort
:-- | :--: | :--:
[Software Architecture & Design](https://www.udacity.com/course/software-architecture-design--ud821)| 8 weeks | 6 hours/week
### Theory
Courses | Duration | Effort
:-- | :--: | :--:
[Intro to Theoretical Computer Science](https://www.udacity.com/course/intro-to-theoretical-computer-science--cs313)| 9 weeks | 6 hours/week
### Software Engineering
Courses | Duration | Effort
:-- | :--: | :--:
[Software Processes and Agile Practices](https://www.coursera.org/learn/software-processes-and-agile-practices)| 4 weeks | 6-8 hours/week
### Math (Probability)
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Probability - The Science of Uncertainty](https://www.edx.org/course/introduction-probability-science-mitx-6-041x-0)| 16 weeks | 12 hours/week
### Computer Architecture
Courses | Duration | Effort
:-- | :--: | :--:
[Computer Architecture](https://www.coursera.org/course/comparch)| - | 5-8 hours/week
### Operating Systems
Courses | Duration | Effort
:-- | :--: | :--:
[Operating Systems and System Programming](https://www.youtube.com/view_play_list?p=-XXv-cvA_iBDyz-ba4yDskqMDY6A1w_c)| 10 weeks | 2-3 hours/week
### Computer Networks
Courses | Duration | Effort
:-- | :--: | :--:
[Computer Networks](https://lagunita.stanford.edu/courses/Engineering/Networking-SP/SelfPaced/about)| - | 4–12 hours/week
### Databases
Courses | Duration | Effort
:-- | :--: | :--:
[Databases](https://lagunita.stanford.edu/courses/DB/2014/SelfPaced/about)| 12 weeks | 8-12 hours/week
### Cloud Computing
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Cloud Computing](https://www.edx.org/course/introduction-cloud-computing-ieeex-cloudintro-x-0)| 4 weeks | 1 hour/week
### Math (Linear Algebra)
Courses | Duration | Effort
:-- | :--: | :--:
[Linear Algebra - Foundations to Frontiers](https://www.edx.org/course/linear-algebra-foundations-frontiers-utaustinx-ut-5-04x#!)| 15 weeks | 8 hours/week
### Cryptography
Courses | Duration | Effort
:-- | :--: | :--:
[Cryptography I](https://www.coursera.org/course/crypto)| 6 weeks | 5-7 hours/week
[Cryptography II](https://www.coursera.org/course/crypto2)| 6 weeks | 6-8 hours/week
### Security
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Cyber Security](https://www.futurelearn.com/courses/introduction-to-cyber-security) | 8 weeks | 3 hours/week
### Compilers
Courses | Duration | Effort
:-- | :--: | :--:
[Compilers](https://lagunita.stanford.edu/courses/Engineering/Compilers/Fall2014/about)| 9 weeks | 6-8 hours/week
### Parallel Computing
Courses | Duration | Effort
:-- | :--: | :--:
[Parallel Computer Architecture and Programming](http://15418.courses.cs.cmu.edu/spring2016/home)| 20 weeks | -
### UX Design
Courses | Duration | Effort
:-- | :--: | :--:
[UX Design for Mobile Developers](https://www.udacity.com/course/ux-design-for-mobile-developers--ud849)| 6 weeks | 6 hours/week
### Computer Graphics
Courses | Duration | Effort
:-- | :--: | :--:
[Computer Graphics](https://www.edx.org/course/computer-graphics-uc-san-diegox-cse167x)| 6 weeks | 12 hours/week
### Artificial Intelligence
Courses | Duration | Effort
:-- | :--: | :--:
[Artificial Intelligence](https://www.edx.org/course/artificial-intelligence-uc-berkeleyx-cs188-1x#!)| 12 weeks | 15 hours/week
### Machine Learning
Courses | Duration | Effort
:-- | :--: | :--:
[Machine Learning](https://www.coursera.org/learn/machine-learning)| 11 weeks | 4-6 hours/week
### Natural Language Processing
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Natural Language Processing](https://www.coursera.org/learn/natural-language-processing)| 12 weeks | -
### Big Data
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Big Data](https://www.coursera.org/learn/big-data-introduction)| 3 weeks | 5-6 hours/week
### Data Mining
Courses | Duration | Effort
:-- | :--: | :--:
[Pattern Discovery in Data Mining](https://www.coursera.org/course/patterndiscovery) | 4 weeks | 4-6 hours/week
### Internet of Things
Courses | Duration | Effort
:-- | :--: | :--:
[The Internet of Things](https://www.futurelearn.com/courses/internet-of-things)| 4 weeks | 2 hours/week
### Specializations
After finishing the courses above, start your specializations on the topics that you have more interest.
The following platforms currently offer specializations:
#### edX: [xSeries](https://www.edx.org/xseries)
#### Coursera: [Specializations](https://www.coursera.org/specializations)
#### Udacity: [Nanodegree](https://www.udacity.com/nanodegree)
#### FutureLearn: [Collections](https://www.futurelearn.com/courses/collections)
![keep learning](http://i.imgur.com/REQK0VU.jpg)
## How to use this guide
### Order of the classes
This guide was developed to be consumed in a linear approach. What does this mean? That you should complete one course at a time.
The courses are **already** in the order you should complete them. Just start in the [Introduction to Computer Science](#introduction-to-computer-science) section and after finishing the first course, start the next one.
**OBS:** If the course is not open, do it with the archived resources or wait until next class is open.
### How to track and show your progress
1. Create an account in [Trello](https://trello.com/).
1. Copy [this](https://trello.com/b/9DPXYv5f) board to your personal account. See how to copy a board [here](http://blog.trello.com/you-can-copy-boards-now-finally/).
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.
We also have **labels** to help you have more control through the process. The meaning of each of these labels is:
- `Main Curriculum`: cards with that label represent courses that are listed in our curriculum.
- `Extra Courses`: cards with that label represent courses that was added by the student.
- `Doing`: cards with that label represent courses the student is current doing.
- `Done`: cards with that label represent courses finished by the student. Those cards should also have the link for at least one project/article built with the knowledge acquired in such course.
- `Section`: cards with that label represent the section that we have in our curriculum. Those cards with the `Section` label are only to help the organization of the Done column. You should put the *Course's cards* below its respective *Section's card*.
- `Extra Sections`: cards with that label represent sections that was added by the student.
The intention of this board is to provide for 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. You can change the status of your board to be **public** or **private**.
### Should I take all courses?
**Yes!** The intention is to conclude **all** the courses listed here!
### Duration of the project
It may take longer to complete all of the classes compared to a regular CS course, but I can **guarantee** you that your **reward** will be proportional to **your motivation/dedication**!
You must focus on your **habit**, and **forget** about goals. Try to invest 1 ~ 2 hours **every day** studying this curriculum. If you do this, **inevitably** you'll finish this curriculum.
> See more about "Commit to a process, not a goal" [here](http://jamesclear.com/goals-systems).
### Project Based
Here in **OSS University**, you do **not** need to take exams, because we are focused on **real projects**!
In order to show for everyone that you **successfully** finished a course, you should create a **real project**.
> "What does it mean?"
After finish a course, you should think about a **real world problem** that you can solve using the acquired knowledge in the course. You don't need to create a big project, but you must create something to **validate** and **consolidate** your knowledge, and also to show to the world that you are capable to create something useful with the concepts that you learned.
The projects of all students will be listed in [this](PROJECTS.md) file. **Submit your project's information in that file after you conclude it**.
Put the OSSU-CS badge in the README of your repository! [![Open Source Society University - Computer Science](https://img.shields.io/badge/OSSU-computer--science-blue.svg)](https://github.com/open-source-society/computer-science)
## Prerequisites
- [Core CS](#core-cs) assumes the student has already taken high school math and physics, including algebra, geometry, and pre-calculus.
Some high school graduates will have already taken AP Calculus, but this is usually only about 3/4 of a college calculus class, so the calculus courses in the curriculum are still recommended.
- [Advanced CS](#advanced-cs) assumes the student has already taken the entirety of Core CS
and is knowledgeable enough now to decide which electives to take.
- Note that [Advanced systems](#advanced-systems) assumes the student has taken a basic physics course (e.g. AP Physics in high school).
## Intro CS
These courses will introduce you to the world of computer science.
Both are required, but feel free to skip straight to the second course when CS50 (the first course) moves away from C.
**Topics covered**:
imperative programming;
procedural programming;
C;
manual memory management;
basic data structures and algorithms;
Python;
SQL;
basic HTML, CSS, JavaScript;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[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 | none
[Introduction to Computer Science and Programming using Python](https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-10) | 9 weeks | 15 hours/week | high school algebra
## Core CS
All coursework under Core CS is **required**, unless otherwise indicated.
### Core programming
**Topics covered**:
functional programming;
design for testing;
program requirements;
common design patterns;
unit testing;
object-oriented design;
Java;
static typing;
dynamic typing;
ML-family languages (via Standard ML);
Lisp-family languages (via Racket);
Ruby;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[How to Code - Simple Data](https://www.edx.org/course/how-code-simple-data-ubcx-htc1x) | 7 weeks | 8-10 hours/week | none
[How to Code - Complex Data](https://www.edx.org/course/how-code-complex-data-ubcx-htc2x) | 6 weeks | 8-10 hours/week | How to Code: Simple Data
[Software Construction - Data Abstraction](https://www.edx.org/course/software-construction-data-abstraction-ubcx-softconst1x) | 6 weeks | 8-10 hours/week | How to Code - Complex Data
[Software Construction - Object-Oriented Design](https://www.edx.org/course/software-construction-object-oriented-ubcx-softconst2x) | 6 weeks | 8-10 hours/week | Software Construction - Data Abstraction
[Programming Languages, Part A](https://www.coursera.org/learn/programming-languages) | 4 weeks | 8-16 hours/week | recommended: Java, C
[Programming Languages, Part B](https://www.coursera.org/learn/programming-languages-part-b) | 3 weeks | 8-16 hours/week | Programming Languages, Part A
[Programming Languages, Part C](https://www.coursera.org/learn/programming-languages-part-c) | 3 weeks | 8-16 hours/week | Programming Languages, Part B
#### Readings
- **Required** to learn about monads, laziness, purity: [Learn You a Haskell for a Great Good!](http://learnyouahaskell.com/)
- **Required**, to learn about logic programming, backtracking, unification: [Learn Prolog Now!](http://www.learnprolognow.org/)
### Core math
**Topics covered**:
linear transformations;
matrices;
vectors;
mathematical proofs;
number theory;
differential calculus;
integral calculus;
sequences and series;
discrete mathematics;
basic statistics;
O-notation;
graph theory;
vector calculus;
discrete probability;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Linear Algebra - Foundations to Frontiers](https://www.edx.org/course/linear-algebra-foundations-frontiers-utaustinx-ut-5-04x#!) ([alt](http://ulaff.net/)) | 15 weeks | 8 hours/week | pre-calculus
[Calculus One](https://www.coursera.org/learn/calculus1)<sup>*1*</sup> ([alt](https://mooculus.osu.edu/)) | 16 weeks | 8-10 hours/week | pre-calculus
[Calculus Two: Sequences and Series](https://www.coursera.org/learn/advanced-calculus)| 7 weeks | 9-10 hours/week | Calculus One
[Mathematics for Computer Science](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-spring-2015/index.htm) | 13 weeks | 5 hours/week | single variable calculus (Calculus Two)
**<sup>1</sup> Note**: When you are enrolled, please see this
[list of errors](https://www.coursera.org/learn/calculus1/discussions/forums/WcY9_8ayEeSWEiIAC0wC5g/threads/CgOJwV-jEeWncxKXIFxpFQ/replies/kH6u_2FPEeWukw4fFhIvKw)
and
[these recommendations](https://www.coursera.org/learn/calculus1/discussions/all/threads/W5P9mFY8EeWbVQrsfyQbuw/replies/XyyJflZDEeWBRg5dvElQww/comments/l-bON17nEeW9lgqcHapJBw)
for how to progress through the course.
### Core systems
**Topics covered**:
boolean algebra;
gate logic;
memory;
machine language;
computer architecture;
assembly;
machine language;
virtual machines;
high-level languages;
compilers;
operating systems;
network protocols;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Build a Modern Computer from First Principles: From Nand to Tetris](https://www.coursera.org/learn/build-a-computer) ([alt](http://www.nand2tetris.org/)) | 6 weeks | 7-13 hours/week | none
[Build a Modern Computer from First Principles: Nand to Tetris Part II ](https://www.coursera.org/learn/nand2tetris2) | 6 weeks | 12-18 hours/week | From Nand to Tetris Part I
[Introduction to Computer Networking](https://lagunita.stanford.edu/courses/Engineering/Networking-SP/SelfPaced/about)| - | 4–12 hours/week | algebra, probability, basic CS
#### Readings
- **Required** since Nand2Tetris does not go deep enough into operating systems: [Operating Systems: Three Easy Pieces](http://pages.cs.wisc.edu/~remzi/OSTEP/)
### Core theory
**Topics covered**:
divide and conquer;
sorting and searching;
randomized algorithms;
graph search;
shortest paths;
data structures;
greedy algorithms;
minimum spanning trees;
dynamic programming;
NP-completeness;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Algorithms (1/4)](https://www.coursera.org/learn/algorithms-divide-conquer) | 4 weeks | 4-8 hours/week | one programming language, proofs, probability
[Algorithms (2/4)](https://www.coursera.org/learn/algorithms-graphs-data-structures) | 4 weeks | 4-8 hours/week | Algorithms (1/4)
[Algorithms (3/4)](https://www.coursera.org/learn/algorithms-greedy) | 4 weeks | 4-8 hours/week | Algorithms (2/4)
[Algorithms (4/4)](https://www.coursera.org/learn/algorithms-npcomplete) | 4 weeks | 4-8 hours/week | Algorithms (3/4)
### Core applications
**Topics covered**:
Agile methodology;
REST;
software specifications;
refactoring;
relational databases;
transaction processing;
data modeling;
neural networks;
supervised learning;
unsupervised learning;
OpenGL;
raytracing;
block ciphers;
authentication;
public key encryption;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Databases](https://lagunita.stanford.edu/courses/DB/2014/SelfPaced/about)| 12 weeks | 8-12 hours/week | some programming, basic CS
[Machine Learning](https://www.coursera.org/learn/machine-learning)| 11 weeks | 4-6 hours/week | linear algebra
[Computer Graphics](https://www.edx.org/course/computer-graphics-uc-san-diegox-cse167x)| 6 weeks | 12 hours/week | C++ or Java, linear algebra
[Cryptography I](https://www.coursera.org/course/crypto)| 6 weeks | 5-7 hours/week | linear algebra, probability
[Software Engineering: Introduction](https://www.edx.org/course/software-engineering-introduction-ubcx-softeng1x) | 6 weeks | 8-10 hours/week | Software Construction - Object-Oriented Design
[Software Development Capstone Project](https://www.edx.org/course/software-development-capstone-project-ubcx-softengprjx) | 6-7 weeks | 8-10 hours/week | Software Engineering: Introduction
## Advanced CS
After completing **every required course** in Core CS, students should choose a subset of courses from Advanced CS based on interest.
Not every course from a subcategory needs to be taken.
But students should take *every* course that is relevant to the field they intend to go into.
The Advanced CS study should then end with one of the Specializations under [Advanced applications](#advanced-applications).
A Specialization's Capstone, if taken, may act as the [Final project](#final-project), if permitted by the Honor Code of the course.
If not, or if a student chooses not to take the Capstone, then a separate Final project will need to be done to complete this curriculum.
### Advanced programming
**Topics covered**:
debugging theory and practice;
goal-oriented programming;
GPU programming;
CUDA;
parallel computing;
object-oriented analysis and design;
UML;
large-scale software architecture and design;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Compilers](https://lagunita.stanford.edu/courses/Engineering/Compilers/Fall2014/about)| 9 weeks | 6-8 hours/week | none
[Software Debugging](https://www.udacity.com/course/software-debugging--cs259)| 8 weeks | 6 hours/week | Python, object-oriented programming
[LAFF: Programming for Correctness](https://www.edx.org/course/laff-programming-correctness-utaustinx-ut-p4c-14-01x) | 7 weeks | 6 hours/week | linear algebra
[Introduction to Parallel Programming](https://www.udacity.com/course/intro-to-parallel-programming--cs344) | 12 weeks | - | C, algorithms
[Software Architecture & Design](https://www.udacity.com/course/software-architecture-design--ud821)| 8 weeks | 6 hours/week | software engineering in Java
### Advanced math
**Topics covered**:
real analysis;
multivariable integrals;
multivariable differentials;
probability theory;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Introduction to Mathematical Thinking](https://www.coursera.org/learn/mathematical-thinking) | 10 weeks | 10 hours/week | pre-calculus
[Multivariable Calculus](https://ocw.mit.edu/courses/mathematics/18-02sc-multivariable-calculus-fall-2010/index.htm) | 13 weeks | 12 hours/week | single-variable calculus (Calculus Two)
[Introduction to Probability - The Science of Uncertainty](https://www.edx.org/course/introduction-probability-science-mitx-6-041x-2) | 18 weeks | 12 hours/week | single- and multi-variable calculus
### Advanced systems
**Topics covered**:
digital signaling;
combinational logic;
CMOS technologies;
sequential logic;
finite state machines;
processor instruction sets;
caches;
pipelining;
virtualization;
parallel processing;
virtual memory;
synchronization primitives;
system call interface;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Electricity and Magnetism, Part 1](https://www.edx.org/course/electricity-magnetism-part-1-ricex-phys102-1x-0)<sup>1</sup> | 7 weeks | 8-10 hours/week | calculus, basic mechanics
[Electricity and Magnetism, Part 2](https://www.edx.org/course/electricity-magnetism-part-2-ricex-phys102-2x-0) | 7 weeks | 8-10 hours/week | Electricity and Magnetism, Part 1
[Computation Structures 1: Digital Circuits](https://www.edx.org/course/computation-structures-part-1-digital-mitx-6-004-1x-0) | 10 weeks | 6 hours/week | electricity, magnetism
[Computation Structures 2: Computer Architecture](https://www.edx.org/course/computation-structures-2-computer-mitx-6-004-2x) | 10 weeks | 6 hours/week | Computation Structures 1
[Computation Structures 3: Computer Organization](https://www.edx.org/course/computation-structures-3-computer-mitx-6-004-3x-0) | 10 weeks | 6 hours/week | Computation Structures 2
[ops-class.org - Hack the Kernel](https://www.ops-class.org/) | 15 weeks | 6 hours/week | algorithms
**<sup>1</sup> Note**:
These courses assume knowledge of basic physics;
if you are struggling, you can find a physics MOOC or utilize the materials from Khan Academy:
[Khan Academy - Physics](https://www.khanacademy.org/science/physics)
### Advanced theory
**Topics covered**:
formal languages;
Turing machines;
computability;
event-driven concurrency;
automata;
distributed shared memory;
consensus algorithms;
state machine replication;
computational geometry theory;
propositional logic;
relational logic;
Herbrand logic;
concept lattices;
game trees;
and more.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Introduction to Logic](https://www.coursera.org/learn/logic-introduction) | 10 weeks | 4-8 hours/week | set theory
[Automata Theory](https://lagunita.stanford.edu/courses/course-v1:ComputerScience+Automata+Fall2016/about) | 8 weeks | 10 hours/week | discrete mathematics, logic, algorithms
[Reliable Distributed Systems, Part 1](https://www.edx.org/course/reliable-distributed-algorithms-part-1-kthx-id2203-1x) | 5 weeks | 5 hours/week | Scala, intermediate CS
[Reliable Distributed Systems, Part 2](https://www.edx.org/course/reliable-distributed-algorithms-part-2-kthx-id2203-2x) | 5 weeks | 5 hours/week | Part 1
[Computational Geometry](https://www.edx.org/course/computational-geometry-tsinghuax-70240183x) | 16 weeks | 8 hours/week | algorithms, C++
[Introduction to Formal Concept Analysis](https://www.coursera.org/learn/formal-concept-analysis) | 6 weeks | 4-6 hours/week | logic, probability
[Game Theory](https://www.coursera.org/learn/game-theory-1) | 8 weeks | x hours/week | mathematical thinking, probability, calculus
### Advanced applications
These Coursera Specializations all end with a Capstone project.
Depending on the course, you may be able to utilize the Capstone as your Final Project for this Computer Science curriculum.
Note that doing a Specialization with the Capstone at the end always costs money.
So if you don't wish to spend money or use the Capstone as your Final, it may be possible to take the courses in the Specialization for free by manually searching for them, but not all allow this.
Courses | Duration | Effort | Prerequisites
:-- | :--: | :--: | :--:
[Robotics (Specialization)](https://www.coursera.org/specializations/robotics) | 26 weeks | 2-5 hours/week | linear algebra, calculus, programming, probability
[Data Mining (Specialization)](https://www.coursera.org/specializations/data-mining) | 30 weeks | 2-5 hours/week | machine learning
[Big Data (Specialization)](https://www.coursera.org/specializations/big-data) | 30 weeks | 3-5 hours/week | none
[Internet of Things (Specialization)](https://www.coursera.org/specializations/internet-of-things) | 30 weeks | 1-5 hours/week | strong programming
[Cloud Computing (Specialization)](https://www.coursera.org/specializations/cloud-computing) | 30 weeks | 2-6 hours/week | C++ programming
[Full Stack Web Development (Specialization)](https://www.coursera.org/specializations/full-stack) | 27 weeeks | 2-6 hours/week | programming, databases
[Data Science (Specialization)](https://www.coursera.org/specializations/jhu-data-science) | 43 weeks | 1-6 hours/week | none
[Functional Programming in Scala (Specialization)](https://www.coursera.org/specializations/scala) | 29 weeks | 4-5 hours/weeks | One year programming experience
## Final project
OSS University is **project-focused**.
You are encouraged to do the assignments and exams for each course, but what really matters is whether you can *use* your knowledge to solve a real world problem.
After you've gotten through all of Core CS and the parts of Advanced CS relevant to you, you should think about a problem that you can solve using the knowledge you've acquired.
Not only does real project work look great on a resume, the project will *validate* and *consolidate* your knowledge.
You can create something entirely new, or you can find an existing project that needs help via websites like
[CodeTriage](https://www.codetriage.com/)
or
[First Timers Only](http://www.firsttimersonly.com/).
Another option is using the Capstone project from taking one of the Specializations in [Advanced applications](#advanced-applications);
whether or not this makes sense depends on the course, the project, and whether or not the course's Honor Code permits you to display your work publicly.
In some cases, it may not be permitted;
do **not** violate your course's Honor Code!
Put the OSSU-CS badge in the README of your repository!
[![Open Source Society University - Computer Science](https://img.shields.io/badge/OSSU-computer--science-blue.svg)](https://github.com/open-source-society/computer-science)
- Markdown: `[![Open Source Society University - Computer Science](https://img.shields.io/badge/OSSU-computer--science-blue.svg)](https://github.com/open-source-society/computer-science)`
- HTML: `<a href="https://github.com/open-source-society/computer-science"><img alt="Open Source Society University - Computer Science" src="https://img.shields.io/badge/OSSU-computer--science-blue.svg"></a>`
**You can create this project alone or with other students!**
### Evaluation
#### Project Suggestions
Upon completing your final project, submit your project's information to [PROJECTS](PROJECTS.md)
via a pull request and use our [community](#community) channels to announce it to your fellow students.
- [Projects](https://github.com/karan/Projects): A list of practical projects that anyone can solve in any programming language.
- [app-specs](https://github.com/ericdouglas/app-specs): A curated list of applications specifications and implementations to practice new technologies, improve your portfolio and sharpen your skills.
- [FreeCodeCamp](http://www.freecodecamp.com/): Course that teaches you fullstack JavaScript development through a bunch of projects.
- [JavaScript Projects](https://github.com/javascript-society/javascript-projects): List of projects related with the [JavaScript Path](https://github.com/javascript-society/javascript-path).
Your peers and mentors from OSSU will then informally evaluate your project.
You will not be "graded" in the traditional sense — everyone has their own measurements for what they consider a success.
The purpose of the evaluation is to act as your first announcement to the world that you are a computer scientist,
and to get experience listening to feedback — both positive and negative — and taking it in stride.
And you should also...
### Be creative!
This is a **crucial** part of your journey through all those courses.
You **need** to have in mind that what you are able to **create** with the concepts that you learned will be your certificate **and this is what really matters**!
In order to show that you **really** learned those things, you need to be **creative**!
Here are some tips about how you can do that:
- **Articles**: create blog posts to synthesize/summarize what you learned.
- **GitHub repository**: keep your course's files organized in a GH repository, so in that way other students can use it to study with your annotations.
The final project evaluation has a second purpose: to evaluate whether OSSU,
through its community and curriculum, is successful in its mission to guide independent learners in obtaining a world-class computer science education.
### Cooperative work
**We love cooperative work**! Use our [channels](#community) to communicate with other fellows to combine and create new projects!
You can create this project alone or with other students!
**We love cooperative work**!
Use our [channels](#community) to communicate with other fellows to combine and create new projects!
### Which programming languages should I use?
My friend, here is the best part of liberty! You can use **any** language that you want to complete the courses.
My friend, here is the best part of liberty!
You can use **any** language that you want to complete the final project.
The **important** thing for each course is to **internalize** the **core concepts** and to be able to use them with whatever tool (programming language) that you wish.
The important thing is to **internalize** the core concepts and to be able to use them with whatever tool (programming language) that you wish.
### Content Policy
## Pro CS
You must share **only** files that you are **allowed** to! **Do NOT disrespect the code of conduct** that you signed in the beginning of some courses.
After completing the requirements of the curriculum above, you will have completed the equivalent of a full bachelor's degree in Computer Science, or quite close to one.
You can stop here, but if you really want to make yourself valuable, the next step to completing your studies is to develop skills and knowledge in a specific domain.
Many of these courses are graduate-level.
[Be creative](#be-creative) in order to show your progress! :smile:
Choose one or more of the following **specializations**:
- [Mastering Software Development in R Specialization](https://www.coursera.org/specializations/r) by Johns Hopkins University
- [Artificial Intelligence Engineer Nanodegree](https://www.udacity.com/ai) by IBM, Amazon, and Didi
- [Machine Learning Engineer Nanodegree](https://www.udacity.com/course/machine-learning-engineer-nanodegree--nd009) by kaggle
- [Cybersecurity MicroMasters](https://www.edx.org/micromasters/ritx-cybersecurity) by the Rochester Institute of Technology
- [Android Developer Nanodegree](https://www.udacity.com/course/android-developer-nanodegree-by-google--nd801) by Google
### Stay tuned
These aren't the only specializations you can choose. Check the following websites for **more options**:
- edX: [xSeries](https://www.edx.org/xseries)
- Coursera: [Specializations](https://www.coursera.org/specializations)
- Udacity: [Nanodegree](https://www.udacity.com/nanodegree)
[Watch](https://help.github.com/articles/watching-repositories/) this repository for futures improvements and general information.
### Where to go next?
## Prerequisite
- Look for a job as a developer!
- Check out the [readings](extras/readings.md) for classic books you can read that will sharpen your skills and expand your knowledge.
- Join a local developer meetup (e.g. via [Meetups.com](https://www.meetups.com/)).
- Pay attention to emerging technologies in the world of software development, such as:
- [Elixir](http://elixir-lang.org/), a new functional programming language for the web based on the battle-tested BEAM VM!
- [Rust](https://www.rust-lang.org/), a systems language which uses borrowing and lifetimes to achieve memory safety without a garbage collector!
The **only things** that you need to know are how to use **Git** and **GitHub**. Here are some resources to learn about them:
![keep learning](http://i.imgur.com/REQK0VU.jpg)
**Note**: Just pick one of the courses below to learn the basics. You will learn a lot more once you get started!
# Community
- [Try Git](https://try.github.io/levels/1/challenges/1)
- [Git - the simple guide](http://rogerdudler.github.io/git-guide/)
- [GitHub Training & Guides](https://www.youtube.com/playlist?list=PLg7s6cbtAD15G8lNyoaYDuKZSKyJrgwB-)
- [GitHub Hello World](https://guides.github.com/activities/hello-world/)
- [Git Immersion](http://gitimmersion.com/index.html)
- [How to Use Git and GitHub](https://www.udacity.com/course/how-to-use-git-and-github--ud775)
- Subscribe to [/r/opensourcesociety](https://www.reddit.com/r/opensourcesociety/)!
- Join us in our [group](https://groups.google.com/forum/#!forum/open-source-society-university)!
- You can also interact through [GitHub issues](https://github.com/open-source-society/computer-science/issues).
- We also have a chat room! [![Join the chat at https://gitter.im/open-source-society/computer-science](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/open-source-society/computer-science?utm_campaign=pr-badge&utm_content=badge&utm_medium=badge&utm_source=badge)
- Add **Open Source Society University** to your [Facebook](https://www.facebook.com/ossuniversity) profile!
## Change Log
> **PS**: A forum is an ideal way to interact with other students as we do not lose important discussions, which usually occur in communication via chat apps.
**Please use our subreddit/group for important discussions**.
**Curriculum Version**: `6.0`
## How to show your progress
To show **respect** to all of our students, we will keep a [CHANGELOG](CHANGELOG.md) file that contains all the alterations that our curriculum may suffer.
1. Create an account in [Trello](https://trello.com/).
1. Copy [this](https://trello.com/b/9DPXYv5f) board to your personal account.
See how to copy a board [here](http://blog.trello.com/you-can-copy-boards-now-finally/).
Now we have a **stable** version of the curriculum, which won't change anymore, only in exceptional cases (outdated courses, broken links, etc).
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.
Our students can **trust** in this curriculum because it has been **carefully planned** and covers **all** the **core topics** that a conventional Computer Science course covers.
We also have **labels** to help you have more control through the process.
The meaning of each of these labels is:
We also include modern topics, making this course one of the **best options** for those who want to become a Computer Scientist and/or a Software Engineer/Developer.
- `Main Curriculum`: cards with that label represent courses that are listed in our curriculum.
- `Extra Courses`: cards with that label represent courses that was added by the student.
- `Doing`: cards with that label represent courses the student is current doing.
- `Done`: cards with that label represent courses finished by the student.
Those cards should also have the link for at least one project/article built with the knowledge acquired in such course.
- `Section`: cards with that label represent the section that we have in our curriculum.
Those cards with the `Section` label are only to help the organization of the Done column.
You should put the *Course's cards* below its respective *Section's card*.
- `Extra Sections`: cards with that label represent sections that was added by the student.
## How to collaborate
You can [open an issue](https://help.github.com/articles/creating-an-issue/) and give us your suggestions as to how we can improve this guide, or what we can do to improve the learning experience.
You can also [fork this project](https://help.github.com/articles/fork-a-repo/) and send a [pull request](https://help.github.com/articles/using-pull-requests/) to fix any mistakes that you have found.
If you want to suggest a new resource, send a pull request adding such resource to the [extras](https://github.com/open-source-society/computer-science/tree/master/extras) section.
The **extras** section is a place where all of us will be able to submit interesting additional articles, books, courses and specializations, keeping our curriculum *as immutable and concise as possible*.
**Let's do it together! =)**
## Community
Subscribe to [/r/opensourcesociety](https://www.reddit.com/r/opensourcesociety/)!
Join us in our [group](https://groups.google.com/forum/#!forum/open-source-society-university)!
You can also interact through [GitHub issues](https://github.com/open-source-society/computer-science/issues).
We also have a chat room! [![Join the chat at https://gitter.im/open-source-society/computer-science](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/open-source-society/computer-science?utm_campaign=pr-badge&utm_content=badge&utm_medium=badge&utm_source=badge)
Add **Open Source Society University** to your [Facebook](https://www.facebook.com/ossuniversity) profile!
> **ps**: A forum is an ideal way to interact with other students as we do not lose important discussions, which usually occur in communication via chat apps. **Please use our subreddit/group for important discussions**.
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.
You can change the status of your board to be *public* or *private*.
## Team
@ -439,13 +514,14 @@ Add **Open Source Society University** to your [Facebook](https://www.facebook.c
* **Curriculum Maintainer**: [Eric Douglas](https://github.com/ericdouglas)
* **Contributors**: [contributors](https://github.com/open-source-society/computer-science/graphs/contributors)
## References
# References
- [Google - Guide for Technical Development](https://www.google.com/about/careers/students/guide-to-technical-development.html)
- [Coursera](https://www.coursera.org/)
- [edX](https://www.edx.org)
- [Udacity](https://www.udacity.com/)
- [Future Learn](https://www.futurelearn.com/)
- [Stanford University](https://lagunita.stanford.edu/)
- [Carnegie Mellon University: Computer Science Major Requirements](https://www.csd.cs.cmu.edu/academics/undergraduate/requirements)
- [MIT Open Courseware](http://ocw.mit.edu/courses/#electrical-engineering-and-computer-science)
- [Obtaining a Thorough CS Background Online](http://spin.atomicobject.com/2015/05/15/obtaining-thorough-cs-background-online/)
- [Teach Yourself Computer Science](https://teachyourselfcs.com/)
- [Obtaining a Thorough CS Background Online](http://spin.atomicobject.com/2015/05/15/obtaining-thorough-cs-background-online/)

74
REQUIREMENTS.md Normal file
View File

@ -0,0 +1,74 @@
# OSSU Academic Requirements
This document contains the subjects (e.g. programming), topics (e.g. imperative programming), and projects the student must master to pass through this curriculum.
The subject requirements are based on topics, rather than specific courses, because sometimes a certain course isn't available at the right time or doesn't fit the student's learning style.
## Subjects
### Programming
#### Paradigms
- Imperative programming
- Procedural programming
- Object-oriented programming
- Functional programming
- Logic programming
#### Languages
- C and/or C-derived languages
- SQL
- XML/HTML
- JavaScript and/or related language
- An ML-family language
- A Lisp-family langauge
- Python and/or Ruby
### Math
- Logic and proofs
- Discrete structures
- Graph theory
- Discrete probability
- Linear algebra
### Systems
- Memory
- Caching
- Virtualization
- Concurrency
- Compilers
- Assembly
- Networking
### Theory
- Data structures
- Sorting
- Searching
- Divide and conquer
- Algorithms on graphs
- Greedy algorithms
- Trees
- P and NP
### Applications
- Software product management
- REST
- Databases
- Computer graphics
- Cybersecurity
- Machine learning
## Projects
Students are required to complete a project at the end of [Core CS](README.md#core-cs) and at the end of [Advanced CS](README.md#advanced-cs).
For Core CS, students have two options:
- They can use the Capstone course at the end of [Core applications](#core-applications) as their Core CS Project, in which case they are not required to share their project code.
- They can skip that Capstone project and make their own project, in which case they *are* required to share the project code.
For the Advanced CS Project (also known as the Final Project), students again have two options:
- They can take one of the Specializations under [Advanced applications](#advanced-applications), all of which include Capstone Projects. Students *must* share their project code unless the course's honor code forbids it.
- They can create their own Final Project, and must share the project code to be evaluated by the community.

96
extras/articles.md
View File

@ -1,96 +0,0 @@
# Computer Science - Extra Resources
## Articles
- [Introduction to Computer Science](#introduction-to-computer-science)
- [Math (Mathematical Thinking)](#math-mathematical-thinking)
- [Program Design](#program-design)
- [Math (Discrete Math)](#math-discrete-math)
- [Algorithms](#algorithms)
- [Programming Paradigms](#programming-paradigms)
- [Software Testing](#software-testing)
- [Math (Calculus)](#math-calculus)
- [Software Architecture](#software-architecture)
- [Theory](#theory)
- [Software Engineering](#software-engineering)
- [Math (Probability)](#math-probability)
- [Computer Architecture](#computer-architecture)
- [Operating Systems](#operating-systems)
- [Computer Networks](#computer-networks)
- [Databases](#databases)
- [Cloud Computing](#cloud-computing)
- [Math (Linear Algebra)](#math-linear-algebra)
- [Cryptography](#cryptography)
- [Security](#security)
- [Compilers](#compilers)
- [Parallel Computing](#parallel-computing)
- [UX Design](#ux-design)
- [Computer Graphics](#computer-graphics)
- [Artificial Intelligence](#artificial-intelligence)
- [Machine Learning](#machine-learning)
- [Natural Language Processing](#natural-language-processing)
- [Big Data](#big-data)
- [Data Mining](#data-mining)
- [Internet of Things](#internet-of-things)
---
### Introduction to Computer Science
### Math (Mathematical Thinking)
### Program Design
### Math (Discrete Math)
### Algorithms
### Programming Paradigms
### Software Testing
### Math (Calculus)
### Software Architecture
### Theory
### Software Engineering
### Math (Probability)
### Computer Architecture
### Operating Systems
### Computer Networks
### Databases
### Cloud Computing
### Math (Linear Algebra)
### Cryptography
### Security
### Compilers
### Parallel Computing
### UX Design
### Computer Graphics
### Artificial Intelligence
### Machine Learning
### Natural Language Processing
### Big Data
### Data Mining
### Internet of Things

74
extras/courses.md Normal file
View File

@ -0,0 +1,74 @@
# Computer Science - Great Courses
This is a list of high-quality courses that, for one reason or another, didn't make it into the curriculum.
The most common reasons are that the course isn't available often enough,
or that there was an alternative that fit better into the curriculum.
## Programming
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Computer Science and Programming Using Python](https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-5#!)| 9 weeks | 15 hours/week
[Introduction to Computational Thinking and Data Science](https://www.edx.org/course/introduction-computational-thinking-data-mitx-6-00-2x-2#!)| 10 weeks | 15 hours/week
[Introduction to Computer Science (Udacity)](https://www.udacity.com/course/intro-to-computer-science--cs101)| 7 weeks | 10-20 hours/week
[An Introduction to Interactive Programming in Python (Part 1)](https://www.coursera.org/learn/interactive-python-1)| 5 weeks | -
[An Introduction to Interactive Programming in Python (Part 2)](https://www.coursera.org/learn/interactive-python-2)| - | -
[Programming Basics](https://www.edx.org/course/programming-basics-iitbombayx-cs101-1x)| 9 weeks | 8 hours/week
[Object-Oriented Programming](https://www.edx.org/course/object-oriented-programming-iitbombayx-cs101-2x)| 4 weeks | 8 hours/week
[Introduction to Programming with MATLAB](https://www.coursera.org/learn/matlab)| - | -
[Introduction to Functional Programming](https://www.edx.org/course/introduction-functional-programming-delftx-fp101x-0)| 7 weeks | 4-6 hours/week
[The Structure and Interpretation of Computer Programs](http://cs61a.org/) | - | -
## Math
Courses | Duration | Effort
:-- | :--: | :--:
[Effective Thinking Through Mathematics](https://www.edx.org/course/effective-thinking-through-mathematics-utaustinx-ut-9-01x-0) | 4 weeks | 2 hours/week | none
[Introduction to Probability and Data](https://www.coursera.org/learn/probability-intro)| - | -
[Linear Algebra (Strang)](https://ocw.mit.edu/courses/mathematics/18-06-linear-algebra-spring-2010/index.htm) | - | -
## Systems
Courses | Duration | Effort
:-- | :--: | :--:
[Computer Architecture](https://www.coursera.org/learn/comparch) | - | 5-8 hours/week
[Operating System Engineering](http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-828-operating-system-engineering-fall-2012/) | - | -
[Introduction to Operating Systems](https://www.udacity.com/course/introduction-to-operating-systems--ud923)| 8 weeks | 5-8 hours/week
[Advanced Operating Systems](https://www.udacity.com/course/advanced-operating-systems--ud189)| 5 weeks | 5-8 hours/week
[Computer Networking](https://www.udacity.com/course/computer-networking--ud436) | 12 weeks | 5-8 hours/week
## Theory
Courses | Duration | Effort
:-- | :--: | :--:
[Algorithms, Part I](https://www.coursera.org/learn/algorithms-part1) | 6 weeks | 6-12 hours/week | some programming
[Algorithms, Part II](https://www.coursera.org/learn/algorithms-part2) | 6 weeks | 6-12 hours/week | Algorithms, Part I
[Analysis of Algorithms (Sedgewick)](https://www.coursera.org/learn/analysis-of-algorithms) | 6 weeks | 6-8 hours/week
[Analysis of Algorithms (Skiena)](http://www3.cs.stonybrook.edu/~skiena/373/) | 15 weeks | 6-8 hours/week
[Programming Challenges (Skiena)](http://www3.cs.stonybrook.edu/~skiena/392/) | 14 weeks | 6-8 hours/week
[Data Structures and Algorithms (Specialization)](https://www.coursera.org/specializations/data-structures-algorithms) | 25 weeks | 3-10 hours/week
[Algorithmic Thinking (Part 1)](https://www.coursera.org/learn/algorithmic-thinking-1/) | - | -
[Algorithmic Thinking (Part 2)](https://www.coursera.org/learn/algorithmic-thinking-2/) | - | -
[Statistical Mechanics: Algorithms and Computations](https://www.coursera.org/learn/statistical-mechanics/) | - | -
[Approximation Algorithms Part I](https://www.coursera.org/learn/approximation-algorithms-part-1/) | - | -
[Approximation Algorithms Part II](https://www.coursera.org/learn/approximation-algorithms-part-2/) | - | -
## Applications
Courses | Duration | Effort
:-- | :--: | :--:
[Using Databases with Python](https://www.coursera.org/learn/python-databases) | 5 weeks | 2-3 hours/week
[Database Systems](https://scs.hosted.panopto.com/Panopto/Pages/Sessions/List.aspx#folderID=%22ed2ee867-9610-4bad-94af-5d12c2ea47cd%22) | - | 27 hours
[Database Management Essentials](https://www.coursera.org/learn/database-management) | 7 weeks | 4-6 hours/week
[Intro to Artificial Intelligence](https://www.udacity.com/course/intro-to-artificial-intelligence--cs271)| 16 weeks | 6-10 hours/week
[Intro to Machine Learning](https://www.udacity.com/course/intro-to-machine-learning--ud120)| 10 weeks | 6-10 hours/week
[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
[Processing Big Data with Azure HDInsight](https://www.edx.org/course/processing-big-data-azure-hdinsight-microsoft-dat202-1x-0)| 5 weeks | 3-4 hours/week
[Big Data Science with the BD2K-LINCS Data Coordination and Integration Center](https://www.coursera.org/course/bd2klincs)| 7 weeks | 4-5 hours/week
# Online Learning - Great Courses
Courses | Duration | Effort
:-- | :--: | :--:
[Learning How to Learn](https://www.coursera.org/learn/learning-how-to-learn) | 4 weeks | 2 hours/week
[Mindshift](https://www.coursera.org/learn/mindshift) | 4 weeks | 2 hours/week

122
extras/free-books.md
View File

@ -1,122 +0,0 @@
# Computer Science - Extra Resources
## Free Books
- [Introduction to Computer Science](#introduction-to-computer-science)
- [Math (Mathematical Thinking)](#math-mathematical-thinking)
- [Program Design](#program-design)
- [Math (Discrete Math)](#math-discrete-math)
- [Algorithms](#algorithms)
- [Programming Paradigms](#programming-paradigms)
- [Software Testing](#software-testing)
- [Math (Calculus)](#math-calculus)
- [Software Architecture](#software-architecture)
- [Theory](#theory)
- [Software Engineering](#software-engineering)
- [Math (Probability)](#math-probability)
- [Computer Architecture](#computer-architecture)
- [Operating Systems](#operating-systems)
- [Computer Networks](#computer-networks)
- [Databases](#databases)
- [Cloud Computing](#cloud-computing)
- [Math (Linear Algebra)](#math-linear-algebra)
- [Cryptography](#cryptography)
- [Security](#security)
- [Compilers](#compilers)
- [Parallel Computing](#parallel-computing)
- [UX Design](#ux-design)
- [Computer Graphics](#computer-graphics)
- [Artificial Intelligence](#artificial-intelligence)
- [Machine Learning](#machine-learning)
- [Natural Language Processing](#natural-language-processing)
- [Big Data](#big-data)
- [Data Mining](#data-mining)
- [Internet of Things](#internet-of-things)
---
### Introduction to Computer Science
Name | Author(s)
:-- | :--:
[Structure and Interpretation of Computer Programs](https://mitpress.mit.edu/sicp/full-text/book/book.html) | Hal Abelson, Jerry Sussman, Julie Sussman
[Introduction to Computing: Explorations in Language, Logic, and Machines](http://www.computingbook.org/) | David Evans
### Math (Mathematical Thinking)
### Program Design
### Math (Discrete Math)
Name | Author(s)
:-- | :--:
[Applied Discrete Structures](http://faculty.uml.edu/klevasseur/ads2/) | Alan Doerr, Ken Levasseur
### Algorithms
### Programming Paradigms
### Software Testing
### Math (Calculus)
Name | Author(s)
:-- | :--:
[Calculus Made Easy](http://www.gutenberg.org/ebooks/33283) | Silvanus P. Thompson
### Software Architecture
### Theory
### Software Engineering
### Math (Probability)
Name | Author(s)
:-- | :--:
[Grinstead and Snell’s Introduction to Probability](https://math.dartmouth.edu/~prob/prob/prob.pdf) |Charles M. Grinstead, J. Laurie Snell
### Computer Architecture
### Operating Systems
### Computer Networks
### Databases
### Cloud Computing
### Math (Linear Algebra)
### Cryptography
### Security
### Compilers
Name | Author(s)
:-- | :--:
[Compiler Construction](http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf) | Niklaus Wirth
### Parallel Computing
### UX Design
### Computer Graphics
### Artificial Intelligence
### Machine Learning
Name | Author(s)
:-- | :--:
[Deep Learning](http://www.deeplearningbook.org/) | Ian Goodfellow, Yoshua Bengio and Aaron Courville
### Natural Language Processing
### Big Data
### Data Mining
### Internet of Things

244
extras/free-courses.md
View File

@ -1,244 +0,0 @@
# Computer Science - Extra Resources
## Free Courses
- [Introduction to Computer Science](#introduction-to-computer-science)
- [Math (Mathematical Thinking)](#math-mathematical-thinking)
- [Program Design](#program-design)
- [Math (Discrete Math)](#math-discrete-math)
- [Algorithms](#algorithms)
- [Programming Paradigms](#programming-paradigms)
- [Software Testing](#software-testing)
- [Math (Calculus)](#math-calculus)
- [Software Architecture](#software-architecture)
- [Theory](#theory)
- [Software Engineering](#software-engineering)
- [Math (Probability)](#math-probability)
- [Computer Architecture](#computer-architecture)
- [Operating Systems](#operating-systems)
- [Computer Networks](#computer-networks)
- [Databases](#databases)
- [Cloud Computing](#cloud-computing)
- [Math (Linear Algebra)](#math-linear-algebra)
- [Cryptography](#cryptography)
- [Security](#security)
- [Compilers](#compilers)
- [Parallel Computing](#parallel-computing)
- [UX Design](#ux-design)
- [Computer Graphics](#computer-graphics)
- [Artificial Intelligence](#artificial-intelligence)
- [Machine Learning](#machine-learning)
- [Natural Language Processing](#natural-language-processing)
- [Big Data](#big-data)
- [Data Mining](#data-mining)
- [Internet of Things](#internet-of-things)
---
### Introduction to Computer Science
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Computer Science and Programming Using Python](https://www.edx.org/course/introduction-computer-science-mitx-6-00-1x-5#!)| 9 weeks | 15 hours/week
[From Nand to Tetris (Part 1) ](https://www.coursera.org/learn/build-a-computer) | 6 weeks | 5-10 hours/week
[Introduction to Computer Science (Udacity)](https://www.udacity.com/course/intro-to-computer-science--cs101)| 7 weeks | 10-20 hours/week
[An Introduction to Interactive Programming in Python (Part 1)](https://www.coursera.org/learn/interactive-python-1)| 5 weeks | -
[An Introduction to Interactive Programming in Python (Part 2)](https://www.coursera.org/learn/interactive-python-2)| - | -
[Introduction to Computational Thinking and Data Science](https://www.edx.org/course/introduction-computational-thinking-data-mitx-6-00-2x-2#!)| 10 weeks | 15 hours/week
[Introduction to Programming with Java Part 1: Starting to Code with Java](https://prod-edx-mktg-edit.edx.org/course/introduction-programming-java-part-1-uc3mx-it-1-1x-0)| 5 weeks | 5-7 hours/week
[Introduction to Programming with Java Part 2: Writing Good Code](https://prod-edx-mktg-edit.edx.org/course/introduction-programming-java-part-2-uc3mx-it-1-2x)| 5 weeks | 5-7 hours/week
[CS For All: Introduction to Computer Science and Python Programming](https://www.edx.org/course/cs-all-introduction-computer-science-harveymuddx-cs005x-0)| 14 weeks | 5-7 hours/week
[Programming Basics](https://www.edx.org/course/programming-basics-iitbombayx-cs101-1x)| 9 weeks | 8 hours/week
[Introduction to Logic](https://www.coursera.org/course/intrologic)| 8 weeks | 4-10 hours/week
[Introduction to Programming with MATLAB](https://www.coursera.org/learn/matlab)| - | -
### Math (Mathematical Thinking)
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Mathematical Thinking](https://www.coursera.org/course/maththink)| 10 weeks | 8-10 hours/week
### Program Design
### Math (Discrete Math)
### Algorithms
Courses | Duration | Effort
:-- | :--: | :--:
[Analysis of Algorithms (Skiena)](http://www3.cs.stonybrook.edu/~skiena/373/) | 15 weeks | 6-8 hours/week
[Analysis of Algorithms (Sedgewick)](https://www.coursera.org/course/aofa)| 6 weeks | 6-8 hours/week
[Programming Challenges (Skiena)](http://www3.cs.stonybrook.edu/~skiena/392/) | 14 weeks | 6-8 hours/week
[Mathematical Logic and Algorithms Theory](https://iversity.org/en/courses/mathematical-logic-and-algorithms-theory) | 7 weeks | 3-4 hours/week
[Algorithmic Toolbox](https://www.coursera.org/learn/algorithmic-toolbox/) | 5 weeks | 4-8 hours/week
[Algorithms on Graphs and Trees](https://www.coursera.org/learn/algorithms-on-graphs-and-trees/) | - | -
[Algorithms on Strings](https://www.coursera.org/learn/algorithms-on-strings/) | - | -
[Advanced Algorithms and Complexity](https://www.coursera.org/learn/advanced-algorithms-and-complexity/) | - | -
[Algorithmic Thinking (Part 1)](https://www.coursera.org/learn/algorithmic-thinking-1/) | - | -
[Algorithmic Thinking (Part 2)](https://www.coursera.org/learn/algorithmic-thinking-2/) | - | -
[Statistical Mechanics: Algorithms and Computations](https://www.coursera.org/learn/statistical-mechanics/) | - | -
[Approximation Algorithms Part I](https://www.coursera.org/learn/approximation-algorithms-part-1/) | - | -
[Approximation Algorithms Part II](https://www.coursera.org/learn/approximation-algorithms-part-2/) | - | -
[Algorithms: Design and Analysis, Part 1](https://www.coursera.org/course/algo) | 6 weeks | 5-7 hours/week
[Algorithms: Design and Analysis, Part 2](https://www.coursera.org/course/algo2) | 6 weeks | 6-10 hours/week
### Programming Paradigms
Courses | Duration | Effort
:-- | :--: | :--:
[Principles of Reactive Programming](https://www.coursera.org/course/reactive)| 7 weeks | 5-7 hours/week
[Object-Oriented Programming](https://www.edx.org/course/object-oriented-programming-iitbombayx-cs101-2x)| 4 weeks | 8 hours/week
[Introduction to Functional Programming](https://www.edx.org/course/introduction-functional-programming-delftx-fp101x-0)| 7 weeks | 4-6 hours/week
### Software Testing
### Math (Calculus)
Courses | Duration | Effort
:-- | :--: | :--:
[Pre-Calculus](https://www.coursera.org/course/precalculus)| 10 weeks | 10-12 hours/week
[Multivariable Calculus](https://www.coursera.org/course/m2o2c2)| 6 weeks | 5-7 hours/week
### Software Architecture
Courses | Duration | Effort
:-- | :--: | :--:
[Web Application Architectures](https://www.coursera.org/course/webapplications)| 6 weeks | 6-9 hours/week
### Theory
### Software Engineering
Courses | Duration | Effort
:-- | :--: | :--:
[Agile Development Using Ruby on Rails - Basics](https://www.edx.org/course/agile-development-using-ruby-rails-uc-berkeleyx-cs169-1x)| 9 weeks | 12 hours/week
[Agile Development Using Ruby on Rails - Advanced](https://www.edx.org/course/agile-development-using-ruby-rails-uc-berkeleyx-cs169-2x)| 8 weeks | 12 hours/week
[Startup Engineering](https://www.coursera.org/course/startup) | 12 weeks | 2-20 hours/week
### Math (Probability)
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Probability and Data](https://www.coursera.org/learn/probability-intro)| - | -
### Computer Architecture
Courses | Duration | Effort
:-- | :--: | :--:
[Certified Information Systems Auditor](https://www.cybrary.it/course/cisa/#)| - | 8.5 hours
[The Hardware/Software Interface](https://www.coursera.org/course/hwswinterface)| 8 weeks | 10-15 hours/week
### Operating Systems
Courses | Duration | Effort
:-- | :--: | :--:
[Operating System Engineering](http://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-828-operating-system-engineering-fall-2012/)| - | -
[Introduction to Linux](https://www.edx.org/course/introduction-linux-linuxfoundationx-lfs101x-0)| 8 weeks | 5-8 hours/week
[CompTIA Linux+](https://www.cybrary.it/course/comptia-linux-plus/)| - | 5.25 hours
[Introduction to Operating Systems](https://www.udacity.com/course/introduction-to-operating-systems--ud923)| 8 weeks | 5-8 hours/week
[Advanced Operating Systems](https://www.udacity.com/course/advanced-operating-systems--ud189)| 5 weeks | 5-8 hours/week
### Computer Networks
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to Computer Networking](https://lagunita.stanford.edu/courses/Engineering/Networking-SP/SelfPaced/about) | - | 5-10 hours/week
[CompTIA Network+](https://www.cybrary.it/course/comptia-network-plus/) | - | 32 hours
[Cisco CCNA](https://www.cybrary.it/course/cisco-ccna/) | - | 15.5 hours
[Networking for Web Developers](https://www.udacity.com/course/networking-for-web-developers--ud256) | - | 12 hours
[Computer Networking](https://www.udacity.com/course/computer-networking--ud436) | 12 weeks | 5-8 hours/week
### Databases
Courses | Duration | Effort
:-- | :--: | :--:
[Using Databases with Python](https://www.coursera.org/learn/python-databases) | 5 weeks | 2-3 hours/week
[Database Systems](https://scs.hosted.panopto.com/Panopto/Pages/Sessions/List.aspx#folderID=%22ed2ee867-9610-4bad-94af-5d12c2ea47cd%22) | - | 27 hours
[Database Management Essentials](https://www.coursera.org/learn/database-management) | 7 weeks | 4-6 hours/week
### Cloud Computing
Courses | Duration | Effort
:-- | :--: | :--:
[CompTIA Cloud+](https://www.cybrary.it/course/comptia-cloud-plus/) | - | 2.5 hours
[Cloud Computing Concepts](https://www.coursera.org/course/cloudcomputing) | 5 weeks | 4-8 hours/week
[Cloud Computing Concepts: Part 2](https://www.coursera.org/course/cloudcomputing2) | 5 weeks | 4-8 hours/week
[Cloud Computing Applications](https://www.coursera.org/course/cloudapplications) | 5 weeks | 10-15 hours/week
### Math (Linear Algebra)
Courses | Duration | Effort
:-- | :--: | :--:
[Linear Algebra - Foundations to Frontiers (LAFF)](https://www.edx.org/course/linear-algebra-foundations-frontiers-utaustinx-ut-5-03x)| 15 weeks | 8 hours/week
### Cryptography
Courses | Duration | Effort
:-- | :--: | :--:
[Applied Cryptography](https://www.udacity.com/course/applied-cryptography--cs387)| 8 weeks | 6 hours/week
[Cryptography](https://www.coursera.org/learn/cryptography/)| 7 weeks | 4-7 hours/week
[Cryptography](https://www.cybrary.it/course/cryptography/)| - | 2.9 hours
### Security
Courses | Duration | Effort
:-- | :--: | :--:
[Usable Security](https://www.coursera.org/learn/usable-security/)| 7 weeks | 5-8 hours/week
[Software Security](https://www.coursera.org/learn/software-security/)| 6 weeks | 3-5 hours/week
[Cybersecurity and Its Ten Domains](https://www.coursera.org/learn/cyber-security-domain/)| 7 weeks | 4-7 hours/week
[Designing and Executing Information Security Strategies](https://www.coursera.org/course/infosec)| 10 weeks | 4-6 hours/week
[CompTIA Security+](https://www.cybrary.it/course/comptia-security-plus/)| - | 9.5 hours
[Cyberwar, Surveillance and Security](https://www.edx.org/course/cyberwar-surveillance-security-adelaidex-cyber101x-0)| 6 weeks | 2-3 hours/week
[Computer and Hacking Forensics](https://www.cybrary.it/course/computer-hacking-forensics-analyst/)| - | 7.1 hours
[Secure Coding](https://www.cybrary.it/course/secure-coding/)| - | 9.5 hours
### Compilers
### Parallel Computing
### UX Design
### Computer Graphics
### Artificial Intelligence
Courses | Duration | Effort
:-- | :--: | :--:
[Discrete Optimization](https://www.coursera.org/course/optimization)| 9 weeks | 10-20 hours/week
[Intro to Artificial Intelligence](https://www.udacity.com/course/intro-to-artificial-intelligence--cs271)| 16 weeks | 6-10 hours/week
### Machine Learning
Courses | Duration | Effort
:-- | :--: | :--:
[Intro to Machine Learning](https://www.udacity.com/course/intro-to-machine-learning--ud120)| 10 weeks | 6-10 hours/week
[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
### Natural Language Processing
### Big Data
Courses | Duration | Effort
:-- | :--: | :--:
[Big Data for Smart Cities](https://www.edx.org/course/big-data-smart-cities-ieeex-introdatax)| 4 weeks | 3-5 hours/week
[Processing Big Data with Azure HDInsight](https://www.edx.org/course/processing-big-data-azure-hdinsight-microsoft-dat202-1x-0)| 5 weeks | 3-4 hours/week
[Big Data Science with the BD2K-LINCS Data Coordination and Integration Center](https://www.coursera.org/course/bd2klincs)| 7 weeks | 4-5 hours/week
### Data Mining
Courses | Duration | Effort
:-- | :--: | :--:
[Mining Massive Datasets](https://www.coursera.org/course/mmds)| 7 weeks | 8-10 hours/week
[Text Retrieval and Search Engines](https://www.coursera.org/learn/text-retrieval)| - | -
[Text Mining and Analytics](https://www.coursera.org/learn/text-mining)| - | -
[Cluster Analysis in Data Mining](https://www.coursera.org/learn/cluster-analysis)| - | -
### Internet of Things
Courses | Duration | Effort
:-- | :--: | :--:
[Introduction to the Internet of Things and Embedded Systems](https://www.coursera.org/learn/iot/?source=phoenixCdp2016AbTest)| 4 weeks | 1-3 hours/week
[Internet of Things: How did we get here?](https://www.coursera.org/learn/internet-of-things-history/)| 2 weeks | 2-3 hours/week
[Internet of Things: Setting Up Your DragonBoard™ Development Platform](https://www.coursera.org/learn/internet-of-things-dragonboard/)| 10 weeks | 2-3 hours/week
[Internet of Things: Sensing and Actuation From Devices](https://www.coursera.org/learn/internet-of-things-sensing-actuation)| 6 weeks | 3-5 hours/week
[Internet of Things: Communication Technologies](https://www.coursera.org/learn/internet-of-things-communication)| 4 weeks | 1 hours/week
[Internet of Things: MultimediaTechnologies](https://www.coursera.org/learn/internet-of-things-multimedia)| 3 weeks | 1-2 hours/week

121
extras/paid-books.md
View File

@ -1,121 +0,0 @@
# Computer Science - Extra Resources
## Paid Books
- [Introduction to Computer Science](#introduction-to-computer-science)
- [Math (Mathematical Thinking)](#math-mathematical-thinking)
- [Program Design](#program-design)
- [Math (Discrete Math)](#math-discrete-math)
- [Algorithms](#algorithms)
- [Programming Paradigms](#programming-paradigms)
- [Software Testing](#software-testing)
- [Math (Calculus)](#math-calculus)
- [Software Architecture](#software-architecture)
- [Theory](#theory)
- [Software Engineering](#software-engineering)
- [Math (Probability)](#math-probability)
- [Computer Architecture](#computer-architecture)
- [Operating Systems](#operating-systems)
- [Computer Networks](#computer-networks)
- [Databases](#databases)
- [Cloud Computing](#cloud-computing)
- [Math (Linear Algebra)](#math-linear-algebra)
- [Cryptography](#cryptography)
- [Security](#security)
- [Compilers](#compilers)
- [Parallel Computing](#parallel-computing)
- [UX Design](#ux-design)
- [Computer Graphics](#computer-graphics)
- [Artificial Intelligence](#artificial-intelligence)
- [Machine Learning](#machine-learning)
- [Natural Language Processing](#natural-language-processing)
- [Big Data](#big-data)
- [Data Mining](#data-mining)
- [Internet of Things](#internet-of-things)
---
### Introduction to Computer Science
Name | Author | ISBN
:-- | :--: | :--:
[Introduction to Computation and Programming Using Python](https://www.amazon.com/Introduction-Computation-Programming-Using-Python/dp/0262525003/) | John V. Guttag | 978-0262525008
### Math (Mathematical Thinking)
### Program Design
### Math (Discrete Math)
Name | Author | ISBN
:-- | :--: | :--:
[Discrete Mathematics with Applications(4th Edition)](http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/) | Susanna S. Epp | 9780495391326
### Algorithms
Name | Author | ISBN
:-- | :--: | :--:
[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 | 9780262033848
### Programming Paradigms
### Software Testing
### Math (Calculus)
### Software Architecture
### Theory
### Software Engineering
### Math (Probability)
### Computer Architecture
### Operating Systems
Name | Author | ISBN
:-- | :--: | :--:
[Modern Operating Systems(4th Edition)](http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X/) | Andrew S. Tanenbaum, Herbert Bos | 9780133591620
### Computer Networks
Name | Author | ISBN
:-- | :--: | :--:
[Computer Networking: A Top-Down Approach (6th Edition)](http://www.chegg.com/textbooks/computer-networking-6th-edition-9780132856201-0132856204) | James F Kurose, Keith W Ross | 9780132856201
[Computer Networks (5th Edition)](http://www.amazon.com/Computer-Networks-5th-Andrew-Tanenbaum/dp/0132126958/) | Andrew S. Tanenbaum, David J. Wetherall| 9780132126953
### Databases
### Cloud Computing
### Math (Linear Algebra)
### Cryptography
### Security
### Compilers
Name | Author | ISBN
:-- | :--: | :--:
[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 | 9780321486813
### Parallel Computing
### UX Design
### Computer Graphics
### Artificial Intelligence
### Machine Learning
### Natural Language Processing
### Big Data
### Data Mining
### Internet of Things

96
extras/paid-courses.md
View File

@ -1,96 +0,0 @@
# Computer Science - Extra Resources
## Paid Courses
- [Introduction to Computer Science](#introduction-to-computer-science)
- [Math (Mathematical Thinking)](#math-mathematical-thinking)
- [Program Design](#program-design)
- [Math (Discrete Math)](#math-discrete-math)
- [Algorithms](#algorithms)
- [Programming Paradigms](#programming-paradigms)
- [Software Testing](#software-testing)
- [Math (Calculus)](#math-calculus)
- [Software Architecture](#software-architecture)
- [Theory](#theory)
- [Software Engineering](#software-engineering)
- [Math (Probability)](#math-probability)
- [Computer Architecture](#computer-architecture)
- [Operating Systems](#operating-systems)
- [Computer Networks](#computer-networks)
- [Databases](#databases)
- [Cloud Computing](#cloud-computing)
- [Math (Linear Algebra)](#math-linear-algebra)
- [Cryptography](#cryptography)
- [Security](#security)
- [Compilers](#compilers)
- [Parallel Computing](#parallel-computing)
- [UX Design](#ux-design)
- [Computer Graphics](#computer-graphics)
- [Artificial Intelligence](#artificial-intelligence)
- [Machine Learning](#machine-learning)
- [Natural Language Processing](#natural-language-processing)
- [Big Data](#big-data)
- [Data Mining](#data-mining)
- [Internet of Things](#internet-of-things)
---
### Introduction to Computer Science
### Math (Mathematical Thinking)
### Program Design
### Math (Discrete Math)
### Algorithms
### Programming Paradigms
### Software Testing
### Math (Calculus)
### Software Architecture
### Theory
### Software Engineering
### Math (Probability)
### Computer Architecture
### Operating Systems
### Computer Networks
### Databases
### Cloud Computing
### Math (Linear Algebra)
### Cryptography
### Security
### Compilers
### Parallel Computing
### UX Design
### Computer Graphics
### Artificial Intelligence
### Machine Learning
### Natural Language Processing
### Big Data
### Data Mining
### Internet of Things

68
extras/readings.md Normal file
View File

@ -0,0 +1,68 @@
# Computer Science - Great Readings
This document consists of great books or articles on computer science.
Some are here because there is a course covering the same material;
some are just great books that you should read at some point in your career.
Once you have made it through most of the curriculum, knowing whether a book is worth your time will become easier.
Or, if you are struggling in one of the courses, perhaps reading a book on the subject will help.
## Programming
Name | Author(s)
:-- | :--:
[Introduction to Computation and Programming Using Python](https://www.amazon.com/Introduction-Computation-Programming-Using-Python/dp/0262525003/) | John V. Guttag
[How to Design Programs](http://www.ccs.neu.edu/home/matthias/HtDP2e/) | Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi
[Structure and Interpretation of Computer Programs](https://mitpress.mit.edu/sicp/full-text/book/book.html) | Hal Abelson, Jerry Sussman, Julie Sussman
[Concepts, Techniques, and Models of Computer Programming](https://www.amazon.com/gp/product/0262220695) | Peter Van Roy, Seif Haridi
[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
[Refactoring](https://www.refactoring.com/) | Martin Fowler
[Clean Code](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882) | Robert Martin
[Code Complete](https://www.amazon.com/Code-Complete-Practical-Handbook-Construction/dp/0735619670) | Steve McConnell
[The Pragmatic Programmer](https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X) | Andrew Hunt, David Thomas
## Math
Name | Author(s)
:-- | :--:
[Calculus Made Easy](http://www.gutenberg.org/ebooks/33283) | Silvanus P. Thompson
[Discrete Mathematics with Applications (4th Edition)](http://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/0495391328/) | Susanna S. Epp
[Applied Discrete Structures](http://faculty.uml.edu/klevasseur/ads2/) | Alan Doerr, Ken Levasseur
[Grinstead and Snell’s Introduction to Probability](https://math.dartmouth.edu/~prob/prob/prob.pdf) |Charles M. Grinstead, J. Laurie Snell
[Introduction to Linear Algebra](https://www.amazon.com/Introduction-Linear-Algebra-Gilbert-Strang/dp/0980232775/) | Gilbert Strang
## Systems
Name | Author(s)
:-- | :--:
[Modern Operating Systems (4th Edition)](http://www.amazon.com/Modern-Operating-Systems-Andrew-Tanenbaum/dp/013359162X/) | Andrew S. Tanenbaum, Herbert Bos
[Computer Organization and Design: The Hardware/Software Interface](https://www.amazon.com/gp/product/0124077269) | David Patternson, John Hennessy
[Computer Networks (5th Edition)](http://www.amazon.com/Computer-Networks-5th-Andrew-Tanenbaum/dp/0132126958/) | Andrew S. Tanenbaum, David J. Wetherall
[Computer Networking: A Top-Down Approach (6th Edition)](https://www.amazon.com/Computer-Networking-A-Top-Down-Approach/dp/1292153598/) | James F Kurose, Keith W Ross
[Distributed Systems: Principles and Paradigms](https://www.amazon.com/Distributed-Systems-Principles-Andrew-Tanenbaum/dp/153028175X) | Andrew Tanenbaum
[Distributed Systems Reading Group](http://dsrg.pdos.csail.mit.edu/papers/) | Various
## Theory
Name | Author(s)
:-- | :--:
[Introduction to Computing: Explorations in Language, Logic, and Machines](http://www.computingbook.org/) | David Evans
[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
[The Algorithm Design Manual](https://www.amazon.com/gp/product/1848000693) | Steven Skiena
## Applications
Name | Author(s)
:-- | :--:
[Architecture of a Database System](http://db.cs.berkeley.edu/papers/fntdb07-architecture.pdf) | Joseph M. Hellerstein, Michael Stonebraker, James Hamilton
[Readings in Database Systems](http://www.redbook.io/) | Peter Bailis, Joseph M. Hellerstein, Michael Stonebraker, editors
[Database Management Systems](https://www.amazon.com/gp/product/0072465638) | Raghu Ramakrishnan, Johannes Gehrke
[Transaction Processing: Concepts and Techniques](https://www.amazon.com/Transaction-Processing-Concepts-Techniques-Management/dp/1558601902) | Jim Gray, Andreas Reuter
[Data and Reality: A Timeless Perspective on Perceiving and Managing Information in Our Imprecise World](https://www.amazon.com/Data-Reality-Perspective-Perceiving-Information/dp/1935504215) | William Kent
[The Architecture of Open Source Applications](http://aosabook.org/en/) | Michael DiBernardo (editor)
[Deep Learning](http://www.deeplearningbook.org/) | Ian Goodfellow, Yoshua Bengio and Aaron Courville
[Bayesian Reasoning and Machine Learning](http://web4.cs.ucl.ac.uk/staff/D.Barber/pmwiki/pmwiki.php?n=Brml.HomePage) | David Barber
[Language Implementation Patterns](https://www.amazon.com/gp/product/193435645X) | Terence Parr
[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
[Compiler Construction](http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf) | Niklaus Wirth
[The Mythical Man-Month](https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959/) | Fred Brooks, Jr.