NikCreate

As someone who got into programming through a non-traditional method I’ve always wondered what I would have learned with a traditional computer science degree that I didn’t get exposed to on my path. If I got confused on something or stuck on a bug, I’d assume that it was something I would have learned in a class and regretted not getting a CS degree whenever something wasn’t going as well as I wanted. Some of this regret probably wasn’t justified as it seemed unlikely I’d learn much about AWS or Kubernetes through a college degree. Still, I’d expected to have learned a lot more about the lower level workings of computers and programming languages and be better at solving the algorithm problems given when interviewing. Probably the biggest signal that I was missing something came when going through Kaggle competitions and trying to solve problems with machine learning and realizing that outside of how to call pre built functions, and realizing that there was a lot of underlying math and concepts that I didn’t understand and only knew how to call. After this, I decided my next side project would be to attempt to figure out to my best ability what knowledge I was missing that I would have gained on the traditional path.

Enter MIT OpenCourseWare. I knew of this website for a while and it seemed like a good tool for answering my questions. MIT makes a lot of their courses available to the public and I’d been meaning to go through their AI and algorithm focused courses even before starting this project. I found the degree requirements for a CS degree, took all of the degree requirements related to computer science and engineering as well as their prerequisites and then checked if they were available on OpenCourseWare. With the exception of a newer class, Fundamentals of Programming all were available and I had a list of twelve courses I could go through which seemed like enough to stop the voice in my head from blaming my degree every time I got confused on something in my future projects.

That list of courses is:

• Intro to Computer Science with Python
• Calculus
• Mathematics for Computer Science
• Physics I
• Introduction to Electrical Engineering and Computer Science
• Intro to Algorithms
• Design and Analysis of Algorithms
• Computation Structures
• Physics II
• Software Construction
• Computer Systems Engineering
• Artificial Intelligence

As a theater major, my math background is more or less the bare minimum I could get away with, but from watching parts of Intro to Algorithms in the past, I knew I was unfamiliar with a lot of notation and confusion on the underlying math related to Artificial Intelligence was one of the main reasons I started this project. I was also curious how the physics courses would play out and how they would be related. I was most excited for the algorithms, programming and computer focused courses, but wanted to make sure to do this in order and not miss anything.

With six months I knew I wouldn’t get the same amount of practice as someone going to the actual course would get and that I was doing this project to answer my own question. Obviously, someone who went through the courses in person would be able to perform much better when tested on material and my focus is mostly to see how everything relates back to me as a programmer. Additionally, if I’d actually gone to school for CS, there would likely have been a lot of networking opportunities, hackathons and in person events that would be as or more meaningful than classes themselves. All of that is to say that I don’t view this as a complete computer science degree experience. It’s primary purpose is to identify things I don’t know that I don’t know due to not having gone that route. Also, realizing many people I’ll work with have gone the traditional route, it would be interesting to have some basic idea of what other’s paths were like. While there are a lot of events and networking activities that I may have gotten access to with such a degree, with meetups and conventions, I don’t think my process has had a lack of those as they were my primary means for getting into the field.

Before getting into the courses, here’s a bit about where I’m starting from. When I initially got curious about programming, I started learning through tutorial sites like Codecademy and Team Treehouse, before discovering Coursera and EDX and going through courses such as University of Michigan’s Python for Everybody, which was a useful change since I’d mostly been using shells provided by the tutorial apps before. After this, I started going to meetup groups as well as my first PyCon. Going into my senior year of college, I joined the Chicago Python User Group’s mentorship programming attempting to build a simple card game in Python and started to get more comfortable building programs (at that point only interacting through CLI). After graduating, I attended a coding bootcamp called Hack Reactor which focused on building full stack web applications using JavaScript and got me comfortable working with a variety of frameworks. From there, I’ve spent the last few years working with some app development and lately a lot of focus on AWS, continuing learning about topics I’m curious about in my free time.

So, that’s the list of courses I had to go through as well as where I was starting from. What was covered by both my path and the courses and what was covered in the courses that I hadn’t been exposed to before. I’ll go through a summary of each of the twelve courses here and have links to my full notes on each course on this page. (The goal of the notes was to be able to go back to my notes to find anything covered in the course, so they’re a bit long.) Overall, there was a lot covered here that I hadn’t learned about previously, though it was mostly about math, physics and how computers worked rather than any neat programming tricks that I hadn’t learned about.

Intro to Computer Science with Python

