To learn programming and computer science, I looked through online courses from universities (MIT, Stanford, UC Berkeley, Carnegie Mellon, Harvard) and Massively Open Online Course (MOOC) offerings (Coursera, Udacity, Udemy). Initially I focused on going through MOOCs, mainly specializations in Coursera and some courses/projects through Udacity. But the more courses I found online through top level universities, the more surprised I was with just how much was available. Stanford offers their entire introductory Comp Sci track on its own site, Berkeley offers lectures from multiple courses on YouTube, and MIT offers multiple complete courses (some with video lectures) on its OpenCourseWare site. While I would lose the ability to get feedback from instructors through forums available on sites such as Coursera, I like the idea of taking courses directly from universities as they are delivered to students. The other downside in the non-Coursera approach is I lose the option to get a certificate proving that I actually completed the course. To overcome this, I will need to track my progress through this site by posting my graded work.
With that, I began trying to develop my own curriculum based on courses I could find online. Online Learning: An Intensive Bachelor’s Level Computer Science Program Curriculum, Part II – aGuipeWare gave me a great initial list of course topics, but I also found curriculums from top universities to make sure I was covering all my bases. Initially I started MIT’s Introduction to Computer Science, which is based on Python and was quite enjoyable. The lectures were fairly easy to follow using my iPad or on the computer, and I was able to do the homework problems and check my work after. I then signed up for the same course on edx in order to earn a certificate of completion.
One third of the way into the MIT course, I found Stanford’s 106A – Programming Methodology, 106B – Programming Abstractions, and 107 Programming Paradigms. All three Stanford courses take 1 year on campus and introduce Java, C++, and C. This means I would have an introduction to programming languages necessary to create Android applications as well as being able to do projects with arduino. More importantly, the future courses I would like to take use Java or C, so taking the Stanford courses would mean I would be prepared to take them.
Additionally, aside from the typical undergrad math and liberal arts courses I have already taken, all computer science curriculums involve at least one “Mathematics for Computer Science” type course. Initially I found MIT’s course, but upon further research became interested in UC Berkeley’s CS70: Discrete Mathematics and Probability Theory. It seems to cover at least the same amount of information, but also includes solved problem sets and discussions (solutions are not included for MIT homeworks).
With that, I came up with the following initial set of courses. The naming conventions are as follows – numbers specify order, letters specify track. Tracks A and B will need to be completed in order, but track A occurs independently of track B. Stanford 106A must be completed first as it gives an introduction to Java and works as the introductory course required for Berkeley CS70. From there I will finish the Stanford Computer Science track. After finishing the first Stanford Course, I will be ready for the UC Berkeley math course, Princeton’s Algorithm courses, and MIT’s Advanced Data Structures. From there, once completing the below course list I will move on to higher level programming (operating systems, architecture, software engineering) and elective type courses (web development, cryptography, and machine learning).
|1AB||Stanford||SEE||CS106A - Programming Methodology
|2A||Stanford||SEE||CS106B - Programming Abstractions
|3A||Stanford||SEE||CS107 - Programming Paradigms
|2B||Berkeley||Berkeley||CS70 Discrete Math
|3B||Princeton||Coursera||Algorithms, Part I
|4B||Princeton||Coursera||Algorithms, Part II
|4A||MIT||MIT OCW||6-851 Advanced Data Structures
|5B||Georgia Tech||Udacity||Software Development Process
Below is a list of the descriptions of each of the courses and links to where they can be found.
Course: CS106A – Programming Methodology
Description: This course is the largest of the introductory programming courses and is one of the largest courses at Stanford. Topics focus on the introduction to the engineering of computer applications emphasizing modern software engineering principles: object-oriented design, decomposition, encapsulation, abstraction, and testing.
Programming Methodology teaches the widely-used Java programming language along with good software engineering principles. Emphasis is on good programming style and the built-in facilities of the Java language. The course is explicitly designed to appeal to humanists and social scientists as well as hard-core techies. In fact, most Programming Methodology graduates end up majoring outside of the School of Engineering.
Course: CS106B – Programming Abstractions
Description: This course is the natural successor to Programming Methodology and covers such advanced programming topics as recursion, algorithmic analysis, and data abstraction using the C++ programming language, which is similar to both C and Java. If you’ve taken the Computer Science AP exam and done well (scored 4 or 5) or earned a good grade in a college course, Programming Abstractions may be an appropriate course for you to start with, but often Programming Abstractions (Accelerated) is a better choice. Programming Abstractions assumes that you already have familiarity with good programming style and software engineering issues (at the level of Programming Methodology), and that you can use this understanding as a foundation on which to tackle new topics in programming and data abstraction.
Topics: Abstraction and its relation to programming. Software engineering principles of data abstraction and modularity. Object-oriented programming, fundamental data structures (such as stacks, queues, sets) and data-directed design. Recursion and recursive data structures (linked lists, trees, graphs). Introduction to time and space complexity analysis. Uses the programming language C++ covering its basic facilities.
Course: CS107 – Programming Paradigms
Description: CS107 is the third course in Stanford’s introductory programming sequence. Our CS106 courses provide students with a solid foundation in programming methodology and abstractions and CS107 follows on to build up their programming maturity and expand breadth and depth of experience. The course will work from the C programming language down to the microprocessor to de-mystify the machine. With a complete understanding of how computer systems execute programs and manipulate data, you will become a more effective programmer, especially in dealing with issues of debugging, performance, portability, and robustness. Topics covered include: the C programming language, data representation, machine-level code, computer arithmetic, elements of code compilation, optimization of memory and runtime performance, and memory organization and management.
Course: CS70 Discrete Math
Description: Discrete mathematics and probability theory provide the foundation for many algorithms, concepts, and techniques in the field of Electrical Engineering and Computer Sciences. For example, computer hardware is based on Boolean logic. Induction is closely tied to recursion and is widely used, along with other proof techniques, in theoretical arguments that are critical to understanding the foundations of many things, ranging from algorithms to control, learning, signal processing, communication, and artificial intelligence. Similarly for modular arithmetic and probability theory. CS70 will introduce you to these and other mathematical concepts. By the end of the semester, you should have a firm grasp of the theoretical basis of these concepts and their applications to general mathematical problems. In addition, you will learn how they apply to specific, important problems in the field of EECS.
Course: Algorithms, Part I
Description: An introduction to fundamental data types, algorithms, and data structures, with emphasis on applications and scientific performance analysis of Java implementations. Specific topics covered include: union-find algorithms; basic iterable data types (stack, queues, and bags); sorting algorithms (quicksort, mergesort, heapsort) and applications; priority queues; binary search trees; red-black trees; hash tables; and symbol-table applications.
Course: Algorithms, Part II
Description: Part II covers graph-processing algorithms, including minimum spanning tree and shortest paths algorithms, and string processing algorithms, including string sorts, tries, substring search, regular expressions, and data compression, and concludes with an overview placing the contents of the course in a larger context.
Course: 6-851 Advanced Data Structures
Description: Data structures play a central role in modern computer science. You interact with data structures even more often than with algorithms (think Google, your mail server, and even your network routers). In addition, data structures are essential building blocks in obtaining efficient algorithms. This course covers major results and current directions of research in data structure.
Course: Software Development Process
Description: In SDP, you will learn how to select and implement the ideal software process for your development project. Through Professor Orso’s engaging examples and interviews with industry insiders, you will learn both conceptual and practical aspects of software engineering. The course covers requirements engineering, architecture and design, testing and maintenance, and software quality in general. The goal of this class is to equip you with the skills necessary to define requirements, set up an integrated development environment (IDE), learn Git (and Github!) and use Unified Modeling Language (UML) to design and build an Android application. We will also examine several testing practices and refactoring techniques that are helpful before the launch of your software project.
Finally, here are some links that helped me work to develop the above: