Calc 1A, 1B, and 1C

It's been a while since my last OSSU post - about 14 months. During that time I started and finished single-variable calculus. Similar to Programming Languages A, B, and C, there are three online courses (if you do the Open Learning Library (OLL) version) but it's really one big course (MIT 's 18.01).

I took AP Calculus AB and BC in high school and got a 5 and 4 (respectively) on the exams. On the off chance he ever sees this: thank you for being an awesome instructor, Mr. Sade. You made calculus genuinely fun and interesting.

All of the material in 18.01 is stuff I had learned before, but much like the OSSU prerequisite math, I had forgotten a lot of it.

That being said, it still took me over a year to finish going through material I had already learned previously. Though it took two years in high school (AP Calc AB and BC are each two semesters), in college this course is only a single semester. On one hand, this is embarrassing. On the other, I am happy to have finished with a lot of confidence in the material, after a few weeks-long breaks, and while I have a full-time job, family, social life, etc.

The course

This course was fine, but could be better. I think my high school calc teacher did a better job, but it's probably not fair to compare my experience then to how I experienced this course now. I wish there were more practice problems readily available, but you can find more elsewhere (e.g. in the OCW version of the course, which I'd probably recommend over the OLL courses at this point).

In particular I would have liked to see more optimization problems. We got a lot of those in my high school calc classes and they were monumentally helpful, even (or especially) when they were hard to make sense of. Sometimes a fellow student would mouth off, which would prompt Mr. Sade to quickly devise a practice problem asking us to figure out how quickly said student would be buried under a conical pile of sand. Good times.

I "passed" the class by taking the practice final and self-assessing my answers against the given solutions. I scored a little over 77% on the first try. I did award myself partial credit where I thought it appropriate, though obviously that's a subjective thing. Unsurprisingly, most of my mistakes had nothing to do with calculus and everything to do with basic algebra.

Study habits

Part of the reason this took so long is: I scaled back how much time I spent on OSSU. Most weeks it was down to the 7.5 hours/week minimum I had set for myself, and sometimes even less than that. This time included watching videos, reading content, and doing practice problems and exams. I'm going to need to increase my study time to make it through the rest of OSSU in any sort of timely matter, especially since the next course is Math for CS (i.e. discrete math), which I do not have much prior experience with.

Another problem was that late 2023/early 2024 was kind of a crazy time in my personal and work life, so I sometimes went weeks without doing any calculus. When you take a break that long, the problem is twofold: you obviously lose any forward progress you would have made during the break, but you also have to spend additional time to get back to where you were when you stopped. There's a similar problem when you stop going to the gym for a while - you can't just show up again after 6 weeks and expect to lift the same weight.