This first course covered the basics of the Python programming language and is the only course to not contain new information for me. It explains Python’s data types, how to write functions and organize them into modules, branching, testing, classes and inheritance. Topics such as mutability and initial “gotchas” that come with aliasing are covered, as well as using recursion to solve problems. Testing and debugging are touched on briefly as well as time complexity. The last lecture covers some basic searching and sorting problems. Overall, this course gives a pretty good overview of Python from a high level and introduces a language which is needed for later. I was familiar with most of the information from this course from Codecademy and Python for Everybody and remember learning about aliasing from ChiPy’s mentorship, learning about time complexity and recursion with Hack Reactor. Still, for someone wanting an introduction to programming, this is a pretty good one and covers the basics of Python in 12 lectures.

Calculus

After feeling confident with the first course, I felt a lot more lost going through calculus. This class had 39 math heavy lectures and lots of recitation videos which were helpful for explaining anything confusing from the lectures. While it was easy to get lost in the details, the course is mostly focused on calculating derivatives and integrals. Derivatives are the rate of change at a point of time, such as acceleration being the rate of change for velocity. Various rules for calculating derivatives of multiple functions (such as the product and chain rule) are shown and derivatives are used to solve min-max and related rate problems. Going the other way, the majority of the second half focuses on integration. The integral is the area under a curve and an integral of a function has that function as it’s derivative and is computable up to a constant. Other topics such as power series, polar coordinates and axis of revolutions are covered, as well as various rules and theorems. Overall, the core ideas of calculating derivatives and integrals are used heavily in the two physics courses and some of the future algorithm and CS courses.

Mathematics for Computer Science

Mathematics for Computer Science explains mathematical proofs and uses them to explain optimal strategies for a variety of games and puzzles. This course felt like a natural prerequisite for introduction to algorithms as it focused on similar problems. It introduced algorithms, data structures and mathematical riddles, all explained with mathematical symbols as opposed to code. Some puzzles shown involve cryptography and algorithms for encryption and decryption along with a good explanation of probability. A lot of the course covers graphs and trees and algorithms using those, along with coloring and searching problems and using divide and conquer algorithms. Overall, this is a course that’s pretty varied in topics, many of which are introduced here and talked about further later. Probability appears in a lot of future classes and graphs and trees are the focus of much of the algorithm focused courses.

Physics 1: Classical Mechanics

This is the first physics course covering forces on physical objects and why they move the way they do. This course makes heavy use of taking derivatives and integrals and a lot of it wouldn’t have made sense without Calculus, which was good. The concept of a vector is introduced here which is a unit with magnitude and direction compared to a scalar which only has a magnitude. Newton’s Laws are covered here and a variety of situations involving movements in the physical world, showing how gravity interacts with slopes to affect the movement of objects, how pulleys work and how masses affect each other in outer space. It also looks at what happens when objects collide, work required to move objects and concepts such as potential energy. Overall, this was an interesting course that provided an interesting way of looking at the world and provided an introduction to a large and interesting field that I’ll hopefully learn more about. The connection between calculus and real world problems was also good to see as it felt somewhat nebulous when first going through Calculus.

Intro to Electrical Engineering and Computer Science

This course was meant to be an introduction to MIT’s focus on EECS and how abstraction and modularity are applicable to a variety of topics. Compared to the straight forward focuses of the previous courses, this course covers a brief introduction to Python, analysis of physical systems using equations and block diagrams, an introduction to circuits and electricity, probability and some basic searching algorithms. All of these topics are used to show how simple modular components can be used to build more complex systems and each topic is explored in more detail in another course.

Introduction to Algorithms

This is a course I’d started before and never finished, looking at a variety of graph focused puzzles and coming up with algorithms to solve them. This starts with reintroducing search algorithms such as breadth-first and depth-first search, enhancing them with dynamic programming and showing solutions for shortest path problems with algorithms such as Dijkstra and Bellman-Ford. Some later lectures focus on NP complete problems as well and use cases for algorithms in chip design. This lecture was a good mixture of reviewing searching algorithms I’d seen before as well as going into more advanced algorithms and applications of dynamic programming. Some of the algorithms here will be good to come back to particularly if going back to HackerRank or solving similar puzzles. At this point, this would have been the most directly applicable course.

Design and Analysis of Algorithms

This course is pretty much a sequel to Introduction to Algorithms, which goes further showing techniques for solving NP-complete problems by incorporating randomness and using dynamic programming. This course introduces new data structures such as B-trees and union find and covers considerations for running algorithms across distributed systems and goes into some more detail on cryptography. I believe this was the first course to go into any detail on distributed computing which covered a bit more in future courses and is very relevant to the computing world today and problems shown here, such as leader election, are used in building systems today. This is another course that will be good to go back to for similar reasons to the last. This is the last course with “Algorithms” in its name in my list, but MIT has many follow ups that could be worth checking out.

Software Construction

