diff --git a/docs/computer-science/advanced-cs/electives/index.md b/docs/computer-science/advanced-cs/electives/index.md new file mode 100644 index 0000000..4db8e3c --- /dev/null +++ b/docs/computer-science/advanced-cs/electives/index.md @@ -0,0 +1,103 @@ +--- +sidebar_position: 6 +--- + +# Electives + +*Timeline: varies per student* + +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. + +#### Advanced programming + +**Topics covered**: +`debugging theory and practice` +`goal-oriented programming` +`parallel computing` +`object-oriented analysis and design` +`UML` +`large-scale software architecture and design` +`and more` + +Courses | Duration | Effort | Prerequisites +:-- | :--: | :--: | :--: +[Parallel Programming](https://www.coursera.org/learn/scala-parallel-programming)| 4 weeks | 6-8 hours/week | Scala programming +[Compilers](https://www.edx.org/learn/computer-science/stanford-university-compilers) | 9 weeks | 6-8 hours/week | none +[Introduction to Haskell](https://www.seas.upenn.edu/~cis194/fall16/)| 14 weeks | - | - +[Learn Prolog Now!](https://www.let.rug.nl/bos/lpn//lpnpage.php?pageid=online) ([alternative](https://github.com/ossu/computer-science/files/6085884/lpn.pdf))*| 12 weeks | - | - +[Software Debugging](https://www.youtube.com/playlist?list=PLAwxTw4SYaPkxK63TiT88oEe-AIBhr96A)| 8 weeks | 6 hours/week | Python, object-oriented programming +[Software Testing](https://www.youtube.com/playlist?list=PLAwxTw4SYaPkWVHeC_8aSIbSxE_NXI76g) | 4 weeks | 6 hours/week | Python, programming experience + +(*) book by Blackburn, Bos, Striegnitz (compiled from [source](https://github.com/LearnPrologNow/lpn), redistributed under [CC license](https://creativecommons.org/licenses/by-sa/4.0/)) + +#### 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 | Notes +:-- | :--: | :--: | :--: | :--: +[Computation Structures 1: Digital Circuits](https://learning.edx.org/course/course-v1:MITx+6.004.1x_3+3T2016) [alternative 1](https://ocw.mit.edu/courses/6-004-computation-structures-spring-2017/) [alternative 2](https://ocw.mit.edu/courses/6-004-computation-structures-spring-2009/) | 10 weeks | 6 hours/week | [Nand2Tetris II](https://www.coursera.org/learn/nand2tetris2) | Alternate links contain all 3 courses. +[Computation Structures 2: Computer Architecture](https://learning.edx.org/course/course-v1:MITx+6.004.2x+3T2015) | 10 weeks | 6 hours/week | Computation Structures 1 | - +[Computation Structures 3: Computer Organization](https://learning.edx.org/course/course-v1:MITx+6.004.3x_2+1T2017) | 10 weeks | 6 hours/week | Computation Structures 2 | - + +#### 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` +`game trees` +`and more` + +Courses | Duration | Effort | Prerequisites +:-- | :--: | :--: | :--: +[Theory of Computation](https://ocw.mit.edu/courses/18-404j-theory-of-computation-fall-2020/) ([alternative](https://www.youtube.com/playlist?list=PLEE7DF8F5E0203A56)) | 13 weeks | 10 hours/week | [Mathematics for Computer Science](https://openlearninglibrary.mit.edu/courses/course-v1:OCW+6.042J+2T2019/about), logic, algorithms +[Computational Geometry](https://www.edx.org/learn/geometry/tsinghua-university-ji-suan-ji-he-computational-geometry) | 16 weeks | 8 hours/week | algorithms, C++ +[Game Theory](https://www.coursera.org/learn/game-theory-1) | 8 weeks | 3 hours/week | mathematical thinking, probability, calculus + +#### Advanced Information Security + +Courses | Duration | Effort | Prerequisites +:-- | :--: | :--: | :--: +[Web Security Fundamentals](https://www.edx.org/learn/computer-security/ku-leuven-web-security-fundamentals) | 5 weeks | 4-6 hours/week | understanding basic web technologies +[Security Governance & Compliance](https://www.coursera.org/learn/security-governance-compliance) | 3 weeks | 3 hours/week | - +[Digital Forensics Concepts](https://www.coursera.org/learn/digital-forensics-concepts) | 3 weeks | 2-3 hours/week | Core Security +[Secure Software Development: Requirements, Design, and Reuse](https://www.edx.org/learn/software-development/the-linux-foundation-secure-software-development-requirements-design-and-reuse) | 7 weeks | 1-2 hours/week | Core Programming and Core Security +[Secure Software Development: Implementation](https://www.edx.org/learn/software-development/the-linux-foundation-secure-software-development-implementation) | 7 weeks | 1-2 hours/week | Secure Software Development: Requirements, Design, and Reuse +[Secure Software Development: Verification and More Specialized Topics](https://www.edx.org/learn/software-engineering/the-linux-foundation-secure-software-development-verification-and-more-specialized-topics) | 7 weeks | 1-2 hours/week | Secure Software Development: Implementation + +#### Advanced math + +Courses | Duration | Effort | Prerequisites +:-- | :--: | :--: | :--: +[Essence of Linear Algebra](https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab) | - | - | [high school math](/precollege-math/index.md) +[Linear Algebra](https://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/) | 14 weeks | 12 hours/week | corequisite: Essence of Linear Algebra +[Introduction to Numerical Methods](https://ocw.mit.edu/courses/mathematics/18-335j-introduction-to-numerical-methods-spring-2019/index.htm)| 14 weeks | 12 hours/week | [Linear Algebra](https://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/) +[Introduction to Formal Logic](https://forallx.openlogicproject.org/) | 10 weeks | 4-8 hours/week | [Set Theory](https://www.youtube.com/playlist?list=PL5KkMZvBpo5AH_5GpxMiryJT6Dkj32H6N) +[Probability](https://stat110.hsites.harvard.edu/) | 15 weeks | 5-10 hours/week | [Differentiation and Integration](https://www.edx.org/course/calculus-1b-integration) + diff --git a/docs/computer-science/advanced-cs/final-project/index.md b/docs/computer-science/advanced-cs/final-project/index.md new file mode 100644 index 0000000..dc2b13f --- /dev/null +++ b/docs/computer-science/advanced-cs/final-project/index.md @@ -0,0 +1,32 @@ +--- +sidebar_position: 6 +--- + +# Final Project +*Timeline: varies per student* + +### Final project + +Part of learning is doing. +The assignments and exams for each course are to prepare you to use your knowledge to solve real-world problems. + +After you've completed Core CS and the parts of Advanced CS relevant to you, +you should identify a problem that you can solve using the knowledge you've acquired. +You can create something entirely new, or you can improve some tool/program that you use and wish were better. + +Students who would like more guidance in creating a project may choose to use a series of project oriented courses. +Here is a sample of options +(many more are available, at this point you should be capable of identifying a series that is interesting and relevant to you): + +Courses | Duration | Effort | Prerequisites +:-- | :--: | :--: | :--: +[Fullstack Open](https://fullstackopen.com/en/) | 12 weeks | 15 hours/week | programming +[Modern Robotics (Specialization)](https://www.coursera.org/specializations/modernrobotics) | 26 weeks | 2-5 hours/week | freshman-level physics, linear algebra, calculus, [linear ordinary differential equations](https://www.khanacademy.org/math/differential-equations) +[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 +[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/week | One year programming experience +[Game Design and Development with Unity 2020 (Specialization)](https://www.coursera.org/specializations/game-design-and-development) | 6 months | 5 hours/week | programming, interactive design + diff --git a/docs/computer-science/advanced-cs/index.md b/docs/computer-science/advanced-cs/index.md new file mode 100644 index 0000000..a413a15 --- /dev/null +++ b/docs/computer-science/advanced-cs/index.md @@ -0,0 +1,10 @@ +--- +sidebar_position: 10 +--- + +# Advanced CS +*Timeline: varies per student* + +import DocCardList from '@theme/DocCardList'; + + diff --git a/docs/computer-science/applications/computer-graphics/index.md b/docs/computer-science/applications/computer-graphics/index.md new file mode 100644 index 0000000..1d3a34d --- /dev/null +++ b/docs/computer-science/applications/computer-graphics/index.md @@ -0,0 +1,12 @@ +--- +sidebar_position: 3 +--- + +# Computer graphics +*Timeline: 72 hours* + +Learn to create images of 3D scenes in both real-time and with realistic ray tracing in this introductory computer graphics course. +- [Computer Graphics](https://www.edx.org/learn/computer-graphics/the-university-of-california-san-diego-computer-graphics) + +Alternative course: +- [CSE 167: Computer Graphics](https://cseweb.ucsd.edu/~viscomp/classes/cse167/wi22/schedule.html) \ No newline at end of file diff --git a/docs/computer-science/applications/databases/index.md b/docs/computer-science/applications/databases/index.md new file mode 100644 index 0000000..693c697 --- /dev/null +++ b/docs/computer-science/applications/databases/index.md @@ -0,0 +1,11 @@ +--- +sidebar_position: 1 +--- + +# Databases +*Timeline: 60 hours* + +These courses will give the student a basic understanding of databases, specifically with SQL: +- [Relational Databases & SQL](https://www.edx.org/learn/relational-databases/stanford-university-databases-relational-databases-and-sql), 20 hrs +- [Modeling & Theory](https://www.edx.org/learn/databases/stanford-university-databases-modeling-and-theory), 20 hrs +- [Semistructured Data](https://www.edx.org/learn/relational-databases/stanford-university-databases-semistructured-data), 20 hrs diff --git a/docs/computer-science/applications/index.md b/docs/computer-science/applications/index.md new file mode 100644 index 0000000..3a15019 --- /dev/null +++ b/docs/computer-science/applications/index.md @@ -0,0 +1,10 @@ +--- +sidebar_position: 9 +--- + +# Applications +*Timeline: 279 - 291 hours* + +import DocCardList from '@theme/DocCardList'; + + diff --git a/docs/computer-science/applications/machine-learning/index.md b/docs/computer-science/applications/machine-learning/index.md new file mode 100644 index 0000000..915b8d2 --- /dev/null +++ b/docs/computer-science/applications/machine-learning/index.md @@ -0,0 +1,14 @@ +--- +sidebar_position: 2 +--- + +# Machine Learning +*Timeline: 99 hours* + +These courses provide a broad introduction to modern machine learning, including supervised learning (multiple linear regression, logistic regression, neural networks, and decision trees), unsupervised learning (clustering, dimensionality reduction, recommender systems), and some of the best practices used in Silicon Valley for artificial intelligence and machine learning innovation (evaluating and tuning models, taking a data-centric approach to improving performance, and more.) + +- [Supervised Machine Learning: Regression and Classification](https://www.coursera.org/learn/machine-learning), 33 hrs + +- [Advanced Learning Algorithms](https://www.coursera.org/learn/advanced-learning-algorithms), 34 hrs + +- [Unsupervised Learning, Recommenders, Reinforcement Learning](https://www.coursera.org/learn/unsupervised-learning-recommenders-reinforcement-learning), 27 hrs \ No newline at end of file diff --git a/docs/computer-science/applications/software-engineering/index.md b/docs/computer-science/applications/software-engineering/index.md new file mode 100644 index 0000000..794c4ee --- /dev/null +++ b/docs/computer-science/applications/software-engineering/index.md @@ -0,0 +1,16 @@ +--- +sidebar_position: 4 +--- + +# Software Engineering +*Timeline: 48 - 60 hours* + +This course introduces how teams design, build, and test multi-version software systems. + +You will learn software engineering principles that are applicable to the breadth of large-scale software systems. The course explores topics such as agile development, REST and Async programming, software specification, design, refactoring, information security, and more. + +By the end of this course, learners will work in teams, applying an agile software development process to specify, design, and test multiple versions of complex software systems. +- [Software Engineering: Introduction](https://www.edx.org/learn/software-engineering/university-of-british-columbia-software-engineering-introduction) + +Alternative: +- [UBC CPSC - Software Engineering Resources](https://github.com/ubccpsc/310/blob/main/resources/README.md) diff --git a/docs/computer-science/ethics-security/cyber-fundamentals/index.md b/docs/computer-science/ethics-security/cyber-fundamentals/index.md new file mode 100644 index 0000000..435ac99 --- /dev/null +++ b/docs/computer-science/ethics-security/cyber-fundamentals/index.md @@ -0,0 +1,12 @@ +--- +sidebar_position: 2 +--- + +# Cybersecurity +*Timeline: 80 - 96 hours* + +Learn cybersecurity fundamentals, including how to detect threats, protect systems and networks, and anticipate potential cyber attacks. +- [Cybersecurity Fundamentals](https://www.edx.org/learn/cybersecurity/rochester-institute-of-technology-cybersecurity-fundamentals) + +Extra resources: +- [Professor Messer SY0-701 Security+ Training Course](https://www.youtube.com/playlist?list=PLG49S3nxzAnl4QDVqK-hOnoqcSKEIDDuv) \ No newline at end of file diff --git a/docs/computer-science/ethics-security/ethics/index.md b/docs/computer-science/ethics-security/ethics/index.md new file mode 100644 index 0000000..b3be6ad --- /dev/null +++ b/docs/computer-science/ethics-security/ethics/index.md @@ -0,0 +1,15 @@ +--- +sidebar_position: 1 +--- + +# Ethics +*Timeline: 35 hours* + +This course provides an introduction to ethics in engineering and technology. +- [Ethics, Technology & Engineering](https://www.coursera.org/learn/ethics-technology-engineering), 18 hrs + +This course will introduce the various types of U.S. intellectual property: patents, which cover inventions and process innovations; copyright, which protects original works of authorship; and trademarks, which protect a business’ commercial identity as the source of valuable goods and services. You will then explore case studies of how global businesses have used intellectual property law to generate enormous value from these intangible assets. +- [Introduction to Intelectual Property](https://www.coursera.org/learn/introduction-intellectual-property), 8 hrs + +This course is designed to introduce data privacy to a wide audience and help each participant see how data privacy has evolved as a compelling concern to public and private organizations as well as individuals. In this course, you will hear from legal and technical experts and practitioners who encounter data privacy issues daily. This course will review theories of data privacy as well as data privacy in the context of social media and artificial intelligence. It will also explore data privacy issues in journalism, surveillance, new technologies like facial recognition and biometrics. +- [Data Privacy Fundamentals](https://www.coursera.org/learn/northeastern-data-privacy), 9 hrs \ No newline at end of file diff --git a/docs/computer-science/ethics-security/index.md b/docs/computer-science/ethics-security/index.md new file mode 100644 index 0000000..2a4a477 --- /dev/null +++ b/docs/computer-science/ethics-security/index.md @@ -0,0 +1,10 @@ +--- +sidebar_position: 8 +--- + +# Ethics & Security +*Timeline: 167 - 183 hours* + +import DocCardList from '@theme/DocCardList'; + + diff --git a/docs/computer-science/ethics-security/secure-coding-practices/index.md b/docs/computer-science/ethics-security/secure-coding-practices/index.md new file mode 100644 index 0000000..ffc217d --- /dev/null +++ b/docs/computer-science/ethics-security/secure-coding-practices/index.md @@ -0,0 +1,15 @@ +--- +sidebar_position: 3 +--- + +# Secure Coding Practices +*Timeline: 52 hours* + +Through these courses, you will cover the principles of secure coding, concepts of threat modeling, cryptography, and exploit vulnerabilities in C/C++ or Java languages, all of which will prepare you to think like a hacker and protect your organizations information. The courses provide ample practice activities including exploiting WebGoat, an OWASP project designed to teach penetration testing. + +- [Principles of Secure Coding](https://www.coursera.org/learn/secure-coding-principles), 16 hrs +- [Identifying Security Vulnerabilities](https://www.coursera.org/learn/identifying-security-vulnerabilities), 16 hrs + +Now pick **one** of the following courses to apply your knowledge: +- [Identifying Security Vulnerabilities in C/C++](https://www.coursera.org/learn/identifying-security-vulnerabilities-c-programming), 20 hrs +- [Identifying Security Vulnerabilities in Java](https://www.coursera.org/learn/exploiting-securing-vulnerabilities-java-applications), 20 hrs \ No newline at end of file diff --git a/docs/computer-science/extras/index.md b/docs/computer-science/extras/index.md index 2aa0bb7..a85e7b2 100644 --- a/docs/computer-science/extras/index.md +++ b/docs/computer-science/extras/index.md @@ -1,5 +1,5 @@ --- -sidebar_position: 3 +sidebar_position: 11 --- # Extra Resources diff --git a/docs/computer-science/index.md b/docs/computer-science/index.md index d3eb14b..9c481d6 100644 --- a/docs/computer-science/index.md +++ b/docs/computer-science/index.md @@ -2,7 +2,7 @@ sidebar_position: 1 --- -# Computer Science +# Computer Science Overview ![The Borr Project - Computer Science](borrproject.webp) @@ -26,14 +26,13 @@ but specifically chosen to meet the following criteria. 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) or [extras/readings](extras/readings). +they belong in [extras/courses](extras/courses) or [extras/readings](extras/readings). Some may be mentioned as supplemental to the recommended course. **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 +- *[Intro CS](#intro-cs)*: for students to try out CS and see if it's right for them +- *[Core CS](#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](#advanced-cs)*: corresponds roughly to the final year of a computer science curriculum, taking [electives](advanced-cs/electives/index.md) according to the student's interests and a [final project](advanced-cs/final-project/index.md) for students to validate, consolidate, and display their knowledge, to be evaluated by their peers worldwide **Duration**. It is possible to finish within about 2 years if you plan carefully and devote roughly 20 hours/week to your studies. Learners can use [this spreadsheet](https://docs.google.com/spreadsheets/d/1Pp4z-ulYDT9Px88oTQP5FJiZWyk8LcF7cBvc6SVXu6o/copy) to estimate their end date. Make a copy and input your start date and expected hours per week in the `Timeline` sheet. As you work through courses you can enter your actual course completion dates in the `Curriculum Data` sheet and get updated completion estimates. @@ -68,327 +67,117 @@ just remember that you can't purchase success! > - An unmaintained and deprecated trello board > - Third-party notion templates -## Curriculum +## Intro CS ### Prerequisites -- [Core CS](#core-cs) assumes the student has already taken [high school math](../precollege-math), including algebra, geometry, and pre-calculus. -- [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 - -This course will introduce you to the world of computer science and programming. This course gives you a flavor of the material to come. If you finish the course wanting more, Computer Science is likely for you! - -**Topics covered**: -`computation` -`imperative programming` -`basic data structures and algorithms` -`and more` - -Courses | Duration | Effort | Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: -[Introduction to Computer Science and Programming using Python](coursepages/intro-cs) | 14 weeks | 6-10 hours/week | [high school algebra](../precollege-math) | [chat](https://discord.gg/JM8WwGedwW) - -### 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` -`static typing` -`dynamic typing` -`ML-family languages (via Standard ML)` -`Lisp-family languages (via Racket)` -`Ruby` -`and more` - -Courses | Duration | Effort | Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: -[Systematic Program Design](coursepages/spd) | 13 weeks | 8-10 hours/week | none | [chat](https://discord.gg/ep93nPwteG) -[Class-based Program Design](https://course.ccs.neu.edu/cs2510sp22/index.html) | 13 weeks | 5-10 hours/week | Systematic Program Design, High School Math | [chat](https://discord.gg/KPAZYDY3V5) -[Programming Languages, Part A](https://www.coursera.org/learn/programming-languages) | 5 weeks | 4-8 hours/week | Systematic Program Design ([Hear instructor](https://www.coursera.org/lecture/programming-languages/recommended-background-k1yuh)) | [chat](https://discord.gg/R6esaxXada) -[Programming Languages, Part B](https://www.coursera.org/learn/programming-languages-part-b) | 3 weeks | 4-8 hours/week | Programming Languages, Part A | [chat](https://discord.gg/R6esaxXada) -[Programming Languages, Part C](https://www.coursera.org/learn/programming-languages-part-c) | 3 weeks | 4-8 hours/week | Programming Languages, Part B | [chat](https://discord.gg/R6esaxXada) -[Object-Oriented Design](https://course.ccs.neu.edu/cs3500f19/) | 13 weeks | 5-10 hours/week | Class Based Program Design | [chat](https://discord.gg/7n9A5yfGSK) -[Software Architecture](https://www.coursera.org/learn/software-architecture) | 4 weeks | 2-5 hours/week | Object Oriented Design | [chat](https://discord.gg/88dtSABJpF) - -#### Core math - -Discrete math (Math for CS) is a prerequisite and closely related to the study of algorithms and data structures. Calculus both prepares students for discrete math and helps students develop mathematical maturity. - -**Topics covered**: -`discrete mathematics` -`mathematical proofs` -`basic statistics` -`O-notation` -`discrete probability` -`and more` - -Courses | Duration | Effort | Notes | Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: | :--: -[Calculus 1A: Differentiation](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+18.01.1x+2T2019/about) ([alternative](https://ocw.mit.edu/courses/mathematics/18-01sc-single-variable-calculus-fall-2010/index.htm)) | 13 weeks | 6-10 hours/week | The alternate covers this and the following 2 courses | [high school math](../precollege-math) | [chat](https://discord.gg/VmYyrdssHJ) -[Calculus 1B: Integration](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+18.01.2x+3T2019/about) | 13 weeks | 5-10 hours/week | - | Calculus 1A | [chat](https://discord.gg/VmYyrdssHJ) -[Calculus 1C: Coordinate Systems & Infinite Series](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+18.01.3x+1T2020/about) | 6 weeks | 5-10 hours/week | - | Calculus 1B | [chat](https://discord.gg/VmYyrdssHJ) -[Mathematics for Computer Science](https://openlearninglibrary.mit.edu/courses/course-v1:OCW+6.042J+2T2019/about) ([alternative](https://ocw.mit.edu/courses/6-042j-mathematics-for-computer-science-fall-2010/)) | 13 weeks | 5 hours/week | [2015/2019 solutions](https://github.com/spamegg1/Math-for-CS-solutions) [2010 solutions](https://github.com/frevib/mit-cs-math-6042-fall-2010-problems) [2005 solutions](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-fall-2005/assignments/). | Calculus 1C | [chat](https://discord.gg/zE3pArAup4) - -#### CS Tools - -Understanding theory is important, but you will also be expected to create programs. There are a number of tools that are widely used to make that process easier. Learn them now to ease your future work writing programs. - -**Topics covered**: -`terminals and shell scripting` -`vim` -`command line environments` -`version control` -`and more` - -Courses | Duration | Effort | Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: -[The Missing Semester of Your CS Education](https://missing.csail.mit.edu/) | 2 weeks | 12 hours/week | - | [chat](https://discord.gg/KNUmYNtHp3) - -#### Core systems - -**Topics covered**: -`procedural programming` -`manual memory management` -`boolean algebra` -`gate logic` -`memory` -`computer architecture` -`assembly` -`machine language` -`virtual machines` -`high-level languages` -`compilers` -`operating systems` -`network protocols` -`and more` - -Courses | Duration | Effort | Additional Text / Assignments| Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: | :--: -[Build a Modern Computer from First Principles: From Nand to Tetris](https://www.coursera.org/learn/build-a-computer) ([alternative](https://www.nand2tetris.org/)) | 6 weeks | 7-13 hours/week | - | C-like programming language | [chat](https://discord.gg/Yvk8xDRycS) -[Build a Modern Computer from First Principles: Nand to Tetris Part II ](https://www.coursera.org/learn/nand2tetris2) | 6 weeks | 12-18 hours/week | - | one of [these programming languages](https://user-images.githubusercontent.com/2046800/35426340-f6ce6358-026a-11e8-8bbb-4e95ac36b1d7.png), From Nand to Tetris Part I | [chat](https://discord.gg/Yvk8xDRycS) -[Operating Systems: Three Easy Pieces](coursepages/ostep) | 10-12 weeks | 6-10 hours/week | - | Nand to Tetris Part II | [chat](https://discord.gg/Yvk8xDRycS) -[Computer Networking: a Top-Down Approach](http://gaia.cs.umass.edu/kurose_ross/online_lectures.htm)| 8 weeks | 4–12 hours/week | [Wireshark Labs](http://gaia.cs.umass.edu/kurose_ross/wireshark.php) | algebra, probability, basic CS | [chat](https://discord.gg/Yvk8xDRycS) - -#### 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 | Discussion -:-- | :--: | :--: | :--: | :--: -[Divide and Conquer, Sorting and Searching, and Randomized Algorithms](https://www.coursera.org/learn/algorithms-divide-conquer) | 4 weeks | 4-8 hours/week | any programming language, Mathematics for Computer Science | [chat](https://discord.gg/8E6MMMmjR4) -[Graph Search, Shortest Paths, and Data Structures](https://www.coursera.org/learn/algorithms-graphs-data-structures) | 4 weeks | 4-8 hours/week | Divide and Conquer, Sorting and Searching, and Randomized Algorithms | [chat](https://discord.gg/8E6MMMmjR4) -[Greedy Algorithms, Minimum Spanning Trees, and Dynamic Programming](https://www.coursera.org/learn/algorithms-greedy) | 4 weeks | 4-8 hours/week | Graph Search, Shortest Paths, and Data Structures | [chat](https://discord.gg/8E6MMMmjR4) -[Shortest Paths Revisited, NP-Complete Problems and What To Do About Them](https://www.coursera.org/learn/algorithms-npcomplete) | 4 weeks | 4-8 hours/week | Greedy Algorithms, Minimum Spanning Trees, and Dynamic Programming | [chat](https://discord.gg/8E6MMMmjR4) - -#### Core security - -**Topics covered** -`Confidentiality, Integrity, Availability` -`Secure Design` -`Defensive Programming` -`Threats and Attacks` -`Network Security` -`Cryptography` -`and more` - -Courses | Duration | Effort | Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: -[Cybersecurity Fundamentals](https://www.edx.org/learn/cybersecurity/rochester-institute-of-technology-cybersecurity-fundamentals) | 8 weeks | 10-12 hours/week | - | [chat](https://discord.gg/QCVy9e4Pbd) -[Principles of Secure Coding](https://www.coursera.org/learn/secure-coding-principles)| 4 weeks | 4 hours/week | - | [chat](https://discord.gg/QCVy9e4Pbd) -[Identifying Security Vulnerabilities](https://www.coursera.org/learn/identifying-security-vulnerabilities) | 4 weeks | 4 hours/week | - | [chat](https://discord.gg/QCVy9e4Pbd) - -Choose **one** of the following: - -Courses | Duration | Effort | Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: -[Identifying Security Vulnerabilities in C/C++Programming](https://www.coursera.org/learn/identifying-security-vulnerabilities-c-programming) | 4 weeks | 5 hours/week | - | [chat](https://discord.gg/QCVy9e4Pbd) -[Exploiting and Securing Vulnerabilities in Java Applications](https://www.coursera.org/learn/exploiting-securing-vulnerabilities-java-applications) | 4 weeks | 5 hours/week | - | [chat](https://discord.gg/QCVy9e4Pbd) - -#### Core applications - -**Topics covered**: -`Agile methodology` -`REST` -`software specifications` -`refactoring` -`relational databases` -`transaction processing` -`data modeling` -`neural networks` -`supervised learning` -`unsupervised learning` -`OpenGL` -`ray tracing` -`and more` - -Courses | Duration | Effort | Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: -[Databases: Modeling and Theory](https://www.edx.org/learn/databases/stanford-university-databases-modeling-and-theory)| 2 weeks | 10 hours/week | core programming | [chat](https://discord.gg/aNDUSGdwjM) -[Databases: Relational Databases and SQL](https://www.edx.org/learn/relational-databases/stanford-university-databases-relational-databases-and-sql)| 2 weeks | 10 hours/week | core programming | [chat](https://discord.gg/aNDUSGdwjM) -[Databases: Semistructured Data](https://www.edx.org/learn/relational-databases/stanford-university-databases-semistructured-data)| 2 weeks | 10 hours/week | core programming | [chat](https://discord.gg/aNDUSGdwjM) -[Machine Learning](https://www.coursera.org/specializations/machine-learning-introduction)| 11 weeks | 9 hours/week | Basic coding | [chat](https://discord.gg/aNDUSGdwjM) -[Computer Graphics](https://www.edx.org/learn/computer-graphics/the-university-of-california-san-diego-computer-graphics) ([alternative](https://cseweb.ucsd.edu/~viscomp/classes/cse167/wi22/schedule.html))| 6 weeks | 12 hours/week | C++ or Java, [Basic Linear Algebra](../precollege-math) | [chat](https://discord.gg/aNDUSGdwjM) -[Software Engineering: Introduction](https://www.edx.org/learn/software-engineering/university-of-british-columbia-software-engineering-introduction) ([alternative](https://github.com/ubccpsc/310/blob/main/resources/README.md)) | 6 weeks | 8-10 hours/week | Core Programming, and a sizable project | [chat](https://discord.gg/aNDUSGdwjM) - -#### Core ethics - -**Topics covered**: -`Social Context` -`Analytical Tools` -`Professional Ethics` -`Intellectual Property` -`Privacy and Civil Liberties` -`and more` - -Courses | Duration | Effort | Prerequisites | Discussion -:-- | :--: | :--: | :--: | :--: -[Ethics, Technology and Engineering](https://www.coursera.org/learn/ethics-technology-engineering)| 9 weeks | 2 hours/week | none | [chat](https://discord.gg/BVZv7ByZst) -[Introduction to Intellectual Property](https://www.coursera.org/learn/introduction-intellectual-property)| 4 weeks | 2 hours/week | none | [chat](https://discord.gg/BVZv7ByZst) -[Data Privacy Fundamentals](https://www.coursera.org/learn/northeastern-data-privacy)| 3 weeks | 3 hours/week | none | [chat](https://discord.gg/BVZv7ByZst) - -### 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. - -#### Advanced programming - -**Topics covered**: -`debugging theory and practice` -`goal-oriented programming` -`parallel computing` -`object-oriented analysis and design` -`UML` -`large-scale software architecture and design` -`and more` - -Courses | Duration | Effort | Prerequisites -:-- | :--: | :--: | :--: -[Parallel Programming](https://www.coursera.org/learn/scala-parallel-programming)| 4 weeks | 6-8 hours/week | Scala programming -[Compilers](https://www.edx.org/learn/computer-science/stanford-university-compilers) | 9 weeks | 6-8 hours/week | none -[Introduction to Haskell](https://www.seas.upenn.edu/~cis194/fall16/)| 14 weeks | - | - -[Learn Prolog Now!](https://www.let.rug.nl/bos/lpn//lpnpage.php?pageid=online) ([alternative](https://github.com/ossu/computer-science/files/6085884/lpn.pdf))*| 12 weeks | - | - -[Software Debugging](https://www.youtube.com/playlist?list=PLAwxTw4SYaPkxK63TiT88oEe-AIBhr96A)| 8 weeks | 6 hours/week | Python, object-oriented programming -[Software Testing](https://www.youtube.com/playlist?list=PLAwxTw4SYaPkWVHeC_8aSIbSxE_NXI76g) | 4 weeks | 6 hours/week | Python, programming experience - -(*) book by Blackburn, Bos, Striegnitz (compiled from [source](https://github.com/LearnPrologNow/lpn), redistributed under [CC license](https://creativecommons.org/licenses/by-sa/4.0/)) - -#### 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 | Notes -:-- | :--: | :--: | :--: | :--: -[Computation Structures 1: Digital Circuits](https://learning.edx.org/course/course-v1:MITx+6.004.1x_3+3T2016) [alternative 1](https://ocw.mit.edu/courses/6-004-computation-structures-spring-2017/) [alternative 2](https://ocw.mit.edu/courses/6-004-computation-structures-spring-2009/) | 10 weeks | 6 hours/week | [Nand2Tetris II](https://www.coursera.org/learn/nand2tetris2) | Alternate links contain all 3 courses. -[Computation Structures 2: Computer Architecture](https://learning.edx.org/course/course-v1:MITx+6.004.2x+3T2015) | 10 weeks | 6 hours/week | Computation Structures 1 | - -[Computation Structures 3: Computer Organization](https://learning.edx.org/course/course-v1:MITx+6.004.3x_2+1T2017) | 10 weeks | 6 hours/week | Computation Structures 2 | - - -#### 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` -`game trees` -`and more` - -Courses | Duration | Effort | Prerequisites -:-- | :--: | :--: | :--: -[Theory of Computation](https://ocw.mit.edu/courses/18-404j-theory-of-computation-fall-2020/) ([alternative](https://www.youtube.com/playlist?list=PLEE7DF8F5E0203A56)) | 13 weeks | 10 hours/week | [Mathematics for Computer Science](https://openlearninglibrary.mit.edu/courses/course-v1:OCW+6.042J+2T2019/about), logic, algorithms -[Computational Geometry](https://www.edx.org/learn/geometry/tsinghua-university-ji-suan-ji-he-computational-geometry) | 16 weeks | 8 hours/week | algorithms, C++ -[Game Theory](https://www.coursera.org/learn/game-theory-1) | 8 weeks | 3 hours/week | mathematical thinking, probability, calculus - -#### Advanced Information Security - -Courses | Duration | Effort | Prerequisites -:-- | :--: | :--: | :--: -[Web Security Fundamentals](https://www.edx.org/learn/computer-security/ku-leuven-web-security-fundamentals) | 5 weeks | 4-6 hours/week | understanding basic web technologies -[Security Governance & Compliance](https://www.coursera.org/learn/security-governance-compliance) | 3 weeks | 3 hours/week | - -[Digital Forensics Concepts](https://www.coursera.org/learn/digital-forensics-concepts) | 3 weeks | 2-3 hours/week | Core Security -[Secure Software Development: Requirements, Design, and Reuse](https://www.edx.org/learn/software-development/the-linux-foundation-secure-software-development-requirements-design-and-reuse) | 7 weeks | 1-2 hours/week | Core Programming and Core Security -[Secure Software Development: Implementation](https://www.edx.org/learn/software-development/the-linux-foundation-secure-software-development-implementation) | 7 weeks | 1-2 hours/week | Secure Software Development: Requirements, Design, and Reuse -[Secure Software Development: Verification and More Specialized Topics](https://www.edx.org/learn/software-engineering/the-linux-foundation-secure-software-development-verification-and-more-specialized-topics) | 7 weeks | 1-2 hours/week | Secure Software Development: Implementation - -#### Advanced math - -Courses | Duration | Effort | Prerequisites -:-- | :--: | :--: | :--: -[Essence of Linear Algebra](https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab) | - | - | [high school math](../precollege-math) -[Linear Algebra](https://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/) | 14 weeks | 12 hours/week | corequisite: Essence of Linear Algebra -[Introduction to Numerical Methods](https://ocw.mit.edu/courses/mathematics/18-335j-introduction-to-numerical-methods-spring-2019/index.htm)| 14 weeks | 12 hours/week | [Linear Algebra](https://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/) -[Introduction to Formal Logic](https://forallx.openlogicproject.org/) | 10 weeks | 4-8 hours/week | [Set Theory](https://www.youtube.com/playlist?list=PL5KkMZvBpo5AH_5GpxMiryJT6Dkj32H6N) -[Probability](https://stat110.hsites.harvard.edu/) | 15 weeks | 5-10 hours/week | [Differentiation and Integration](https://www.edx.org/course/calculus-1b-integration) - -### Final project - -Part of learning is doing. -The assignments and exams for each course are to prepare you to use your knowledge to solve real-world problems. - -After you've completed Core CS and the parts of Advanced CS relevant to you, -you should identify a problem that you can solve using the knowledge you've acquired. -You can create something entirely new, or you can improve some tool/program that you use and wish were better. - -Students who would like more guidance in creating a project may choose to use a series of project oriented courses. -Here is a sample of options -(many more are available, at this point you should be capable of identifying a series that is interesting and relevant to you): - -Courses | Duration | Effort | Prerequisites -:-- | :--: | :--: | :--: -[Fullstack Open](https://fullstackopen.com/en/) | 12 weeks | 15 hours/week | programming -[Modern Robotics (Specialization)](https://www.coursera.org/specializations/modernrobotics) | 26 weeks | 2-5 hours/week | freshman-level physics, linear algebra, calculus, [linear ordinary differential equations](https://www.khanacademy.org/math/differential-equations) -[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 -[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/week | One year programming experience -[Game Design and Development with Unity 2020 (Specialization)](https://www.coursera.org/specializations/game-design-and-development) | 6 months | 5 hours/week | programming, interactive design +*Timeline: 0 - 2 years* + +Get a thorough idea of what it takes to begin study of Computer Science at The Borr Project. While some of these prerequisites may be daunting, they are vital for success in this curriculum. To break things up, feel free to work on Elementary Programming, an optional course that introduces the very basics of programming. + +- [Prerequisites & Motivation](prerequisites/index.md) +- [Elementary Programming](prerequisites/elementary-programming.md) (Optional) + +### Introduction to Computer Science + +*Timeline: 108 - 164 hours* + +*Prerequisites: [High school math](../precollege-math/)* + +Get a birds eye view of what the field of Computer Science entails. Even if you have programmed in the past, you will find the MIT's Intro to CS with Python to be a great experience in teaching you the basics of computer science. Note that although the course is taught with Python, the focus of the course is not on the particular language, but core concepts of Computer Science. + +- [Introduction to CS](intro-cs/index.md) + +Understanding theory is important, but you will also be expected to create programs. There are a number of tools that are widely used to make that process easier. MIT's Missing Semester is a course reviewing such tools. Learn them now to ease your future work writing programs. + +- [Missing Semester](intro-cs/missing-semester/index.md) + +## Core CS + +### Program Design + +*Timeline: 325 - 500 hours* + +*Prerequisites: [High school math](../precollege-math/), [Intro CS](intro-cs/)* + +Learn how to think like a programmer and build robust, well-structured, thoroughly-tested software. These courses are the cornerstone of your CS education. You will find that the practical concepts of Data Structures and Algorithms distributed throughout this pathway. More theory-oriented DSA courses come later in the theory track. + +- [Systematic Program Design](program-design/spd/index.md) +- [Class-Based Program Design](program-design/class-based/index.md) +- [Programming Languages](program-design/programming-languages/index.md) +- [Object-Oriented Design](program-design/object-oriented/index.md) +- [Software Architecture](program-design/software-architecture/index.md) + +### Math + +*Timeline: 1 - 2 years* + +*Prerequisites: [High school math](../precollege-math/)* + +Build a rigorous foundation in mathematical thinking, which is essential for mastering computer science. The goal is to sharpen your analytical thinking so you can confidently tackle complex computational and algorithmic challenges. + +- [Calculus](math/calculus/index.md) +- [Discrete Mathematics](math/discrete-math/index.md) + +### Systems + +*Timeline: 250 - 500 hours* + +*Prerequisites: [Program Design](program-design/)* + +Learn how computers actually works. You will build a simulated version of a computer from scratch, learn the inner workings of operating systems, and take a look into how computers communicate with each other. This track will demystify how the programs you write actually get executed by the computer. + +- [Nand2Tetris](systems/nand2tetris/index.md) +- [Operating Systems](systems/ostep/index.md) +- [Computer Networking](systems/networking/index.md) + +### Theory + +*Timeline: 64 - 128 hours* + +*Prerequisites: [Discrete Math](math/discrete-math/), [Program Design](program-design/)* + +Get a perspective into why certain ways of solving a problem are better than others. Learn about complexity and theoretical limits of algorithms. Get an idea of what computers can or cannot do. These courses are the pillars of Computer Science. +- [Theory](theory/index.md) + +### Ethics & Security + +*Timeline: 167 - 183 hours* + +*Prerequisites: [Program Design](program-design/)* + +Learn how to think critically about the social impact of technology and protect digital systems against evolving threats. These courses lay the foundation for responsible and secure software development. You will find concepts like privacy, threat modeling, cryptography, and ethical reasoning deeply interwoven throughout this track. + +- [Ethics](ethics-security/ethics/index.md) +- [Cybersecurity Fundamentals](ethics-security/cyber-fundamentals/index.md) +- [Secure Coding Practices](ethics-security/secure-coding-practices/index.md) + +### Applications + +*Timeline: 279 - 291 hours* + +*Prerequisites: [Program Design](program-design/)* + +Get to know how to use the skills you have learned apply to real world applications of Computer Science. Learn how to design database systems, how computer graphics work, and dip your feet into the world of machine learning. This track ends with teaching you how to tackle large sized real world projects. + +- [Databases](applications/databases/index.md) +- [Machine Learning](applications/machine-learning/index.md) +- [Computer Graphics](applications/computer-graphics/index.md) +- [Software Engineering](applications/software-engineering/index.md) + +## Advanced CS + +*Timeline: varies per student* + +*Prerequisites: all tracks included in [Core CS](#core-cs)* + +After completing every course in all previous tracks, choose a subset of courses from Advanced CS based on interest. Understand that these are electives; not every course needs to be taken. But take every course that is relevant to the field you intend to go into. You do not need to make this choice until you have completed all previous tracks, and it is suggested to only make the choice after that. + +- [Electives](advanced-cs/electives/index.md) + +Afterwards, visit our Final Project page to decide how you want to cap off your Computer Science journey. There are many paths you can take your career, and it is up to you to decide where to go. + +- [Final Project](advanced-cs/final-project/index.md) ### Congratulations diff --git a/docs/computer-science/coursepages/intro-cs.md b/docs/computer-science/intro-cs/index.md similarity index 96% rename from docs/computer-science/coursepages/intro-cs.md rename to docs/computer-science/intro-cs/index.md index 80a6dd8..549294a 100644 --- a/docs/computer-science/coursepages/intro-cs.md +++ b/docs/computer-science/intro-cs/index.md @@ -1,4 +1,9 @@ +--- +sidebar_position: 3 +--- + # Introduction to CS +*Timeline: 84 - 140 hours* This course will introduce you to the world of computer science and programming, giving you a flavor of the material to come. If you finish the course wanting more, Computer Science is likely for you! @@ -8,7 +13,7 @@ This course has been developed by MIT and is available on [MIT's OCW](https://oc **Course Link:** [https://ocw.mit.edu/courses/6-100l-introduction-to-cs-and-programming-using-python-fall-2022/pages/material-by-lecture/](https://ocw.mit.edu/courses/6-100l-introduction-to-cs-and-programming-using-python-fall-2022/pages/material-by-lecture/) -The course has been designed to accommodate people completely new to programming. However, if you find the course difficult to follow, you can try doing one of the [Intro to Programming courses](../intro-programming) and then return to this course. +The course has been designed to accommodate people completely new to programming. However, if you find the course difficult to follow, you can try doing one of the [Elementary Programming courses](../prerequisites/elementary-programming.md) and then return to this course. ## Instructions diff --git a/docs/computer-science/intro-cs/missing-semester/index.md b/docs/computer-science/intro-cs/missing-semester/index.md new file mode 100644 index 0000000..eb15faa --- /dev/null +++ b/docs/computer-science/intro-cs/missing-semester/index.md @@ -0,0 +1,9 @@ +--- +sidebar_position: 2 +--- + +# Missing Semester +*Timeline: 24 hours* + +Understanding theory is important, but you will also be expected to create programs. There are a number of tools that are widely used to make that process easier. Learn them now to ease your future work writing programs. +- https://missing.csail.mit.edu/ diff --git a/docs/computer-science/math/calculus/hw1-2.zip b/docs/computer-science/math/calculus/hw1-2.zip new file mode 100644 index 0000000..092a7ab Binary files /dev/null and b/docs/computer-science/math/calculus/hw1-2.zip differ diff --git a/docs/computer-science/math/calculus/hw3.zip b/docs/computer-science/math/calculus/hw3.zip new file mode 100644 index 0000000..799547f Binary files /dev/null and b/docs/computer-science/math/calculus/hw3.zip differ diff --git a/docs/computer-science/math/calculus/index.md b/docs/computer-science/math/calculus/index.md new file mode 100644 index 0000000..d0e749d --- /dev/null +++ b/docs/computer-science/math/calculus/index.md @@ -0,0 +1,21 @@ +--- +sidebar_position: 1 +--- + +# Calculus +*Timeline: 173 - 320 hours* + +Created by MIT, these three courses cover everything typically found in Calculus 1 & 2, which happens to be the scope of a Computer Science degree. +- [Calculus 1A: Differentiation](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+18.01.1x+2T2019/about), 78-130 hrs +- [Calculus 1B: Integration](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+18.01.2x+3T2019/about), 65-130 hrs +- [Calculus 1C: Coordinate Systems & Infinite Series](https://openlearninglibrary.mit.edu/courses/course-v1:MITx+18.01.3x+1T2020/about), 30-60 hrs + +This alternative course contains excellent problem sets that many students use to supplement the first course. +- [Single Variable Calculus](https://ocw.mit.edu/courses/18-01sc-single-variable-calculus-fall-2010/) + +Extra resources: +- [3Blue1Brown: Essence of Calculus](https://youtube.com/playlist?list=PLZHQObOWTQDMsr9K-rj53DwVRMYO3t5Yr) +- [OpenStax: Calculus Textbook Vol. 1](https://openstax.org/details/books/calculus-volume-1), [Vol. 2](https://openstax.org/details/books/calculus-volume-2) +- [The College Prep School: Calculus 1](https://youtu.be/playlist?list=PLm2VEQtiYjhrZz-k1HnnOe0C8TS46WbXm) +- [Khan Academy: Calculus BC](https://www.khanacademy.org/math/ap-calculus-bc) +- [Professor Leonard: Calculus 1](https://youtu.be/playlist?list=PLF797E961509B4EB5), [Calculus 2](https://youtu.be/playlist?list=PLDesaqWTN6EQ2J4vgsN1HyBeRADEh4Cw-) diff --git a/docs/computer-science/math/discrete-math/index.md b/docs/computer-science/math/discrete-math/index.md new file mode 100644 index 0000000..499c7d2 --- /dev/null +++ b/docs/computer-science/math/discrete-math/index.md @@ -0,0 +1,23 @@ +--- +sidebar_position: 2 +--- + +# Discrete Math +Timeline: 65 hours - 1 year + +Covers everything typically found in a Discrete Math course. +- [Mathematics for Computer Science 2019](https://openlearninglibrary.mit.edu/courses/course-v1:OCW+6.042J+2T2019/about), 65 hrs +- Alternative: [Mathematics for Computer Science 2010](https://ocw.mit.edu/courses/6-042j-mathematics-for-computer-science-fall-2010/) + +Many students choose to go with a paid textbook for an easier introduction to this subject: +- [Discrete Mathematics with Applications](https://www.amazon.com/Discrete-Mathematics-Applications-Susanna-Epp/dp/1337694193/), 1 year + +This book covers some topics which are covered again in [theory courses](/computer-science/theory/index.md). The MIT course and the corresponding book covers more topics, which are not covered by this book. + + +[Book of Proof](https://richardhammack.github.io/BookOfProof/) can be used as a quick introduction to writing proofs. + +Extra resources: +- [2015/2019 Solutions](https://github.com/spamegg1/Math-for-CS-solutions) +- [2010 Solutions](https://github.com/frevib/mit-cs-math-6042-fall-2010-problems) +- [2005 Solutions](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-fall-2005/assignments/) \ No newline at end of file diff --git a/docs/computer-science/math/index.md b/docs/computer-science/math/index.md new file mode 100644 index 0000000..1c1c4dc --- /dev/null +++ b/docs/computer-science/math/index.md @@ -0,0 +1,10 @@ +--- +sidebar_position: 5 +--- + +# Math +*Timeline: 238 hours - 1.5 years* + +import DocCardList from '@theme/DocCardList'; + + diff --git a/docs/computer-science/coursepages/intro-programming.md b/docs/computer-science/prerequisites/elementary-programming.md similarity index 94% rename from docs/computer-science/coursepages/intro-programming.md rename to docs/computer-science/prerequisites/elementary-programming.md index 6016dc9..7c7597c 100644 --- a/docs/computer-science/coursepages/intro-programming.md +++ b/docs/computer-science/prerequisites/elementary-programming.md @@ -1,6 +1,11 @@ -# Introduction to Programming +--- +sidebar_position: 1 +--- -If you find the [Intro CS course](../intro-cs) difficult to follow, start here. These courses are self-paced, allowing you to adjust the number of hours you spend per week to meet your needs. +# Elementary Programming +*Timeline: 75 - 100 hours* + +If you find the [Intro CS course](/computer-science/intro-cs/index.md) difficult to follow, or if you want to break up your studies of [Pre-college Math](/precollege-math/index.md), start here. These courses are self-paced, allowing you to adjust the number of hours you spend per week to meet your needs. You need to do **only ONE** of the following courses. diff --git a/docs/computer-science/prerequisites/index.md b/docs/computer-science/prerequisites/index.md new file mode 100644 index 0000000..6f3315a --- /dev/null +++ b/docs/computer-science/prerequisites/index.md @@ -0,0 +1,27 @@ +--- +sidebar_position: 2 +--- + +# Prerequisites & Motivation +*Timeline: 0 - 2 years* + +There are a few prerequisites to be aware of before starting your Computer Science studies at The Borr Project. + +First of all, if you do not have a strong mathematical foundation from Arithmetic to Precalculus, you will need to go through the Pre-College Math curriculum before starting the Computer Science curriculum at The Borr Project. + +Don't feel like you need to start completely from scratch as we provide diagnostic tests to determine what you need to study to be sufficiently prepared for CS. + +- [Pre-College Math](/precollege-math/index.md), 0 - 2 years + +Secondly, there is the mental aspect of self-study. Are you prepared to commit to a routine of studying Computer Science regularly for a few years? This is a challenge for everyone, but rest assured we have resources designed to help. Be sure to join our [Discord](https://discord.gg/uR2QS36pdH) server for cohort meetings, progress sharing, tutoring, and an overall passionate community to hang out & study with. Check out [Getting Help](/getting-help.md) before asking questions. Another good read is [How to Ask Technical Questions](https://www.theodinproject.com/guides/community/how_to_ask) by The Odin Project; these tips can help you anywhere. + +Here are a few courses that some may find helpful to get the right mindset necessary for self study. They are both optional, but past students have mentioned that they have been helpful. + +- [Learning How to Learn](https://www.coursera.org/learn/learning-how-to-learn), 14 hrs +- [Mindshift](https://www.coursera.org/learn/mindshift), 9 hrs + +Finally, if you feel like the prerequisites are too daunting, feel free to break up your math studies with some basic programming. The following course is completely optional, but it can break up the monotony of exclusively studying high school math. + +- [Elementary Programming](elementary-programming/), 75 - 100 hrs + +Once you're ready, feel free to start the [Intro Computer Science](../intro-cs/index.md) track to get an idea of what CS is all about. Afterwards, complete the [Program Design](../program-design/index.md) and [Math](../math/index.md) track in any order. Once both of those are done, you can do any of the other tracks any time. \ No newline at end of file diff --git a/docs/computer-science/program-design/class-based/index.md b/docs/computer-science/program-design/class-based/index.md new file mode 100644 index 0000000..ebc4cb7 --- /dev/null +++ b/docs/computer-science/program-design/class-based/index.md @@ -0,0 +1,84 @@ +--- +sidebar_position: 2 +--- + +# Class-Based Program Design +*Timeline: 104 - 130 hours* + +This course studies the class-based program design and the design of abstractions that support the design of reusable software and libraries. It covers the principles of object oriented program design, the basic rules of program evaluation, and examines the relationship between algorithms and data structures, as well as basic techniques for analyzing algorithm complexity. The recommended background is [Systematic Program Design](../spd). +- https://course.ccs.neu.edu/cs2510sp22/index.html + +Keep in mind that the written notes are the primary source of learning in this class. Any videos should be considered supplementary. *Credit: @pulkitkrishna, Discord* + +Starting from Assignment 3, the homework scales massively. It is believed to be a group project on campus. Self taught students can choose just one of the two problems given. *Credit: @leafeningagent, Discord* + +Note that the video that goes with lecture 30 is inaccessable, watch [this video](https://www.youtube.com/watch?v=6WZo7sFFFlQ&list=PL_N7YxtCMPyea2YC3e-1s7SR_S3oWGjdb) instead. *Credit: @nadi726, Discord* + +# Course Syllabus +To make it easier on students, a syllabus was created to give a general sequence that the lectures & assignments should be taken. +*Credit: @nadi726, Discord* + +| Week | Topic | +| ------- | ------------------------------------------------------------------------------------------------------------------------- | +| Week 1 | [Lecture 1: Data Definitions in Java](https://course.ccs.neu.edu/cs2510sp22/lecture1.html) | +| | [Lecture 2: Data Definitions: Unions](https://course.ccs.neu.edu/cs2510sp22/lecture2.html) | +| Week 2 | [Lecture 3: Methods for Simple Classes](https://course.ccs.neu.edu/cs2510sp22/lecture3.html) | +| | [Lab 1](https://course.ccs.neu.edu/cs2510sp22/lab1.html) | +| | [Lecture 4: Methods for Unions](https://course.ccs.neu.edu/cs2510sp22/lecture4.html) | +| | [Lecture 5: Methods for Self-referential Lists](https://course.ccs.neu.edu/cs2510sp22/lecture5.html) | +| | [Assignment 1](https://course.ccs.neu.edu/cs2510sp22/assignment1.html) | +| Week 3 | [Lecture 6: Accumulator Methods](https://course.ccs.neu.edu/cs2510sp22/lecture6.html) | +| | [Lab 2](https://course.ccs.neu.edu/cs2510sp22/lab2.html) | +| | [Lecture 7: Accumulator Methods, Continued](https://course.ccs.neu.edu/cs2510sp22/lecture7.html) | +| | [Assignment 2](https://course.ccs.neu.edu/cs2510sp22/assignment2.html) | +| | [Lecture 8: Practice Design](https://course.ccs.neu.edu/cs2510sp22/lecture8.html) | +| Week 4 | [Lecture 9: Abstract Classes and Inheritance](https://course.ccs.neu.edu/cs2510sp22/lecture9.html) | +| | [Lab 3](https://course.ccs.neu.edu/cs2510sp22/lab3.html) | +| | [Lecture 10: Customizing Constructors](https://course.ccs.neu.edu/cs2510sp22/lecture10.html) | +| | [Assignment 3](https://course.ccs.neu.edu/cs2510sp22/assignment3.html) | +| | [Lecture 11: Defining Sameness for Complex Data, Part 1](https://course.ccs.neu.edu/cs2510sp22/lecture11.html) | +| Week 5 | [Lecture 12: Defining Sameness for Complex Data, Part 2](https://course.ccs.neu.edu/cs2510sp22/lecture12.html) | +| | [Lab 4](https://course.ccs.neu.edu/cs2510sp22/lab4.html) | +| | [Lecture 13: Abstracting Over Behavior](https://course.ccs.neu.edu/cs2510sp22/lecture13.html) | +| | [Assignment 4](https://course.ccs.neu.edu/cs2510sp22/assignment4.html) | +| | [Lecture 14: Abstractions Over More Than One Argument](https://course.ccs.neu.edu/cs2510sp22/lecture14.html) | +| Week 6 | [Lab 5](https://course.ccs.neu.edu/cs2510sp22/lab5.html) | +| | Exam 1 | +| | [Lecture 15: Abstracting Over Types](https://course.ccs.neu.edu/cs2510sp22/lecture15.html) | +| | [Assignment 5](https://course.ccs.neu.edu/cs2510sp22/assignment5.html) | +| Week 7 | [Lecture 16: Visitors](https://course.ccs.neu.edu/cs2510sp22/lecture16.html) | +| | [Lab 6](https://course.ccs.neu.edu/cs2510sp22/lab6.html) | +| | [Lecture 17: Mutation](https://course.ccs.neu.edu/cs2510sp22/lecture17.html) | +| | [Assignment 6](https://course.ccs.neu.edu/cs2510sp22/assignment6.html) | +| | [Lecture 18: Mutation Inside Structures](https://course.ccs.neu.edu/cs2510sp22/lecture18.html) | +| Week 8 | [Lecture 19: Mutation, Aliasing, and Testing](https://course.ccs.neu.edu/cs2510sp22/lecture19.html) | +| | [Lab 7](https://course.ccs.neu.edu/cs2510sp22/lab7.html) | +| | [Lecture 20: Mutable Data Structures](https://course.ccs.neu.edu/cs2510sp22/lecture20.html) | +| | [Assignment 7](https://course.ccs.neu.edu/cs2510sp22/assignment7.html) | +| | [Lecture 21: ArrayLists](https://course.ccs.neu.edu/cs2510sp22/lecture21.html) | +| Week 9 | [Lecture 22: ArrayLists](https://course.ccs.neu.edu/cs2510sp22/lecture22.html) | +| | [Lab 8](https://course.ccs.neu.edu/cs2510sp22/lab8.html) | +| | [Lecture 23: For-each Loops and Counted-for Loops](https://course.ccs.neu.edu/cs2510sp22/lecture23.html) | +| | [Assignment 8](https://course.ccs.neu.edu/cs2510sp22/assignment8.html) | +| | [Lecture 24: While Loops](https://course.ccs.neu.edu/cs2510sp22/lecture24.html) | +| Week 10 | [Lecture 25: Iterator and Iterable](https://course.ccs.neu.edu/cs2510sp22/lecture25.html) | +| | [Lab 9](https://course.ccs.neu.edu/cs2510sp22/lab9.html) | +| | [Lecture 26: Hashing and Equality](https://course.ccs.neu.edu/cs2510sp22/lecture26.html) | +| | [Assignment 9 Part 1](https://course.ccs.neu.edu/cs2510sp22/assignment9.html) | +| | [Lecture 27: Introduction to Big-O Analysis](https://course.ccs.neu.edu/cs2510sp22/lecture27.html) | +| Week 11 | [Lecture 30: Breadth-first Search and Depth-first Search](https://course.ccs.neu.edu/cs2510sp22/lecture30.html) | +| | [Lab 10](https://course.ccs.neu.edu/cs2510sp22/lab10.html) | +| | Exam 2 | +| | [Lecture 28: Quicksort and Mergesort](https://course.ccs.neu.edu/cs2510sp22/lecture28.html) | +| Week 12 | [Lecture 29: Priority Queues and Heapsort](https://course.ccs.neu.edu/cs2510sp22/lecture29.html) | +| | [Assignment 9 Part 2](https://course.ccs.neu.edu/cs2510sp22/assignment9.html) | +| | [Lab 11](https://course.ccs.neu.edu/cs2510sp22/lab11.html) | +| | [Lecture 31: Dijkstra’s Algorithm for Single-source Shortest Paths](https://course.ccs.neu.edu/cs2510sp22/lecture31.html) | +| | [Lecture 32: Minimum Spanning Trees](https://course.ccs.neu.edu/cs2510sp22/lecture32.html) | +| Week 13 | [Lab 12](https://course.ccs.neu.edu/cs2510sp22/lab12.html) | +| | [Assignment 10 Part 1](https://course.ccs.neu.edu/cs2510sp22/assignment10.html) | +| | [Lecture 34: Implementing Objects](https://course.ccs.neu.edu/cs2510sp22/lecture34.html) | +| | [Lecture 35: Dynamic Programming](https://course.ccs.neu.edu/cs2510sp22/lecture35.html) | +| Week 14 | Lecture 35: Intro to OOD part 1 | +| | [Assignment 10 Part 2](https://course.ccs.neu.edu/cs2510sp22/assignment10.html) | +| | Lecture 35: Intro to OOD part 2 | \ No newline at end of file diff --git a/docs/computer-science/program-design/index.md b/docs/computer-science/program-design/index.md new file mode 100644 index 0000000..21261a9 --- /dev/null +++ b/docs/computer-science/program-design/index.md @@ -0,0 +1,10 @@ +--- +sidebar_position: 4 +--- + +# Program Design +*Timeline: 325 - 500 hours* + +import DocCardList from '@theme/DocCardList'; + + diff --git a/docs/computer-science/program-design/object-oriented/index.md b/docs/computer-science/program-design/object-oriented/index.md new file mode 100644 index 0000000..456a8f0 --- /dev/null +++ b/docs/computer-science/program-design/object-oriented/index.md @@ -0,0 +1,12 @@ +--- +sidebar_position: 4 +--- + +# Object-Oriented Design +*Timeline: 65 - 130 hours* + +CS 3500 teaches a rigorous approach to object-oriented programming and design, with an emphasis on abstraction, modularity, and code reuse as applied to the building and understanding of large-scale systems. We will explore the basic mechanisms and concepts of object-oriented programming: object, class, message, method, interface, encapsulation, polymorphism, and inheritance. Students will gain hands-on experience with tools and techniques that facilitate the creation and maintenance of applications using the Java programming language. + +This course assumes familiarity with programming in the style of *[Systematic Program Design](../spd)*, and basic knowledge of the Java programming language as introduced in *[Class-Based Program Design](../class-based/)*. + +- https://course.ccs.neu.edu/cs3500f19/ diff --git a/docs/computer-science/program-design/programming-languages/index.md b/docs/computer-science/program-design/programming-languages/index.md new file mode 100644 index 0000000..1c74a44 --- /dev/null +++ b/docs/computer-science/program-design/programming-languages/index.md @@ -0,0 +1,22 @@ +--- +sidebar_position: 3 +--- + +# Programming Languages +*Timeline: 44 - 88 hours* + +The following is quoted from the course website: + +This course is an introduction to the basic concepts of programming languages, with a strong emphasis on functional programming. The course uses the languages ML, Racket, and Ruby as vehicles for teaching the concepts, but the real intent is to teach enough about how any language “fits together” to make you more effective programming in any language -- and in learning new ones. + +This course is neither particularly theoretical nor just about programming specifics -- it will give you a framework for understanding how to use language constructs effectively and how to design correct and elegant programs. By using different languages, you will learn to think more deeply than in terms of the particular syntax of one language. The emphasis on functional programming is essential for learning how to write robust, reusable, composable, and elegant programs. Indeed, many of the most important ideas in modern languages have their roots in functional programming. Get ready to learn a fresh and beautiful way to look at software and how to have fun building it. + +The course assumes some prior experience with programming, as described in more detail in the first module. See [Recommended Background](https://www.coursera.org/lecture/programming-languages/recommended-background-k1yuh) for more details. *This is covered by the previous courses in [Program Design](../)*. + +The course is divided into three Coursera courses: Part A, Part B, and Part C. As explained in more detail in the first module of Part A, the overall course is a substantial amount of challenging material, so the three-part format provides two intermediate milestones and opportunities for a pause before continuing. The three parts are designed to be completed in order and set up to motivate you to continue through to the end of Part C. The three parts are not quite equal in length: Part A is almost as substantial as Part B and Part C combined. + + + +- [Programming Languages: Part A](https://www.coursera.org/learn/programming-languages), 20-40 hrs +- [Programming Languages: Part B](https://www.coursera.org/learn/programming-languages-part-b), 12-24 hrs +- [Programming Languages: Part C](https://www.coursera.org/learn/programming-languages-part-c), 12-24 hrs diff --git a/docs/computer-science/program-design/software-architecture/index.md b/docs/computer-science/program-design/software-architecture/index.md new file mode 100644 index 0000000..88077f8 --- /dev/null +++ b/docs/computer-science/program-design/software-architecture/index.md @@ -0,0 +1,14 @@ +--- +sidebar_position: 5 +--- + +# Software Architecture +*Timeline: 8 - 20 hours* + +The following is quoted from the course website: + +The way that software components — subroutines, classes, functions, etc. — are arranged, and the interactions between them, is called architecture. In this course you will study the ways these architectures are represented, both in UML and other visual tools. We will introduce the most common architectures, their qualities, and tradeoffs. We will talk about how architectures are evaluated, what makes a good architecture, and an architecture can be improved. We'll also talk about how the architecture touches on the process of software development. + +In the Capstone Project you will document a Java-based Android application with UML diagrams and analyze evaluate the application’s architecture using the Architecture Tradeoff Analysis Method (ATAM). + +- https://www.coursera.org/learn/software-architecture \ No newline at end of file diff --git a/docs/computer-science/coursepages/automatic-parentheses.png b/docs/computer-science/program-design/spd/automatic-parentheses.png similarity index 100% rename from docs/computer-science/coursepages/automatic-parentheses.png rename to docs/computer-science/program-design/spd/automatic-parentheses.png diff --git a/docs/computer-science/coursepages/change-dr-racket-notation.png b/docs/computer-science/program-design/spd/change-dr-racket-notation.png similarity index 100% rename from docs/computer-science/coursepages/change-dr-racket-notation.png rename to docs/computer-science/program-design/spd/change-dr-racket-notation.png diff --git a/docs/computer-science/coursepages/spd.md b/docs/computer-science/program-design/spd/index.md similarity index 99% rename from docs/computer-science/coursepages/spd.md rename to docs/computer-science/program-design/spd/index.md index ca93b90..403c27f 100644 --- a/docs/computer-science/coursepages/spd.md +++ b/docs/computer-science/program-design/spd/index.md @@ -1,4 +1,9 @@ +--- +sidebar_position: 1 +--- + # Systematic Program Design +*Timeline: 104 - 130 hours* This course has been developed by UBC and is available from Edx. We recommend you to do it from the archived version on Edx. diff --git a/docs/computer-science/coursepages/space-invaders-instructions.png b/docs/computer-science/program-design/spd/space-invaders-instructions.png similarity index 100% rename from docs/computer-science/coursepages/space-invaders-instructions.png rename to docs/computer-science/program-design/spd/space-invaders-instructions.png diff --git a/docs/computer-science/coursepages/index.md b/docs/computer-science/systems/index.md similarity index 55% rename from docs/computer-science/coursepages/index.md rename to docs/computer-science/systems/index.md index 7ad2d18..742c2e2 100644 --- a/docs/computer-science/coursepages/index.md +++ b/docs/computer-science/systems/index.md @@ -1,8 +1,9 @@ --- -sidebar_position: 2 +sidebar_position: 6 --- -# Course Pages +# Systems +*Timeline: 250 - 506 hours* import DocCardList from '@theme/DocCardList'; diff --git a/docs/computer-science/systems/nand2tetris/index.md b/docs/computer-science/systems/nand2tetris/index.md new file mode 100644 index 0000000..b413ef9 --- /dev/null +++ b/docs/computer-science/systems/nand2tetris/index.md @@ -0,0 +1,16 @@ +--- +sidebar_position: 2 +--- + +# Nand2Tetris +*Timeline: 114 - 186 hours* + +- [Nand2Tetris Part 1: Hardware](https://www.coursera.org/learn/build-a-computer), 42-78 hrs + +In this project-centered course you will build a modern computer system, from the ground up. We’ll divide this fascinating journey into six hands-on projects that will take you from constructing elementary logic gates all the way through creating a fully functioning general purpose computer. In the process, you will learn - in the most direct and constructive way - how computers work, and how they are designed. + +- [Nand2Tetris Part 2: Software](https://www.coursera.org/learn/nand2tetris2), 72-108 hrs + +In this project-centered course you will build a modern software hierarchy, designed to enable the translation and execution of object-based, high-level languages on a bare-bone computer hardware platform. In particular, you will implement a virtual machine and a compiler for a simple, Java-like programming language, and you will develop a basic operating system that closes gaps between the high-level language and the underlying hardware platform. In the process, you will gain a deep, hands-on understanding of numerous topics in applied computer science, e.g. stack processing, parsing, code generation, and classical algorithms and data structures for memory management, vector graphics, input-output handling, and various other topics that lie at the very core of every modern computer system. + +- [Nand2Tetris Course Website](https://www.nand2tetris.org/) \ No newline at end of file diff --git a/docs/computer-science/systems/networking/index.md b/docs/computer-science/systems/networking/index.md new file mode 100644 index 0000000..7cec0e1 --- /dev/null +++ b/docs/computer-science/systems/networking/index.md @@ -0,0 +1,12 @@ +--- +sidebar_position: 4 +--- + +# Computer Networking +*Timeline: 32 - 96 hours* +- [Computer Networking: A Top Down Approach](https://gaia.cs.umass.edu/kurose_ross/online_lectures.htm) +- [Wireshark Labs](http://gaia.cs.umass.edu/kurose_ross/wireshark.php) + +Extra Material: +- [Professor Messer: Network+ Course](https://youtu.be/playlist?list=PLG49S3nxzAnl_tQe3kvnmeMid0mjF8Le8) +- [Jeremy's IT Lab: CCNA Course](https://youtu.be/playlist?list=PLxbwE86jKRgMpuZuLBivzlM8s2Dk5lXBQ) diff --git a/docs/computer-science/coursepages/ostep/Project-1B-initial-xv6.md b/docs/computer-science/systems/ostep/Project-1B-initial-xv6.md similarity index 100% rename from docs/computer-science/coursepages/ostep/Project-1B-initial-xv6.md rename to docs/computer-science/systems/ostep/Project-1B-initial-xv6.md diff --git a/docs/computer-science/coursepages/ostep/Project-2A-processes-shell.md b/docs/computer-science/systems/ostep/Project-2A-processes-shell.md similarity index 100% rename from docs/computer-science/coursepages/ostep/Project-2A-processes-shell.md rename to docs/computer-science/systems/ostep/Project-2A-processes-shell.md diff --git a/docs/computer-science/coursepages/ostep/Scheduling-xv6-lottery.md b/docs/computer-science/systems/ostep/Scheduling-xv6-lottery.md similarity index 100% rename from docs/computer-science/coursepages/ostep/Scheduling-xv6-lottery.md rename to docs/computer-science/systems/ostep/Scheduling-xv6-lottery.md diff --git a/docs/computer-science/coursepages/ostep/index.md b/docs/computer-science/systems/ostep/index.md similarity index 99% rename from docs/computer-science/coursepages/ostep/index.md rename to docs/computer-science/systems/ostep/index.md index c0fb586..6a70228 100644 --- a/docs/computer-science/coursepages/ostep/index.md +++ b/docs/computer-science/systems/ostep/index.md @@ -1,5 +1,9 @@ -# Operating Systems: Three Easy Pieces +--- +sidebar_position: 3 +--- +# Operating Systems +*Timeline: 80 - 200+ hours*, Credit goes to [palladian](https://github.com/palladian1) ## Introduction diff --git a/docs/computer-science/coursepages/ostep/vm-xv6-intro.md b/docs/computer-science/systems/ostep/vm-xv6-intro.md similarity index 100% rename from docs/computer-science/coursepages/ostep/vm-xv6-intro.md rename to docs/computer-science/systems/ostep/vm-xv6-intro.md diff --git a/docs/computer-science/theory/index.md b/docs/computer-science/theory/index.md new file mode 100644 index 0000000..898286e --- /dev/null +++ b/docs/computer-science/theory/index.md @@ -0,0 +1,24 @@ +--- +sidebar_position: 7 +--- + +# Theory +*Timeline: 64 - 128 hours* + +Covers everything typically found on the theoretical side of a Data Structures & Algorithms course. Introduction to DSA was covered throughout [Program Design](../program-design/). + +The primary topics in this part of the specialization are: asymptotic ("Big-oh") notation, sorting and searching, divide and conquer (master method, integer and matrix multiplication, closest pair), and randomized algorithms (QuickSort, contraction algorithm for min cuts). + +- [Algorithms 1](https://www.coursera.org/learn/algorithms-divide-conquer), 16-32 hrs + +The primary topics in this part of the specialization are: data structures (heaps, balanced search trees, hash tables, bloom filters), graph primitives (applications of breadth-first and depth-first search, connectivity, shortest paths), and their applications (ranging from deduplication to social network analysis). + +- [Algorithms 2](https://www.coursera.org/learn/algorithms-graphs-data-structures), 16-32 hrs + +The primary topics in this part of the specialization are: greedy algorithms (scheduling, minimum spanning trees, clustering, Huffman codes) and dynamic programming (knapsack, sequence alignment, optimal search trees). + +- [Algorithms 3](https://www.coursera.org/learn/algorithms-greedy), 16-32 hrs + +The primary topics in this part of the specialization are: shortest paths (Bellman-Ford, Floyd-Warshall, Johnson), NP-completeness and what it means for the algorithm designer, and strategies for coping with computationally intractable problems (analysis of heuristics, local search). + +- [Algorithms 4](https://www.coursera.org/learn/algorithms-npcomplete), 16-32 hrs \ No newline at end of file