In prior posts I lamented about how I could have avoided similar problems with a little more discipline, by being a little more intentional - but this time around it was simply a matter of priorities (my apologies dear reader, but I won't be going into the details here).

Flash cards

I used flash cards heavily for this course. I made a card in Anki for anything I thought was remotely important and tried to keep up with daily reviews. This served me well when doing practice questions and tests - I typically did not need to look up formulas or other such information. It was also useful to have these things in the front of my brain when watching lectures and digesting new material. It should be said that despite all their advantages, flash cards are not a substitute for practice problems.

Displaying math things in Anki

Anki has support for MathJax built in (MathJax is not quite the same as LaTeX, but it's similar). Most of my calculus Anki cards have MathJax in them. It's come in handy a few times at work too - there is a lot of crossover between MathJax and many other math display engines.

You can press ctrl+m, m (or cmd+m, m on Mac) to add inline MathJax in Anki. I used this Math StackExchange post as a cheatsheet: https://math.meta.stackexchange.com/questions/5020/mathjax-basic-tutorial-and-quick-reference.

More responsibilities

I have also become a social organizer for the UTC_Night cohort in the OSSU Discord community. This means I help facilitate the little community we have in that cohort. This happens primarily through the weekly check-ins, but there's usually a fair bit of chatter in the channel throughout the week too. I'm happy to report I've made a few more acquaintances in this cohort since becoming a social organizer, which is part of the reason I joined the OSSU community in the first place.

Next up:

I loved calculus in high school, and I love it still, but the truth is that it's probably not going to make much of an appearance in the rest of my OSSU studies and possibly also my career. My next course is discrete math, which has A LOT to do with computer science. Calculus is listed as a prerequisite, but honestly I'm not sure how much help it is going to be.

In any case, I'm excited to learn some new math and hope to have another post here by early January!

I recently installed Fedora Asahi Remix on my M2 Macbook Pro. The installation was super smooth and honestly took me by surprise - I went from curl to a fully-operational Linux distro in about 5 minutes.

However, I was frustrated with the region and locale settings. I wanted to use the American English defaults for everything except for date and time, which should be formatted yyyy-MM-dd (year-month-day, numerical) and HH:mm (24 hour time with leading 0s), respectively.

As an aside: the point-and-click method for changing the region (System Settings -> Region and Language) is kind of finicky - sometimes the changes take effect immediately, sometimes they take effect but the system settings show the old settings until you reboot, and sometimes the settings don't take effect at all until a reboot.

Anyway, I thought the C locale was close enough:

This uses the three-letter abbreviation instead of the number of the month, which wasn't a deal breaker. However, for some reason it does include seconds on the time on the lock screen (HH:mm:ss) and I did not want this. Displaying seconds does consume more battery but mostly I just didn't like it this way. While probably not a big deal (how often is the lock screen actually displayed?), it's not what I wanted.

After a little more searching, I found exactly what I wanted in English (Sweden), aka en_SE.

The only problem: when attempting to select this locale, I received an error: Could not find the system's available locales using the localectl tool. Please file a bug report about this at https://bugs.kds.org

Despite being listed as an option, The en_SE locale was not actually available to use, which was VERY confusing. How could it give me examples of what the current date and time would look like in this format if it didn't have access to that format? I also found a few other locales with this same listed-but-not-actually-useable issue. I did find this error referenced on the KDE bug tracker, but unfortunately I didn't find any easy solutions (e.g. https://bugs.kde.org/show_bug.cgi?id=479213)

At this point I knew it was time to stop playing around with the GUI and use a terminal. I opened Konsole and ran localectl list-locales | grep en to show the list of available English locales on my system, and sure enough en_SE was not one of them.

I had never added a new locale to any operating system before, but I guess this was as good a time as ever to learn how. I read the Fedora documentation for configuring the system locale, read the man page for locale files, and luckily also stumbled across some other internet folk who had this same issue and a similar desire to make dates and times look the way they want. I learned that you can create a properly formatted locale definition file, build it with localedef, and make it available for use in the localectl tool (and also it'll actually work in the system settings GUI).

Coincidentally, at least one other person must have gone through this exact process with the en_SE locale because I found a gist with a locale definition and build instructions for a version of the en_SE locale. This locale file still had Swedish settings for telephone number formatting and default paper size, which I did not want, so I forked the gist and modified the locale definition and build instructions slightly:

en_SE locale

en_SE locale. GitHub Gist: instantly share code, notes, and snippets.

Gist262588213843476

I confirmed the freshly built, custom en_SE locale was available for use:

Time for the test - would activating this locale actually do what I want? I had already become familiar with the terminal-based locale configuration tools, so I decided to set the locale there rather than in the system settings GUI. I also decided to use the en_SE locale only for the time, rather than set it as the global locale. This pretty much negated the changes I made in my version of the locale definition file (since we're only using the date and time format anyway):

sudo localectl set-locale LC_TIME=en_SE.UTF-8

I had to restart for the changes to take effect, but I finally got what I wanted.

This was a lot of work just to make the date and time look how I wanted, but I did learn a fair bit about locales in Linux. To be honest though, the date format in the C locale (dd-mmm-yyyy, e.g. 26 Jan 2024) is growing on me. It totally removes any confusion about whether the first number refers to the day or the month (i.e. is it MM-dd-yyyy or dd-MM-yyyy?) The good news is now I know how to make a custom locale file to do what I want, because I still don't want to see seconds on my lock screen.

Alternatively, I could spend my time doing anything else. We'll see what happens.

Programming Languages, Part C

The last course in the Programming Languages course trilogy. I am going to miss learning from Dan Grossman. Programming Languages A, B, C were some of the most instructive, satisfying, and fun courses I've ever taken. Here's to hoping (probably naively) that the rest of the OSSU curriculum is this awesome.

My progress

I went on vacation in the middle of taking this course, so it took me about 2 weeks longer to complete than I initially estimated. I didn't lose all my momentum, but even after just a 10 day break I had to put in some real effort to get back up to speed before I could make forward progress again. Another reminder that consistency is incredibly important.

My experience

As good as this course was, I still came out with a much higher view of functional programming than object oriented programming. Now that it's been a few weeks and I've had time to digest eveything, I have come to adopt the "right tool for the job" mentality, but OOP just did not land with me like functional programming did.

One of the assignments was to port an interpreter written in SML to Ruby. Over and over I found myself thinking that the Ruby version of the program was so much more complex and involved so much more ceremony than the SML version. I felt like I was spending a lot of my time in Ruby setting up to do the thing I wanted to do, instead of just doing the thing. It was also harder for me to follow the path my code would take, which consequently made debugging my Ruby code harder and cost more time than in SML. This echos my (limited) experience in other heavily OOP languages like C# (though debugging was a little easier in C# because of the tooling and it being staticly typed). However, I did feel like a wizard after nailing the double-dispatch portions of the porting assignment on my first attempt.

I also developed a strong preference for static typing over dynamic typing. There were a number of times I discovered a bug in my Ruby code after way too much debugging, only to realize that the problem was a minor typo or some other simple mistake that caused the program to misbehave in some weird way. The perfect example of this came from another student's solution while I was peer reviewing it (warning: this is a bit technical):

There was a method that should never return false, but was returning false in certain situations. The problem was here:

The issue is in that one-line ternary expression. Evertything before the ? should be wrapped in parenthesis, otherwise Ruby will evaluate the and of everything before the and keyword, and everything to the right of it. In other words, with the way this code is written, the and expression is the outermost operation, not the ternary expression - which will always return a Boolean value. The correct version of this code is this (notice the and expression wrapped in parenthesis):

(inbetween(@x, seg.x1, seg.x2) and inbetween(@y, seg.y1, seg.y2)) ? Point.new(@x, @y) : NoPoints.new

To top it off, this was buried beneath a few layers of double-dispatch shenanigans. It took me about an hour to figure this out, and who knows how much time was spent by the student who originally wrote the code - this didn't pass the given tests so I'm guessing the student just gave up trying to fix it and turned it in. Static typing would have caught this before runtime and would have given a helpful error message.

Next up

I decided to take a small break from Core Programming and start on Core Math. I have fond memories of learning Calculus in high school and I am much more excited to revisit that than learn more about object-oriented programming. I could feel some resistence toward toward the thought of learning "Object Oriented Design" with Java, so I figure this was the better move to avoid burnout and preserve consistency.

Programming Languages, Part B

Programming Languages Part A, Part B, and Part C are really one whole course broken up into three pieces, so it was both useful and satisfying that I was able to keep up the momentum from Part A. I finished this course exactly on time:

The course was a lot of fun, but I have to be honest and say that programming in Racket was not nearly as fun as programming in SML. Some possible reasons:

• The amount of parentheses can get kind of ridiculous. Relevant xkcd: https://xkcd.com/297/
• Maybe I'm spoiled by how nice SML's syntax (and especially case expressions) are
• Racket isn't novel to me like SML was (the How to Code courses use something very similar to Racket)
• This course had me doing more complicated things than I was doing in Part A with SML
• I enjoyed the static typing in SML more than the dynamic typing we used in Racket. Things just felt more neat, tidy, and orderly in a static type system.

Whatever the reason(s) were: I was less happy programming with Racket in this course than SML in Part A, but I still enjoyed myself.

Just like in previous courses, I had a number of "a ha" moments where things that were confusing before suddenly clicked. I love when that happens. I feel like my understanding of computer science and programming has improved dramatically in just the four courses I've taken so far, even though none of them are particularly deep. Among the "a ha" moments in this course were:

• how promises work
• how streams work
• memoization (function caching)
• (related to the above) even in a functional paradigm, mutation is sometimes genuinely useful, or even necessary

The final homework in this course has you writing a very basic interpreter for a "language" created solely for the purpose of this homework, aptly called "Made Up Programming Language", or MUPL. In the past I would sometimes read posts and articles about someone writing an interpreter for some language and it would feel so far above my capabilities and knowledge that I wouldn't even know where to start. To be honest, I wasn't even sure what an "interpreter" was. Obviously writing this incredibly basic interpreter for an incredibly basic language is nothing to brag about, but I no longer feel like "interpreters" is a topic reserved for higher life forms. I genuinely had a blast with this homework assignment.

Next up:

Programming Languages, Part C is the last course in this series. It uses Ruby and aims to teach Object Oriented Programming with a dynamic type system and contrast it with Functional Programming. At this point I am very much on the functional programming train, so we'll see if Dan Grossman (the instructor for these courses) can convince me that OOP is just as awesome. OOP is what I learned when I first started programming, so the novelty probably won't be there like it was with FP, but I am excited nonetheless.

I intend to keep this pace going through Part C as well. Hopefully you'll see another blog post from me in mid to late July!

Programming Languages, Part A

This is the first blog post I've written about OSSU where I don't have to explain why I failed so miserably to meet my goals, and that feels really good. I finished the course about a week earlier than planned:

This is another course that I thoroughly enjoyed. It hit that sweet spot where the content was difficult enough to be challenging, but not so difficult that it was discouraging.

Software setup

I completed this course using both a MacBook and a Windows 10 laptop. Setup was not nearly as hard as the course made it sound, though that might be in part because I used Visual Studio Code instead of Emacs. I already use VSCode on a daily basis and didn't see a good reason to learn Emacs.

Setup on Windows was really easy. I just installed SML and this extension (for VSCode): SML Environment. I used the SML REPL from the terminal in VSCode.

Setup on MacOS was a little more complicated, but not terribly so:

• SML installed fine, though it uses Rosetta since (as of now) there is no native SML compiler for Apple Silicon. I did not experience any performance issues or bugs but the stuff you program in this course is not terribly large or complicated, so I can't say whether or not the Rosetta layer would be an issue if you were doing something more complex.
• The default shell in MacOS is zsh now, not bash. All I had to do was add a PATH export in my ~/.zshrc file:
  export PATH="$PATH:/usr/local/smlnj/bin"
• There was an issue using command history (actually anything involving the arrow keys) in the SML REPL. For example, if I pressed the up arrow key to get my previous command, a bunch of random characters would appear instead. Evidently this has been an issue for a long time. My solution was to install rlwrap and then run the SML REPL like this: rlwrap sml

I created a new repo in Github and used git to keep my notes and homework in sync between my Windows and Mac laptops.

Course content

I settled into a routine pretty quickly, and I think it worked pretty well:

1. Watch all videos at 1.5x speed, taking notes and programming along. Rewatch any videos where the material was harder to grasp.
2. Skim through the section summary, paying particular attention to topics that were difficult to understand in the videos.
3. Do the homework, referencing the section summary and SML language documentation when I get stuck.

The homework assignments in this course were incredibly important. I started each one with a 70-80% grasp of the week's material and finished feeling very confident in the material. Everything sort of clicked into place as I worked through the problems. This was particularly true of concepts like lexical scope and closures.

In my opinion the peer reviews were almost equally important. I didn't get a lot of good peer review feedback - sometimes it was even frustrating - but the process of reading other students' code and critiqueing it was really helpful. I saw code that was both worse and better than my own, and then had to articulate what specifically was good or bad about that code. This granted me additional clarity that I didn't have even after completing the homework myself.

Tests are still really important

The test file you get for each homework is nowhere near exhaustive. You are expected to write more tests for each of your functions. I passed each homework the first time I turned it in, and this would not have happened if I didn't first write a bunch of good tests for each of my functions. These tests also helped me identify issues with other students' code during peer reviews.

I got slightly lazy about this in homework 3, and it cost me some time and effort. You have to write a helper function called longest_string_helper and the basic test file had no test for this function. I decided to skip writing tests for this function as well. When I turned in my work to the autograder, I passed (i.e. scored more than 80%) but was surprised to see that I was docked points even though all my tests passed.

After carefully re-reading the relevant homework problem, looking at the sample solution, and looking at the type that SML inferred for my function, I realized that I had slightly misunderstood what the longest_string_helper function was supposed to do. In short, I needed to compare the size of two strings in my helper function, not in the functions that called my helper function. If I had written even a single good test for longest_string_helper it's likely I would have realized this immediately, because it probably would not have even type-checked. I wish I could show you the specifics here, but sharing this code is against the TOS for the course.

Next up:

I jumped right into the next course, Programming Languages Part B, which should take about 3 weeks to complete. I am really enjoying the momentum I have right now, and while I don't expect to complete every OSSU course ahead of schedule, I am hoping to complete them at least within a week of my estimated finish date. Here's to hoping the 4-months-overdue phase of my OSSU studies was indeed just a phase.

Where have I been?

I last posted about OSSU on January 10th of this year. Almost four months ago. I wish I could say that in that time I was tearing through courses and Getting Stuff Done™ but the truth is:

It took me over four months to finish a single course. I publicly committed to ~15 hours/week of study and a blog post every month. Obviously neither of these happened, and I'm pretty embarrassed about it. Some contributing factors to this:

• At work, I had some significant projects pop up. Among them was dealing with the fallout from the LastPass breach (we moved to 1Password), a SharePoint migration, and another vendor incident. Between these things, other projects, and the normal day-to-day stuff, much of the the time I had set aside for OSSU ended up used to get other stuff done.
• I had some pretty serious stuff come up in my personal life. I'm not going to go into detail, but OSSU took a backseat for a while.
• Between the work stuff and personal stuff, there were two periods of about a month where I did not work on the How to Code: Complex Data course at all. Consequently, when I got back into the course I had to spend some time re-familiarizing myself with the course content. I think I went through chapter 12 of the course two or three times.

Moving forward I'm making the following adjustments to my routine:

1. Shooting for 10 hours every week (instead of 15). This was something I had considered after my last blog post too. It is honestly just a more realistic goal right now.
2. A blog post after every course (instead of every month). This is a more natural place to take a short break and I'm typically in a more reflective mood after completing something anyway.

How to Code: Complex Data

I really enjoyed this course. I said something similar at the end of the previous course, but I really do understand the functional programming hype now. I have plenty more to learn, but this course challenged me in ways that were sometimes frustrating, but also fun and rewarding.

There's a project where you build a Sudoku solver. It sounds like a daunting project at first, but if you break the problem down into small chunks and follow the recipes, it kind of just comes together. There were many times during this course where things felt magical and reminded me of why I like programming so much in the first place.

While I do understand functional programming a little better now, it is still pretty foreign to me. This was, honestly, a positive thing. In OSSU blog #3 I said: "I have a tendency to just sit down and start working on the problem at hand, without much effort to plan things out first". While the first How to Code course offered strong incentives to think hard about the problem you were solving before you solve it, this course made it impossible to do otherwise - at least for me.

Learning about abstract functions was also a big deal. I've written plenty of javascript and python, but my understanding of map() was limited to: "everyone says I should use map() if I need to call the same function on all elements in a list". After completing this course not only do I have a much better understanding of what map() does and why I should use it, but I have gained that same understanding for abstract functions in general. Functions like map(), filter(), and sum() no longer seem like black magic to me.

I also feel like I have a much better grasp on recursion in general. Even as I started this course it still felt like magic. I'm sure the next course (Programming Languages, Part A) will be humbling, but for now I'm enjoying it.

Similar to the abstract functions revelation, I also know what people mean when they talk about trees and graphs as data structures. It wasn't quite the brain-melting experience I had as when abstract functions clicked with me, but I suspect it'll be at least as important later on.

Discord

The OSSU community on Discord was really helpful while I took this course. I had some people check my work on a few assignments and I can't overstate how beneficial it is to get constructive feedback while you're learning something new.  

My attendance at the weekly check-ins has still been pretty abysmal. Stuff in my personal life has calmed down a bit so my attendance should get better. I am also considering a switch to another cohort with a different weekly check-in time.

What's next?

I'm diving right into Programming Languages, Part A with much excitement. Hopefully another blog post in 5-6 weeks!

How to Code: Simple Data

This course was next up after the math prerequisites. A large chunk of this course involved information that was completely new to me, which on one hand was a bit surprising given my existing technical background, but on the other hand I had never done any real work with functional programming. Object-oriented programming and Java were the standard when I was in college the first time.

After taking this course, I think I understand some of the hype behind functional programming. There is a certain elegance about it, and at least for me, recursive functions are kind of magical. That feeling hasn't worn off too much even as I work through the next course (How to Code: Complex Data).

This course also revealed (and helped correct) some poor development habits that had crept in over the years:

Make sure the problem is well-defined

I don't do this all the time, but when I program I have a tendency to just sit down and start working on the problem at hand, without much effort to plan things out first. Consequently, I often end up rewriting things from scratch and changing design decisions frequently as I go. I know that this is not the optimal way to do it, but things usually work out.

This course, like any good instructional course, emphasizes the opposite. Before you write code, you need to ask questions like: What is the problem I am trying to solve? What specific` things does this function need to do? What constants do I need? What is the function changing? Should I sketch out the flow of the program first?

These are basic concepts when tackling any problem. They are not unique to programming. I try to plan well in all areas of my personal and work life - and yet, I had become undisciplined in this specific area. As I solved the small, relatively simple problems in this course, I was reminded that proper planning goes a long way. It's hard to describe how important this is unless you've experienced the boost in productivity for yourself.

Write good tests, and write them first

I've done a little bit of work with testing frameworks over the years, but this course forces you to write tests before your functions are written. This was extremely helpful in two ways (there are probably more ways but these were the most obvious to me):

1. It makes writing the function easier because you have a clearer idea of what you want the function to do
2. It's easier to catch bugs and unexpected behavior if you make changes in the future.  

Bias to simpler functions

When I say "simple" I mean it as the opposite of "complex". A single function should not try to do too much. Functions that only do a few things are preferable to functions that try to do a bunch of things in one place. Simpler functions are, in general, easier to write, maintain, and understand.

I will sometimes write functions that are big, long, sprawling messes and leave them that way. This course helped remind me that it is a good idea to not do that.

Study habits and routine

The plan:

1. Study a minimum of 15 hours every week
2. Work through one course at a time, and definitely no more than two at a time.
3. Actively participate in the Discord community.  

15 hours/week

I struggled with this one the last few months. There was a period of about 20 days in November where I didn't work on OSSU at all. I took a week off around Thanksgiving when I was out of state with family, but for over a month after we got back at least one person in my immediate family was sick. I personally got sick three times between late November and early January, one of which was with whatever variant of COVID is going around.

We've got two young kids, one of which is in school, and the weather was changing so on one hand this is kind of expected, but on the other hand three times in a month is a lot. After I got sick the first time, I fell off track with my sleeping and exercise habits. I think this may have played a part in weakening my immune system. I'm back on track now and I've also started to implement some of the habits I learned in these Huberman Lab podcasts:

It took me over two months to complete How to Code: Simple Data. This is far too slow a pace. My pace has been better since I started How to Code: Complex Data, but I'm really going need to drive forward harder if I want to complete OSSU in two years.

One course at a time

No problems with this one, as you might expect. I struggled to complete a single course in two months, so I'm not really feeling tempted to add more courses to my workload.

Participate in the Discord community

The weekly check-ins for the UTC Night cohort have been text-only for a while, which is kind of disappointing, but I'm not sure I would have attended voice chats much either. There's been a push recently for more voice chat check-ins, and I'd like to do better about attending them.

That said, I have been a bit more active on Discord than when I was taking the math prerequisites. It is a legitimately helpful place for getting your questions answered. I even answered a question or two myself, which gave me a nice feeling of validation after taking so long to complete How to Code: Simple Data.

What's next?

As I write this, I'm working steadily through the next course: How to Code: Complex Data. I am progressing at a decent pace and am really enjoying the course so far. All the (frankly annoying) work you put in to get disciplined about function signatures, type comments, etc in HtC: Simple Data really pays off in this course.

I missed a few months of blogging (this post was due in November), but I'm hopeful that things are back on track now.

I forgot a lot of math

The first thing I did for OSSU (other than the "learning how to learn" stuff - see blog post #1) was tackle the math prerequisites. I considered "passing" to be when I could do the course challenges in Khan Academy and score at least 80%. It took me ~13 weeks to get this done.

As you can see in the screenshot above, I greatly underestimated how long it would take for me to complete the math prerequisites. The estimated finish date was based on how quickly I was progressing through Arithmetic, Geometry, and Pre-algebra in Khan Academy, which in hindsight was a silly thing to do. My progress got much slower as I got about halfway through High School Math 2, and High School Math 3 alone took me 6 weeks to complete.

The most frustrating part of High School Math 2 and 3 was that I had forgotten just enough from high school that I needed to review most sections in their entirety, but everything was pretty easy after I relearned it. When I graduated high school (over ten years ago) I had done enough math to pass the AP exam for Calc 2, so sitting through videos and working practice problems about the side-angle-side theorem and converting radians to degrees was pretty boring - but I had legitimately forgotten how to do that stuff, so it was necessary.

I probably could have skipped more sections than I did, but this would have contradicted my goal of learning computer science well. If math is important in computer science (and it is), I want to make sure my foundation is rock solid. I even went as far as making Anki cards for some of the formulas and concepts as I was relearning them, just to make sure they really stuck.

I have already benefitted professionally from OSSU

I recently had to do a deep dive into some technical indicators involved in our financial trading systems at SEM (where I work). This involved figuring out the inner workings of a fairly custom exponential moving average function and then reinplementing it myself.

I happened to be working through summations and series in Khan Academy at the exact same time, which was perfect timing. I can say, without a doubt, that revisiting those math concepts helped me complete the task faster and with far more confidence.

Study habits and routine

I had a section in post #1 called How am I going to tackle the curriculum? Long story short, I planned to:

1. Study a minimum of 15 hours every week
2. Work through one course at a time, and definitely no more than two at a time.
3. Actively participate in the Discord community.  

It's been about 6 weeks since the last OSSU blog post. Here's how things have worked out since then:

15 hours/week

I was really good about this at first. My wife and I are usually pretty intentional about planning our lives each week - we sit down with our calendar, our list of activities, things we want to accomplish, etc and schedule all of it - including blocking out chunks of time for me to study without any interruptions. I was also exercising regularly, getting up in the morning and taking cold showers, and trying to get 8 hours of sleep every night.

At some point in September, my wife and I both got sick at the same time. It lasted for a few days and needless to say - especially with young kids in the house - it was a rough week. As you might expect, it also totally upended our routines. After we got better, it was hard to jump back into how things were before. I should have anticipated this and prepared for it, but even after getting better I didn't resume my exercise routines, I stopped making sure I was going to bed on time, and I was lax about completing my daily tasks. To nobody's surprise, this affected my ability to wake up early, my energy levels, and my motivation. I didn't completely stop working on OSSU (or the other things in my life), but my general level of productivity was far lower than before we got sick. I think there were 4 straight weeks where I did not hit 15 hours of studying, which certainly played a part in why High School Math 3 took me six weeks to complete.    

I'm pretty much back on track now, and I'm also done slogging through the math prerequisites - so I'm expecting the next month to be much more productive.

One course at a time

I had no issues sticking with this, with one minor exception: in late August I was feeling a little burnt out on the math prerequisites. This is something I anticipated, and as I talked about in OSSU post #1 the solution was to do two courses in parallel so that I could bounce between them when I was feeling unmotivated. With this in mind, I started the How to Code: Simple Data course on EdX.

Shortly afterward, I regained my motivation for math and switched back to concentrating on the math prerequisite courses exclusively. However, the audit track for the EdX course (i.e., the option that allows you to take the course for free) expires after a certain amount of time. With some courses you can just re-enroll after the expiration date, but with other courses you can't regain access unless you pay for the verified track. This course was the latter.

My solution was to create a second EdX account using plus addressing and enroll in the course under that account. If you don't know what plus addressing is, a quick explanation is: if you have an email account test@example.com, you can add a + and an arbitrary string after your username but email will still be delivered to the same inbox. In other words, I could sign up to EdX a second time with the address test+edx2@example.com because EdX considers it a different email address than test@example.com, but any email sent to the plus address variation will go to the exact same inbox. I essentually created two different EdX accounts that are both tied to the same email account.

Actively participate in the Discord community

I was pretty consistent with this, though the "UTC Night" cohort was smaller than I expected. I had an audio call with one member the first week I joined, but the cohort has done text check-ins since then. I also try to check in daily on the channels for whichever course I'm currently working on, but I haven't found a lot of opportunity to say something useful or ask a good question yet. I'm guessing this will change as I move into the "proper" OSSU curriculum now that I'm done with the math prerequisites.

That's all I've got for this update. I still plan to blog about once per month, so look for update #3 some time in November. Thanks for reading!

Why am I learning computer science?

A little backstory: I always knew that my career would involve playing guitar or messing with computers. The first time I tried college, my plan was to major in guitar performance and minor in computer science. Due to a bunch of immature decisions, this didn't work out and I ended up dropping out and falling into traditional sysadmin IT work. I liked the work I was doing well enough - and I did eventually get a degree in Information Technology from WGU - but this was not my first choice; I like programming far more than taking care of infrastructure.

Fast forward to today: I work for SEM Wealth Management, which has a number of proprietary financial trading systems that have been developed over the better part of 30 years. The trading team at SEM recently decided it was time to rework and modernize some of the technology behind these trading systems. I was asked to participate in this, and so I started brushing up on my Python.

I've been loving it. I'm doing a lot of programming and learning new things every day. However, as I attempt to understand and develop new features for these trading systems, I am finding myself at the edge of my knowledge and abilities pretty regularly. Given that this project involves a lot of math and a lot of programming, it seemed appropriate to finally finish my education in computer science - which, with the benefit of hindsight, is what I should have done the first time I went to college. If anyone in my family is reading this: yes, I admit you were right.

Why OSSU in particular?

I initially considered going back to college to get a formal degree in Computer Science, but the ROI for that at this point in my life is not very high. Formal education is not cheap and there are two main reasons I don't think the value of a CS degree justifies the cost in my current situation:

1. I need flexibility. I'm married, have kids, work a full time job, and the closest university is 30 minutes away. I could certainly make it happen, but attending classes and doing school work on a rigid schedule would have a high cost. There are plenty of online degree programs for computer science, which would afford me the flexibility I need, but that brings us to point #2
2. I don't need another credential. My singular concern is developing competency. I'm not looking for another job and even if I was, my resume, portfolio, and ability to demonstrate skills and knowledge would matter far more than having another bachelor's degree in a field so closely related to my first one.  

With that being said, the credential you get at the end is just one benefit of college. A formal program also gives you a community, accountability, and direct access to instructors (i.e. mentorship). These things are significant. I knew that if I wasn't going to go through a formal CS program I needed to try and replicate the benefits of one as much as possible. I like to think of myself as a self-motivated autodidact, but the truth is that I need to be surrounded both by people who are in the trenches with me and people who have already done what I am doing. I’m not special and need guidance, accountability, and mentorship as much as anyone else.

I started researching what my options were. I initially entertained the idea of doing a bootcamp, but the goals of a bootcamp aren't really aligned with my goals; bootcamps seem to be more like jobs programs than formal education programs. I eventually narrowed my options down to OSSU and Teach Yourself Computer Science, and ultimately OSSU won out because it fit my criteria best. You can read the summary section in the OSSU README for more details, but in short:

• The OSSU cirriculum is intended to meet a formally defined set of guidelines for what makes a good computer science program
• Courses are either self-paced or run multiple times per year.
• Courses usually have homework and assignments. Many of the courses require you to pay to get the assignments graded by a real person, though.
• There is an active OSSU Discord server with channels for specific courses. There are also a few cohort communities that hold weekly check-in meetings. A number of people knowledgeable in CS and the OSSU cirriculum are also hanging out in the server - at least one of them has the server role of "Tutor".

Teach Yourself Computer Science looked good, but unfortunately it lacks a community. As I mentioned above, a community and at least some level of accountability are very important to me.

Why am I blogging about this?

1. Accountability. I know that at some point I'm going to want to quit. Maybe it'll be because of some situation in my personal life. Maybe I'll get really frustrated with one of the courses. I won't be on a college campus every day around other motivated people. I'm not paying any money to take these classes. My job isn't on the line if I don't complete the cirriculum. There are plenty of things that could affect my motivation. Blogging about my journey is a way to introduce some accountability - if I tell my friends, family, and Discord community that I will be posting regularly about OSSU, they will expect me to do just that. If I stop, there is a pool of people who could ask "what happened?" and "why did you quit?".
2. It helps establish a routine. Not much to say here - establishing routines is a good way to deal with the times that you don't feel motivated.
3. I get to practice communicating. It usually takes me a while - far longer than I'd like - to organize my thoughts into something communicable. For example, it's been about 3 weeks since I first started this blog post. I also tend to be overly verbose and the essence of what I'm saying is often lost in the noise. Blogging regularly gives me an opportunity to practice this skill and get better at communicating.

How am I going to tackle the cirriculum?

I think there are three main things here:

1. Organizing my time
2. Organizing my studies
3. Participation in the community

Organizing my time

The OSSU README says you can finish the cirriculum "within about 2 years if you plan carefully and devote roughly 20 hours/week to your studies". I'm going to shoot for 15 hours per week at a minimum. I think this is incredibly realistic, and that's intentional; I don't want to set a lofty goal and then feel unmotivated when I inevitably fail to meet that goal. Here's how I plan to spend my time on OSSU during the week:

1. I have permission from my boss to spend up to 1.5 hours per day studying at work since this has a direct effect on my performance and abilities at work. If I can do this 5 days/week, that's 7.5 hours/week.
2. Over the course of a normal Monday-Friday outside of work, I can for sure dedicate three 2-hour blocks. That's 6 hours/week.
3. Over the course of a normal weekend, I can for sure dedicate two 2-hour blocks. That's 4 hours/week.

This adds up to 17.5 hours/week. This gives me some wiggle room to meet the minimum 15 hours/week even if I can't do 1.5 hours every day at work. If I have a more time during the week or on the weekend, I can get even more done. It is almost certain that I will have more than 4 hours available on the weekends but I am intentionally not including that in my calculations because the goal is simply at least 15 hours per week.

I'll plan the specific time slots on a week-to-week basis. I've got two young kids - not every week is going to look the same.

Organizing my studies

One thing I've realized about myself is that I can only juggle so many things as once (an earth-shattering realization, I know). With this is mind, I'm going to try and stick to one course at a time. If I start to get burned out on a course or need variety for some reason, I'm willing to do two courses in parallel - but no more than that.

I am also intentionally not setting any goals in terms of finishing X courses in Y amount of time. I will finish each course in the amount of time that it takes for me to learn the material - remember, my goal is to learn CS well, not get a credential. That being said, OSSU provides an estimated time to complete each course. I can use these numbers as a benchmark to help assess my competency; if I finish a course faster than the estimated time, that could mean I didn't learn the material deeply. If I'm delayed, that could mean I need some extra guidance.

I'm planning to track all of this in Notion (which I've become rather fond of). I set up a basic table to track the courses I'm working on, and each of the rows in this table contains a page where I can take notes, document progress, or whatever else I need to do.

As a side note, you may notice the first three "courses" that I completed in that table are not actually part of the OSSU cirriculum. I came across these resources a little while ago and they totally changed how I approach learning new things, so I thought it might be a good idea to revisit them before starting OSSU. Here are the links if you're interested:

• https://www.coursera.org/learn/learning-how-to-learn
• https://www.youtube.com/watch?v=Z-zNHHpXoMM
• https://www.youtube.com/watch?v=ukLnPbIffxE

Participation in the community

There are three cohort communities in the OSSU Discord server, each corresponding to an 8-hour period of time, and you're meant to join the cohort that aligns best with the window of time you spend working on OSSU material. I joined the "UTC Night" cohort, which covers 8:00pm - 4:00am UTC (which is currently 4:00pm - 12:00am Eastern Time). Each cohort has a weekly check-in, and I intend to attend these as much as possible.

I think it makes sense to spend a few minutes every day checking in on the Discord channels for my cohort community and the course(s) that I am currently working on. I don't want to be a stranger in these communities, so I'd like to participate in discussions and ask my own questions as much as possible.

As for blogging: I think a cadence of one post every month makes sense. My intuition is that a month is just long enough to 1. give me enough new experiences to write about and 2. not interfere with my studying.

Kudos to you if you're still here - this post is sitting at just about 2,000 words. Hopefully OSSU blog post #2 will be a little shorter!

Consider this (imperfect) example: you're using a ModelForm to allow users of your web app to create a Student. The user would supply the student's name, date of birth, and address in a form, but the student ID should be generated based on their other information (e.g. name and date of birth).

The ModelForm object won't give you access to the underlying Model's student_id field unless you include it with the form, which is undesirable. You could also save the Student to the database, then update its student_id field, but that's pretty inefficient. The better solution:

# Model
class Student(models.Model):
    student_id = models.CharField()
    name = models.CharField()
    dob = models.DateField()
    address = models.CharField()
    

# ModelForm
class AddStudentForm(forms.ModelForm):
    class Meta:
        model = Student
        # don't include student_id
        fields = ['name', 'birthday', 'address']
        

# View
def add_student(request):
    ...
    if form.is_valid():
        # this will gave you an instance of the Student model without saving it to the db
        student = form.save(commit=False)
        
        # then you can create the student_id and save to the db
        student.student_id = create_id(student.name, student.dob)
        student.save()
    ....

tl;dr - OneDrive's known folder move is nice for general use, but don't put your git repositories in a folder synced by OneDrive (e.g. %UserProfile%\Documents\GitHub\)

Why not?

By default, OneDrive will try to save space by removing files that haven't been used in a while (re-downloading them when necessary). Think of how this could affect a node_modules or venv folder; need to work on a project you haven't touched in a week? Gotta wait while OneDrive re-downloads thousands of files. Running npm install for the first time in a project? OneDrive is about to go nuts trying to sync thousands of files. You can mitigate some of these issues - e.g. marking folders "always keep on device" - but even then, these things really do get in the way.

There's also often some hooplah involved when deleting a repository (remember that pesky node_modules folder with thousands of files?). OneDrive also has some restrictions on what types of files will be synced, and some other restrictions that you might run into as a developer (e.g. certain characters not allowed in filenames). If any of these restrictions are violated you'll get complaints from OneDrive. Not worth the hassle in my opinion.

I started keeping git repositories in the root of my user profile, sometimes within a subfolder there (e.g. %UserProfile%\GitHub). Obviously the repositories won't be backed up in OneDrive, but if something happens to my computer, I can just clone the repository again and reinstall the packages (assuming I've been pushing changes to remote/origin regularly)

Known folder move is great for most other, non-repository things though!

Whenever I would save a template, some sort of autoformatting would happen and make my Django template tags look really undesirable. Here's an example (shoutout to the Django Girls tutorial):

Before saving:

After saving:

This would happen every time I pressed Ctrl + s. Obviously it was pretty annoying. I think the culprit was the built-in HTML autoformatter, so I played with some of the built-in settings in VSCode but ultimately nothing I did with those settings fixed this.

Solution

Installed this plugin (simply named Django): https://marketplace.visualstudio.com/items?itemName=batisteo.vscode-django

Added some lines to my workspace json file under settings:

"settings": {
	"files.associations": {
		"**/*.html": "html",
		"**/templates/**/*.html": "django-html",
		"**/templates/**/*": "django-txt",
		"**/requirements{/**,*}.{txt,in}": "pip-requirements"
	},
},

After reloading VSCode, the language for my Django template files was automatically set to Django HTML and the undesirable autoformatting problem was gone.