Surprisingly, this is the first course about writing software since Introduction to Computer Science with Python. Software Construction focuses on programming with Java and goes a bit further than the first course did. This course focuses on writing code that is safe from bugs, easy to understand and ready for change. Besides writing classes and methods and testing them, this course is the first to cover multiple clients to a program at once and techniques for avoiding concurrency bugs. It also covers regular expressions and writing parsers and languages. It also covers a bit of Git and serves as a more complete introduction to programming, covering more specifics around Java’s interfaces and status as a strongly-typed language and how to work in a team and with distributed programs.

Physics 2: Electricity and Magnetism

The second Physics course looks at electricity and magnetism, looking at charges creating fields and using integration to calculate the force propagated through each section. It also looks at methods for storing energy and converting energy between electric and magnetic forms. Like the first physics course, this one is pretty heavy on math and examples, making use of calculus to explain situations in the real world and how various devices can be used to store and amplify electricity. This is another course worth coming back to and actually has quite a bit of a tie back to the inner workings of computers as capacitors and circuits can be used to store and read values represented as voltages, though I’m not sure if and when I’d need to come back to the specific formulas in this course.

Computation Structures

This is a course all about how computers work, looking at multiple levels. It builds on Physics 2 for storing information, representing bits as voltages and transmitting information using voltage differences. The first part of the course looks at using physical components to create logic gates and run functions in circuits. Then, the course looks at the base level components of a computer showing internal implementations of CPU and memory components and trade offs between implementation options. Then the course shows how to compile high level languages such as C to assembly language and how those instructions are run on machines. It also explains how virtual machines can be used by separating contexts. Overall, this course is a great explanation of how computers work on a fundamental level and was something I’d been curious about for awhile even if I might not be writing any languages or operating systems any time soon.

Computer Systems Engineering

This course is a follow up from Computation Structures, starting with talking more about operating systems, client-server communications and buffers and threads, before moving into a variety of topics such as networking, security, fault tolerance and distributed systems. Computer Systems Engineering is an introduction to a lot of specific technologies and strategies with lectures on DNS, TLS, Bitcoin and Tor and a lot of recommended follow up classes. This course had some repeated information from Software Construction and Computation Structures, but mostly consisted of new information and explanations of a lot of technologies I’d heard of but hadn’t gone in depth on. If Computation Structures was everything that went into building a single machine, this is the equivalent for networks and distributed systems.

Artificial Intelligence

Since Kaggle competitions were one of the main places where I realized I was lacking knowledge I might be able to fill in with a traditional CS education, I was particularly interested in seeing how MIT would teach artificial intelligence. Similar to the Algorithms courses, Artificial Intelligence started with examples of games and search problems before getting into learning techniques. The course looks at nearest neighbors, neural networks, genetic algorithms, support vector machines, boosting and more. It broadly covers concepts such as computer vision and how to represent language, along with talking about the history of AI. This course is a broad introduction to AI but does a good job explaining how concepts work compared to my knowledge so far which was mostly prebuilt functions I’d call using Scikit-learn or TensorFlow.

Conclusion

As expected, there was a good mix of repeat and new information, in similar ways to what I may have expected. Calculus and Physics were largely new topics for me, with the latter seeming a lot more interesting now than it did in high school, and Computation Structures and Computer Systems Engineering going into explanations on the inner workings of computers and systems which explain things I work with every day even though I haven’t had to understand their implementations. A lot of courses were a mix of old information that was good to review along with some new pieces, such as the Algorithms courses and Software Construction and the Algorithms courses and Artificial Intelligence taught concepts I was somewhat familiar with in ways I hadn’t seen before. Calculus helped teach me a language that many courses would follow up with and will be useful even if just as a prerequisite to understanding future classes and these courses will help me approach Machine learning again without the same doubt and see operating systems, virtual machines and networks in a different way.

With that, this blog will shift focus to a new project. Now, when I get frustrated, I won’t be able to blame my blocker on some nebulous concept I would have learned in a college course as I’ll know if the issue would have been covered or not (ignoring electives) and where to go back to. While I’m ready to take a break from courses and try approaching something more hands-on, many of these courses gave a suggested follow up path and there are certainly more courses I’d be interested in taking a look at in the near future particularly in the areas of algorithms and machine learning. Overall, I feel that my path was a pretty effective one for learning what I needed to know to be effective as a programmer. While I’ve learned a lot from this process, what I learned wasn’t blocking me any more than I let it, but will still be useful for being able to understand more in the future.

So where to go from here? I haven’t looked at quantum computing yet and quantum physics seems like an interesting topic. Those are definitely on my list of things to learn about. Building distributed applications on blockchains is another thing that’s been on my radar but which I haven’t gotten around to looking into. I’ve also thought about working toward the AWS Machine Learning specialty certification and have been wanting to learn more about natural language processing as machines using human language seems like one of the most interesting applications of Machine Learning. Regardless, it will be good to get more hands on with a project and with this project I’ll be able to proceed with a bit more confidence knowing what was likely down a path I didn’t take.