OSU eCampus CS361 Software Engineering I review & recap

This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.

Six-word summary: Group work group work group work

In CS361 you’ll get a high level look at “real world” scheduling methodologies (mostly waterfall and agile) and you’ll work in a group with 3-4 other students to meet weekly milestones designing and implementing parts of some other student’s “Vision Statement”.

CS361 Review

You don’t have to spend long on the OSU CS subreddit to realize that virtually no one likes this class. It’s not awful, but I understand the frustrations people voice on various forums around the web.

The heavy reliance on group work was frustrating more often than not and the course materials felt dated or like they were specific to a certain industry, but I didn’t dislike this class as much as most people seem to. I think it helped that I already have design and software development experience and enjoy writing and making diagrams/mockups, so this class played to some of my strengths.

The materials that introduce common planning and scheduling techniques for software projects were a welcome inclusion – I’m glad this stuff is covered somewhere in OSU’s CS program – but I thought they didn’t go nearly in depth enough to prepare students for the realities of working on an agile team. There wasn’t enough story writing, requirements gathering, pointing exercises, or customer involvement.

I thought the weekly homework assignments were a little lackluster. Working in a group is tough even in the best situations – some parts of the homework depended on other parts being done first, and some people’s schedules didn’t seem to allow for them to start the homework early in the week.

The documents we wrote as a group seemed excessively heavy on diagrams and put too much emphasis on satisfying a very specific set of expectations. For example, there’s a lot of emphasis placed on terminology such as “functional requirements” and “functional definitions”, which I had never heard outside of this class or seen used so religiously, but the concepts they represent were familiar. That describes a lot of this class’s materials: heavy focus on overly-specific methods and terms that probably don’t translate to every industry.

Maybe the course’s materials would be improved by taking a step back from strict terminology and definitions and talking instead about how to write good step-by-step documentation, how to write a good bug, how to write a good feature design that someone else can implement from – skills that can be applied to a variety of specific methodologies, since it’s impossible to predict which ones your future company or team might be using. There are so many skills that have nothing to do with programming that programmers still need to develop, and this class could be a good place to start learning them.

Class structure

  • In the first week of the class, everyone in the class writes a 2000 word “Vision Statement” for a software product that solves some lofty real-world problem. Forget about making a simple app to solve a simple problem, your idea for this vision statement should be utterly epic. They are surprisingly strict about the 2000 word count, but you should be able to hit that easily by showing off your design skills and covering every topic imaginable in relation to your app idea. You really can’t write too much, and no topic is too trivial to not write a page about. (I thought I’d covered security pretty well with the half page I wrote on it, but I got got dinged for not writing enough on the topic. I got the feeling the TA had to find something wrong with my document and if it wasn’t that, it’d have been something else.)
  • In the second week of the class, everyone votes on which ideas they think are best.
  • It doesn’t matter what you vote for. Your voting has no bearing on what project you get assigned. But you should vote anyway to help lift decent-sounding projects to the top, so that nobody has to work on the duds.
  • Expect to be assigned to a project you didn’t vote for because you thought it sounded stupid or impossible (or both).
  • You’ll then get grouped with 3-4 classmates based on absolutely no criteria whatsoever, so expect clashing schedules/mismatched interests/time zone incompatibilities. The instructor says this is part of life, and I agree (and every single software team I’ve been on has had an off-shore counterpart on the other side of the globe), but don’t expect your teammates to be so understanding. My group insisted that the only time we could meet was what was usually my bedtime, which sucked for me.
  • You’ll get to know these people very well as you meet 1-2 times a week (probably over a voice chat if your group is keyboard-phobic or generally unavailable at any time of day outside of the specific meeting window)
  • Every week you’ll work with these people to produce a lengthy document in response to a lengthy prompt. It will require diagrams and lots and lots of writing.
  • This assignment will be graded by a TA who might have limited English skills or a general lack of interest in reading 12+ pages of rather dry writing. We lost points on things that were present and the TA missed and we lost points on things that were never part of the requirements in the first place.
  • The last two weeks of the term are spent coding a small portion of the stuff you designed thus far; your group members may or may not participate in this process depending on whether they’re dirtbags or not
  • The final is made up of rather vague questions, but you should review the slides anyway to scoop up whatever points you can here

CS361 Tips

Vision statement tips

The grading requirements on the vision statement draft are really vague, but you can get full credit by writing a ton on every design topic you can think of and meeting the 2000 minimum word requirement.

Some ideas of what to include (beyond what the assignment suggests):

  • What differentiates your app from similar ones – do some market research and write comparisons. Someone’s probably already made a product like the one you’re imagining. What makes yours better? 
  • User profiles – Imagine some hypothetical users for your app and write about them. Are they young? Old? Tech-savvy? Tech-illiterate? How is your app designed to appeal to them and meet their needs?
  • Accessibility features – imagine how your app might work on a screen reader or to someone with limited vision and write about how accessibility concerns are addressed in your app.
  • Security features – I wrote like half a page on security, which wasn’t enough according to my TA. Maybe you can do better!
  • Mockups! I made mine in mockflow

Journal tips

Work on the journal regularly – every other day is a good pace. The class’s instructor looks at these himself (or at least he looked at mine himself and commented on it) and he’s very good at detecting who wrote theirs in one fell swoop the night before it was due.

If you don’t know what to write, here are some ideas I used throughout the course to inspire myself:

  • Draw a comparison between the class’s material and your experiences working in a team – you ought to have some from your previous career or OSU classes
  • Talk about any previous software development experience you have; maybe throw in a bit about how you think CS361’s teachings on topics like agile will help you on future projects you develop
  • Talk about how your group work is going
  • Relate the lecture material to outside reading you’ve done or things you’ve heard
  • Sometimes the lecturer asks questions in the video; respond to those
  • Respond to the weekly learning topics: early in the week, write what you think they mean, then, after you do the lectures and your part of the homework, write again about what you’ve learned about those topics and correct any misinterpretations you had initially

Track your group members’ contributions

Yes, it feels creepy to keep secret notes about who in your group isn’t attending meetings, who turned in their part just hours before it was due, etc., but in the last week you’ll be asked to produce a very long, very detailed document rating each group member on a half-dozen criteria and justifying your rating in writing, so having kept track of this stuff will help you earn full credit on the assignment. I did my group member tracking in a Google Spreadsheet with a column for each week of the class and a row for each group member.

A lot of people in the Slack channel reported getting dinged for not being detailed enough, so keep regular notes and you should have plenty of material for this document and you should be able to write it in very little time. (Mine was 14 pages and included screenshots and data about meeting attendance and how close to the weekly deadline each person submitted their work; I got full credit on the group evaluation.)

Pick a programming language / framework that plays to your group’s strengths

Three people in my group inexplicably voted in favor of a framework they had little to no familiarity with – and majority ruled. I spent 2 weeks giving myself a crash course in JavaFX, coding as I went, which was fine but our development weeks would have gone so much better if the group had just picked something we already knew and could’ve hit the ground running in. The end result: some group members struggled to produce anything at all during the coding weeks.

Here’s what we ended up with: a clickable map of the United States that colors states according to how they voted in the 2016 presidential election and, alternatively, according to how gerrymandered they are.

This screenshot best represents my portion of the work: building the map and hooking it up to real data.

Implementing this much functionality posed plenty of interesting challenges to work through. Things like building a complete map out of individual SVG boundaries, figuring out how to make them clickable, altering their color based on data from the project’s database, and fitting containers within containers to get everything fitting in the application window kept me busy for the two weeks.

For some people in my group this was their first exposure to Git as well, so this project came with a side-helping of Git training. (Note to any future students out there: if you don’t know git yet, start learning it now – don’t wait until you’re in a time crunch of a group project with multiple people counting on you.)

And finally…

Don’t be a dick

Show up to meetings. Do your part and do it early enough so that your group can review it. Don’t disappear during the coding weeks. Be a good team member and make connections on LinkedIn once the class is over.

An educational program like this one is a huge opportunity to network and make friends; you never know who might end up at a great company someday and put in a good word for you. You can gripe about 361 and sandbag for two months, or you can impress a bunch of future industry peers by knocking it out of the park every week.

It’s only 10 weeks – you can do it!

OSU eCampus CS271 Computer Architecture and Assembly Language review & recap

This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.

Six-word summary: Where my 4.0 GPA went to die

CS271 is a pedantic deep-dive into your computer’s inner workings and an opportunity to enjoy coding in a highly restrictive language. There’s special emphasis on going step-by-step through the stack frame and understanding what’s in every register and even some much-appreciated training on “what order to do things in” when building a program.

CS271 Review

CS271 often felt like it was made of two distinct halves that ran in parallel: the first half is made up of the cute little MASM programs you write for the homework that’s due every other week. The other half is the mountains of computer architecture trivia and methods for calculating various things you learn for the bi-weekly exams, such as binary/hex conversions, Hamming codes, memory usage, optimization, recursive output, stack frame changes, the step-by-step changes in registers as a program runs or steps through a loop, and so on.

The class is very well organized. They tell you precisely what to do for the homework and what the output should look like, line by line. Unlike many classes in OSU’s CS program thus far, you won’t need to do a ton of Googling to learn the material – the lectures and the book reading are actually adequate preparation for most of the class’s homework and quiz questions. The workload is consistent. Each week follows the same pattern, and the homework’s complexity ramps up slowly.

However, the homework (in which you write some Assembly language code) is rather light and may give you a false sense of security come quiz and exam time. The true heavy hitters in this class are the self-checks you do after the lectures, the weekly exercises, and the bi-weekly quizzes. Mastering the material found in all of these is essential for surviving the midterm and the final.

Whether 271’s material is interesting is going to depend on your own likes and dislikes. I thought most of it was squarely in the “hey, that’s neat” category, but I thought it focused too much over low-level details that (probably) won’t directly enhance my career in software. (And that’s just like, my opinion, man – I’m sure some people who take 271 find their calling and never resurface from the depths of CPU architecture, binary math, hex addresses, and bit ordering.)

Class structure

  • 10 weeks
  • Multiple briskly-paced weekly lectures
  • An ungraded/untimed “self-check” exercise worksheet for every single lecture – you should actually do these, the quizzes and exams pull from them
  • A weekly exercise quiz with a 6 hour time limit – you get two attempts and they keep the best score, but each attempt has a different batch of questions so it is advised to take it twice to see both question banks
  • 4 bi-weekly tests, 1-hour time limit, each worth 2.5% of your final grade
  • 6 Assembly-language coding projects (homework assignments) total – each one gives you two full weeks to work on it, with the grading rubric released at the start of the 2nd week
  • Proctored midterm, proctored final
  • Steady, even workload
  • Less self-teaching than some OSU classes (still quite a bit of rote memorization and practice, though)
  • NO GROUP PROJECTS!

Tips for CS271

This was my first OSU CS class where I couldn’t quite earn a solid A (I got an A-). It certainly wasn’t for lack of effort or time put in – I think I cleared 20 hours of practice most weeks and I worked on this class’s stuff daily.

There’s a ton of material and the tests are very picky – they’re not multiple choice where half the answers are obviously silly, they’re fill-in-the-blank or multiple choice where all the options seem like they could be right. (The tests are also almost half your final grade. Ouch.)

When I look back on what I could’ve done better and what I would advise future students, these are the things that come to mind.

CS271 tip #1: Get the book, it doesn’t suck!

This is one of the books that’s worth buying. It’s approachable with many  examples to follow and, surprisingly, many quiz questions are lifted line-for-line from the book.

See Assembly Language for x86 Processors on Amazon.com

I liked having a physical book because it freed up screen space during quizzes and while working on homework. I found it helpful to read on paper, practice in a notebook, and really work problems over and over until I had the process down cold. (That’s just my personal preference; I seem to retain more if I read and work on paper.)

CS271 tip #2: Make yourself some worksheets and grade yourself

Speaking of rote memorization and brute-force practice, I highly recommend making yourself some worksheets out of the weekly self-checks and bi-weekly quizzes. Print them out and work through them (over and over) until you can do all of them quickly and perfectly.

This technique was time-consuming but it went a long way to cementing the steps to solving all the various types of CS271 problems. As I mentioned earlier, the homework is borderline useless for the exams. The exams draw their questions almost entirely from the weekly self-checks and bi-weekly quizzes.

The exams tend to layer multiple concepts together into one question and they’re autograded, not graded by a potentially generous TA, so your goal for CS271’s tests should be to become very fast at solving every kind of problem you encounter in the practice materials.

CS271 tip #3: Get a binary/hex calculator

The Casio fx-115ES can do math in binary and hex: addition, subtraction, and conversions between binary/hex and back again.

I had no idea this kind of calculator even existed and the course materials make no mention of it. Frustratingly, I only found out about it through the class’s Slack chat. I was doing conversions by hand like a total chump, which would have cost me dearly on the midterm either in terms of time spent or stupid mistakes or both. The hex and binary questions on the exam were made trivial by having this calculator. I don’t know why the syllabus doesn’t open with “GET THIS CALCULATOR”.

As an alternative to the physical calculator, the course lets you use your operating system’s built-in calculator. (I did this course’s work on my PC but I take tests via ProctorU on Macbook since that’s where my webcam is, so I preferred the physical calculator over having to get familiar with multiple OS calculators.)

CS271 tip #4: Pack that cheat sheet to the density of a neutron star

I made mine in Google Docs, which will let you pick a font size as small as 6 (you have to type it in, it’s not in the dropdown).

One side of my CS271 cheat sheet – the back side was all code examples.

I don’t care for exam cheat sheets. I think allowing cheat sheets drives students to put their efforts into guessing what details should be on the sheet, which sets the student up for an inevitable wave of frustration and disappointment when they realize 2 seconds into the exam that they guessed wrong. Letting students bring a cheat sheet seems to inspire instructors feel free to ask all kinds of minutia-focused questions instead of testing for a more general understanding of the concepts.

But… nobody asked my opinion, and I doubt the cheat sheets are going away any time soon, so my advice here is to pack your sheet as full as you can get it. I think a good cheat sheet for CS271’s midterm and final would be at least 50% code examples, which is what the back side of my sheet was full of.

CS271 tip #5: The extra credit on the homework was generally a waste of time for me

I tried to do the extra credit (of which there are 1-3 points up for grabs on every bi-weekly assignment), but for the most part I found the extra credit opportunities frustrating and almost as time-consuming as the rest of the assignment itself. Your mileage may vary, but I should’ve spent the time on worksheet drills instead.

CS271 tip #6: If I could do one thing differently…

I’d spend more time studying all the nuances of what happens in the system stack while a program runs a loop. Here’s me practicing on a whiteboard, but despite all this preparation I still think this is where I lost points on the exam. I was probably off by 4 on some memory address or miscounted loops somewhere.

And that’s it for CS271! I’m glad I’m done with it; I’ve heard it’s one of the tougher courses and for me, that was definitely true. I worked very hard in this class and I advise all future students to do the same. The tests are no joke and your ability to track and manage tiny details will be tested like never before.

Next up: CS290 – Web Development. See you all next quarter!

Fixing WordPress site’s low mobile score in Google’s PageInsights with W3 Total Cache

In this article: Steps I took to optimize a WordPress-based site for Google’s upcoming mobile search prioritization. It started with a PageSpeed Insights score of 8/100 and ended at 62/100.

Plugins used: W3 Total Cache

Time spent: Several hours of trial and error, but this guide should help you through it much quicker.

Google announced in January that they’re going to take a site’s mobile speed into account for searches beginning July 2018. I’ve always tried to make my WordPress sites mobile-friendly, but it looks like there’s some room for improvement.

One of my biggest (and highest-earning) sites scored just an 8 out of 100 for mobile optimization. Ouch.

(You can test your own site here: https://developers.google.com/speed/pagespeed/insights/ )

What I’ve already done to optimize this WordPress site

I’ve managed this site for a few years and have already put some effort into optimizing it for search and mobile.

The site already scores well for these categories:

  • Avoid landing page redirects
  • Enable compression
  • Minify CSS
  • Minify HTML
  • Minify JavaScript
  • Optimize images
  • Prioritize visible content

Some of those scores are probably due to the site already using a CDN, lazy loading, a good caching plugin, and a good hosting plan. Here’s what the site uses:

However, there’s more work to be done! Here’s what I did to raise my Google Insights mobile score.

Fixing render-blocking JavaScript on above-the-fold content on a WordPress site using W3 Total Cache and a CDN

Let’s look at this render-blocking JS/CSS problem first:

Eliminate render-blocking JavaScript and CSS in above-the-fold content. 

Your page has 8 blocking script resources and 12 blocking CSS resources. This causes a delay in rendering your page.

None of the above-the-fold content on your page could be rendered without waiting for the following resources to load. Try to defer or asynchronosly load blocking resources, or inline the critical portions of those resources directly in the HTML.

This message is followed by a list of all the JS and CSS scripts causing the render blocking, which were 8 JavaScript files and 3 CSS files in my site’s case.

These guides were helpful to me while working on this problem:

To fix the blocking JavaScript files I had to do a number of things to configure W3 Total Cache. This part took a couple hours of trial and error and some steps were not covered in the guides I used (or my situation was different from theirs), so I’ve attempted to document the process as I experienced it in this guide.

First, I enabled Minify in the general W3 Total Cache settings. Go to Performance > General Settings > Minify > check the “Enable” box and select the “Manual” radio button.

Next, go to Performance > Minify to work on minify settings as they pertain to JavaScript and CSS. You’ll need the list of blocking files from PageSpeed Insights report. 

Watch out! The file paths shown in the PageSpeed Insights results might be truncated. To get the full path, you have to hover over the truncated path and copy the path from the tool tip

In other words, make sure you are copying a complete path:

https://your-cdn.netdna-ssl.com/wp-includes/js/jquery/jquery.js?ver=1.12.4

and not a path with … in it:

https://your-cdn.netdna-ssl.com/-includes/js/jquery/jquery.js?ver=1.12.4

In Performance > Minify there are a variety of options that apply to all the script in a particular area (before head, after body begins, before end of body). In my case, code in the head tag was already minified, so I set it to “Combine only” (rather than re-minify it). I also needed to keep it blocking, or else my page filled Chrome’s console with “can’t find JQuery!” errors.

Next, under JS file management, add all of the blocking files from the PageSpeed Insights results – be sure to get the full file path, not the truncated version.

Also! If you’re using a CDN, you’ll have to change the domain in the file paths that you paste. 

Instead of this:

https://your-cdn.com/wp-includes/etc

You need to use your website’s actual domain. For each path you paste, change the CDN part to be your site’s domain instead, like this:

https://yourwebsitesrealdomain.com/wp-includes/etc

Or you can remove that part of the url entirely and go with something like:

/wp-includes/etc

…which is what I did for mine:

Note: I needed to set the jquery files to embed in <head> to avoid a slew of console errors when visiting the site. As per the earlier settings, anything embedded in head is going to be blocking. I think some blocking files might be inevitable; the point of these settings is to tease out which files belong where in the load sequence.

Save settings and purge all caches, then test again in PageSpeed Insights.

Woohoo – no JS files blocking loading. I also tested the site manually, and verified that it doesn’t look like garbage and doesn’t fill the console with errors. So far, so good.

Fixing render-blocking CSS with Autoptimize

I initially set up all the CSS file paths in W3 Total Cache but ran into these two cases that I couldn’t figure out how deal with through W3 Total Cache alone:

One blocking css file is from w3tc itself:

https://mywebsite.com/?w3tc_minify=6951f.default.include.89e358.css

And another is from Google Fonts:

https://fonts.googleapis.com/css?family=Open+Sans%3A300%2C400%2C600%2C700%7CMuli%3A300%2C300italic%2C400%2C400italic%2C600%2C600italic%2C700%2C700italic%2C900%2C900italic%7CPlayfair+Display%3A400%2C400italic%2C700%2C700italic&subset=latin%2Clatin-ext

To fix the Google Fonts, I installed the very lightweight plugin Autoptimize and checked these boxes:

I also used Autoptimize to disable Google Fonts. Whether you want to do this is up to you, but I went ahead with it because I am happy with a default system font for this site.

To fix the w3tc minify, I disabled CSS in W3TC and let Autoptimize handle it. I also had to uncheck this setting:

Finally, for the sake of completeness, here’s what my HTML minify settings look like:

At this point, I loaded my site and found it was using serif typefaces on buttons and it wasn’t scaling the hero (header) image correctly. To fix this, I added custom CSS to Autoptimize’s custom CSS section. This CSS gets loaded right away, so the page doesn’t get stuck waiting on the js or css to “fix” certain issues that are visible right away to a visitor.

.button {
   font-family: "Open Sans", sans-serif !important;
}

.header-homepage {
   padding-top: 120px !important;
}

One more thing: I also uploaded a significantly more compressed “hero” banner image jpg to the site (old size: about 350kb, new size: about 110kb).

The reward for all these optimizations:

Note that I still have one render-blocking w3tc js file. For now, I’m going to call this “good enough”, since I don’t know how to fix this last one without breaking some fundamental aspect of the site, so I’m going to move onto the expiry problems and see if I can get the score higher that way.

Fixing “leverage browser caching” with W3 Total Cache

PageSpeed Insights found a few files it thinks could leverage browser caching. These files are all .js files.

I found this guide helpful and accurate at the time of this writing: Leverage Browser Caching with W3 Total Cache

The first step is to enable browser caching in W3 Total Cache’s settings. Go to Performance > General Settings and make sure Browser Cache is enabled.

Then, go to the actual Browser Cache section of the plugin. As per the guide, I ensured these boxes were checked:

  • Set expires header
  • Set cache control header
  • Set entity tag (eTag)
  • Set W3 Total Cache Header – this one was not already checked for me
  • Enable HTTP (gzip) compression

(I re-ran the PageSpeed Insights test at this time just in case that one checkbox was all it took. Alas, there was no change in the results.)

The next thing I did was scroll down a little bit to the CSS & JS section. My “expires header lifetime” was set to 172800, which is way less than the recommended 604800 (2 weeks) the guide recommends. I saved that change, cleared cache, and ran the test again.

Now I have just three files with unsuitable caching times:

Alas, two of the remaining files are out of my hands: they are Google Analytics’s own .js files. After reading this guide to browser caching Google Analytics, I decided not to try to cache the analytics js file myself. Doing so would require manually updating it periodically. Even the guide’s author says they don’t recommend this method. That’s fine by me.

But how about this emoji js file? I don’t use emojis on my site, so I wouldn’t mind removing them and reaping a small page speed boost.

Normally, removing them is as simple as adding these two lines in your site’s functions.php:

remove_action( 'wp_head', 'print_emoji_detection_script', 7 );

remove_action( 'wp_print_styles', 'print_emoji_styles' );

But I’m using a pro theme that gets automatic updates (which will clobber this code if I add it to functions.php), and I don’t want to make a child theme for the express purpose of removing emojis.

So, I did what any good WP user does and installed yet another plugin: Disable Emojis. (Yes, I also canceled Christmas and summer break while I was heartlessly removing emojis from my very srs blog.)

I ran PageSpeed Insights again and….

Woohoo! (It initially came out worse, but network latency has some affect on the score, too. I tried again and got a 62/100).

My report has never looked better:

PSI estimates this page requires 2 render-blocking round trips and ~26 resources (0.4MB) to load. The median page requires 4 render-blocking round trips and ~75 resources (1MB) to load. Fewer round trips and bytes results in faster pages.

Fixing the “flash of unstyled content”

A new problem has been introduced by all this work: now my page looks unstyled for half a second or so while it’s loading.

I used this tool: Critical Path CSS to identify a the “minimum” CSS needed to make the “above the fold” content look good (it’s a huge block, I’m sure a human could produce something more elegant but for now, it’ll do).

I put this CSS into Autoptimize’s “above the fold” CSS section and the flash of unstyled content seems to look better now, though I still see the fonts looking bad before the preferred “open sans” style comes into effect.

Done… for now

At this point, I’ve gotta call it good enough for now. My site’s score went from 8/100 to about 62/100. I still have a one blocking JS file that I don’t know what to do with and two files from Google Analytics with unsuitable cache expiration times.

I’ll update this page when I make further improvements to the site.

How to convert a 4-byte hexadecimal sequence in a little-endian architecture into decimal

Here is my technique for solving the problem of converting a 4-byte hexadecimal sequence in a little-endian architecture into decimal.

This may seem rather niche but it was a surprisingly large part of Week 5 in my CS271 class. The class’s materials and extra help I found around the web seemed to go off on tangents that were interesting but unrelated to solving this kind of problem quickly, and all I really wanted was a simple step-by-step guide I could use on exams.

Therefore, I am sharing my simple 5-step technique for converting hex to decimal in a little-endian architecture here! Hope someone else finds it helpful.

Example problem:

The four-byte sequence 0x86 0x65 0x53 0x82 stored in consecutive memory cells in a little-endian architecture represents ___________ (decimal) when interpreted as a 32-bit signed integer.

From reading this, we know: 

  • it’s little-endian, so we are going to reverse the order of the bits
  • our result will be signed

Step 1: Reverse the bytes

Take the bits in blocks of two and work right to left.

0x86 0x65 0x53 0x82 becomes 0x82536586

Step 2: Look at the most significant bit and determine if there will be a negative result

0x82536586   <-- that's this dude in red here

The most significant bit here contains an 8.

We know that in hex a most-significant bit of 7 or more means we are looking at a negative number. (If this were a positive number, ie: the most significant bit is between 0 and 6 inclusive, then skip ahead to Step 4.)

Step 3: Since we are working with a negative number, flip the bits (subtract our hex sequence from FFFFFFFF) and add 1

  FFFFFFFF
- 82536586
  7DAC9A79

Add one to the result:

7DAC9A79
      +1
7DAC9A7A

The result is the hex sequence we will use for the next step.

7DAC9A7A

Step 4: Multiply each term by 16 raised to a power

To convert a hex value into a decimal value, we multiply each “position” in the hex sequence by 16 raised to a power. Working from right to left, we know that furthest-right position is 16^0 (so, just a 1). The second-from-right position is 16^1 (so, just a 16). The third-from-right position is 16^2, and so on.

Recall that A = 10, B = 11, C = 12, D = 13, E = 14, and F = 15 when working in hex.

(7*16^7)+(D*16^6)+(A*16^5)+(C*16^4)+(9*16^3)+(A*16^2)+(7*16^1)+A

The result of this long sequence is:

2108463738

Remember that negative sign? Now’s a good time to stick it on.

-2108463738

And there you have it: the result is -2108463738.

Some final notes

  • Be sure to observe whether the problem expects a signed decimal result or an unsigned decimal result. If the problem is asking for unsigned, you can skip the FFFFFFFF subtraction step entirely, even if the most significant bit is 7 or higher.
  • Remember that when working with a signed hexadecimal number, you look at the most significant bit to determine if it’s negative or positive.
    • 0-7 = positive
    • 8-F = negative
  • If you had to do the flipping step, don’t forget to put that negative sign onto your final answer!

OSU eCampus CS325 Analysis of Algorithms review & recap

This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.

Six-word summary: brutally difficult, but it’s over now!

CS325 – it me

In CS325 you’ll study recurrences, asymptotic bounds, probably every major sorting algorithm plus some silly ones, dynamic programming, graph traversal, recursion, linear programs, and more.

CS325 Review

Well, the rumors are true – this class is hard. I’d place it in a tie with CS162 for overall difficulty. But where CS162 tries to kill you with a brutal workload, CS325 tries to kills you with instructional materials that don’t adequately prepare you for the homework or the exams.

The lectures are not sufficient preparation for the homework – you’ll rely on YouTube and Stack Overflow to get through each homework question. The weekly homework assignments are time-consuming and the documents you prepare are long. Mine were anywhere from 5-15 pages of graphs, pseudocode, and written explanations for my work.

If you can take CS325 by itself, you should.

There was a noticeable (and distressing) disconnect between what was on the homework and what was on the exams. I scored 100% on the homework assignments, but failed the midterm. It’s like the homework and exams were from different classes!

A week or so after the midterm was graded it was opened up so students could see which questions they got wrong and dispute wrong answers, if they could prove they had it right. I thought for sure I’d prove the TAs wrong on at least one or two of mine, so I reworked all of my incorrect answers – and reworked and reworked them – until I eventually figured out what subtle thing I missed while taking the test.

I definitely struggled in this class, and for the first time I wondered if I even belonged in this CS program.

Class structure

  • 10 weeks
  • 7 assignments total
  • Group work: weekly graded discussions on Canvas, a 3-person group project the last two weeks of the quarter
  • Proctored midterm (20% of final grade), proctored final (20% of final grade)
  • No homework assignment the week leading into the midterm
  • No homework assignment once the group project at the end begins
  • You can bring a 8.5″ x 11″ sheet of typed notes (size 6 font!) into the midterm and the final with you

Tips for CS325

Take every extra credit opportunity (they’re rarer than you think). There was an extra credit opportunity on the first homework, but there wasn’t another opportunity until the last homework!

Comment early, often, and be helpful in the Canvas discussions. There’s an opportunity for 1 point of extra credit in each of these weekly discussions. I was able to earn it most weeks by doing all of the following:

  • As soon as the discussion thread was available, I “structured” the discussion by creating a series of replies, one for each homework question. In each reply, I posted the contents of the homework question for easy reference. This gave each homework question its own thread for my group mates to use.
  • When I figured something out on the homework, I posted pseudocode or a “how I approached this problem” guide to the Canvas discussion to help others. I spent easily 1-4 hours on creating this type of “tutorial”, every single week.
  • I started the homework right away. On Sunday I did the lectures, on Monday I did question 1, Tuesday I did question 2, etc. By midweek, I had half the homework done and was able to assist with answering questions from group members just starting theirs.

This was a ton of extra work. I see why people blew off the Canvas discussions. But the discussions did two key things for me:

  1. It helped my understanding of the various topics to revisit them and “teach” them to others
  2. The extra credit helped me squeak by with a 92.58% in this class, which got rounded up to a 93% (the cutoff for an A). I needed every. single. point. I could get.

Study recursion – put it on your exam sheet! A lot of the class’s materials (lectures, book reading, and homework) will “gloss over” recursive solutions to problems. They’ll be like, “this is the slow way to do it with recursion, now here’s the better way to do it with <the technique of the week>”.

You might be tricked into thinking the exam will want you to know the fancy technique – you’d be wrong. The midterm will expect you to produce the recursive solutions, which you won’t code for the homework or even look at past the few minutes they get in each lecture. I thought this was unfair of the class, so that’s my tip to future CS325 students: study the recursive solutions. Put them on your “cheat sheet”. Know them inside and out!

The extra credit competition among the final project groups is a poorly-designed zero-sum game that you have almost no chance of winning. Here’s how it works: 60+ groups implement algorithm(s) to solve a given problem in as little time as possible, then post their best running times to a Canvas thread. The assignment won’t tell you what “good” times look like – you’ll figure that out by looking at results that trickle in from the other groups. The winner is whichever group (or groups) has the best performance times in the two different categories.

I think this competition could be made better by awarding extra credit to any (and all) groups that can pass a certain benchmark, since that’s hard enough on its own. My group picked difficult-to-implement but highly performant algorithms and did our work in C++ and we still lost to multiple other groups by a little bit. Unless you’re super dying for that extra credit, I think the winning move here is not to play. Take the time you’d spend optimizing your final project towards an unknown goal and spend it studying for the final instead.

The book sucks. (This is the book.) Okay, maybe the book doesn’t suck, but it doesn’t map nicely to the class material and it won’t walk you through how to solve the kinds of problems you’ll face in the homework. I think the teacher requires this book just for the sake of requiring a book.

You’ll need the power of Google (and YouTube and Stack Overflow) to uncover how-to’s and guides for actually solving problems. I still did the readings every week, just in case something useful turned up, but the book is more like an introduction to the topic, not a guide. I relied almost 100% on external resources to actually learn this class’s material.

There are better videos and walk-throughs for every topic this class covers on YouTube and people’s blogs. Seek them out! There are people who recorded themselves going step by step through real problems pertaining to topics like recurrences and dynamic programming in ways the class-provided lecture videos do not. I owe my A in this class to the generous people of YouTube who took the time to demonstrate these difficult topics.

More than any other class before it, CS325 requires self-teaching and finding help on your own. Whether that experience is worth $1900 is left as an exercise to the reader – there is, of course, the argument that self-teaching is what you’ll do on the job so you might as well get used to it, but there’s also the argument that $1900 ought to buy you at least a little bit of hand-holding.

I’ll be in two classes next quarter: CS271 (Assembly and Architecture) and CS361 (Software Engineering I), so say hi if you’re in either of those with me!

Fix: Font Awesome icons missing with Mesmerize PRO theme and MaxCDN

In this post: missing Font Awesome icons due to missing CDN configuration.

I have a WordPress blog that uses MaxCDN, W3 Total Cache, and the Mesmerize PRO theme by Extend Themes which includes Font Awesome icons.

After installing and activating the theme on my website the Font Awesome icons appeared as boxes:

Missing icon looks like a box
Another missing font awesome icon
Another missing font awesome icon

And I could see these (canceled) errors in the Network tab:

Errors in the Chrome Network tab. fontawesome-webfont status is canceled.
Errors in the Chrome Network tab. fontawesome-webfont status is canceled.

The referrer is

https://cdn1-mycompany.netdna-ssl.com/wp-content/themes/mesmerize-pro/assets/font-awesome/font-awesome.min.css?ver=1.0.221

That referrer, cdn1-mycompany.netdna-ssl.com, isn’t allowed to serve this file. But there’s an easy fix: you can whitelist the CDN itself in the CDN.

The fix: whitelist the CDN itself

In MaxCDN, go to Pull Zones > Security > Whitelist.

You might already have yourdomain.com in here. What you need to add is the domain your CDN files are pulled from.

MAXCDN settings: Pull Zone tab, Security tab, whitelist tab, add cdn1-domain.netdna-ssl.com to whitelist

In my case, that was a domain that took the form of cdn1-mydomain.netdna-ssl.com, but you can find out what yours is by looking in the Network tab while you try to load your site. Look for a red-colored error message and open the Headers.

Anyway, the fix is as easy as adding the domain to this list of whitelisted domains and waiting a few minutes (for me it was about 10 minutes). Reload your website and the Font Awesome icons should now appear.

Note: You will probably need to Purge All Caches, too, once the time has passed to actually see the change in your browser (I use the dropdown in the WP toolbar).

WordPress toolbar with W3 Total Cache Performance section rolled out, Purge All Caches selected

My W3 Total Cache settings

(Just in case it’s useful to someone else trying to debug this problem)

My W3 Total Cache settings are set to upload .css, .tff, .otf, .woff, and .woff2 files.

W3 Total Cache settings for which theme files to upload by extension. css, js, gif, tff, otf, woff, woff2, etc.

Provided again as text so you can copy/paste.

wp-includes file types to upload:

*.css;*.js;*.gif;*.png;*.jpg;*.xml

Theme file types to upload:

*.css;*.js;*.gif;*.png;*.jpg;*.ico;*.tff;*.otf;*.woff;*.woff2

This is a pretty specific configuration issue but hopefully it’ll help someone else out there!

I made an AngularJS web app! Check out the OSU CS Course Explorer

Browse 300+ candid student reviews and helpful tips for OSU’s online CS degree courses

Check it out: https://osu-cs-course-explorer.com/

What it does: Aggregates real student course reviews from the OSUOnlineCS subreddit survey, which dumps data into this spreadsheet, and displays that same data in an easier-to-navigate format.

Who it’s for: OSU CS Ecampus students

Technologies used:

The rest of this post is about the app itself (not its code). If you’re hoping for some code walkthroughs, stay tuned – I’ll be writing a few in the next month or two before I move onto my next side project.

App inspiration

I started OSU’s online CS degree program Fall 2016, and I am so grateful for the opportunity the school has given me to receive a formal CS education.

Ever since I applied to the program I’ve been an avid reader of the OSU CS subreddit. I was always looking for info on my next class – survival tips, strategies, what to study, etc. The course survey (linked in the sidebar) contains years of useful student data but at 300+ entries, it was becoming difficult to browse or parse on a macro level (ie: there was no way to look at it and determine how time-consuming on average a particular class might be).

I had the idea for a simple web app that would take the Google spreadsheet data and reorganize it by course, listing all the tips (with timestamps) and aggregating the time spent and difficulty data into a couple of easy-to-read pie charts. I knew other people would find this useful, too, so I planned to make it publicly and freely available once it was presentable. (From this experience I also wanted a finished, portfolio-worthy app that I might show to a potential employer.)

I started the project in the summer of 2017, worked on it bit by bit whenever I wasn’t swamped with classwork (or my full-time job, or my baby who was 9-13 months old while I worked on this, or the cross-country move I did in August). It’s definitely a testament of what you can build even if you don’t have loads of contiguous free time, as long as you are consistent and keep going.

Browse the code

If you want to browse the app’s progress (and see some of the mistakes I made along the way) you can browse the GitHub repo for it here. I tried to leave concise comments explaining what I was doing, in hopes that other students and beginning web devs would find it helpful.

I plan to write a few blog posts dedicated to different sections of the app’s code. I love “here’s an app I built and how I built it” type posts myself and owe a lot of my own knowledge to them, so I’ll try to give back a few contributions of my own.

Why I chose AngularJS

I know everyone’s got the hots for React these days but I had just come off of 2 years of working in Ember and wanted to return to my ancestral headwaters for a bit and build something in the framework I got my start in. I wanted to see if all my “I liked how that worked in Angular better” feelings towards Ember were actually accurate or just some rose-colored tinting of history (as it turns out, I really do prefer Angular to Ember :P)

I don’t know if I’d pick it again, though. The world has largely moved on from AngularJS (to Angular 2 and beyond, and React), but there’s still a ton of helpful blog posts and Stack Overflow questions about every imaginable Angular topic (way more than Ember has, that’s for sure) so for that reason, I think it’s still a good, established choice if you’re new to web development frameworks and want to try something.

Thanks to contributors

Special thanks goes to Yong Joseph Bakos for his pull requests after the project launched – cleaning up some cruft in the codebase, improving tests, documentation, etc.

Special thanks also goes to Jonathan Burley for helping unstick me at some critical points in development, like when I needed help customizing the canvas legends in a way that wasn’t documented and when Heroku was being a pain.

I feel like I always learn so much from even the briefest encounters with other developers, so I am grateful for the help I received along the way.

OSU eCampus CS261 Data Structures review & recap

This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.

Six-word summary: Loads of implementations, light on context.

Heaps, AVL trees, hash tables, and a whole bunch of ways to sort data – you’ll do it all in CS261, but you might finish the course wondering why.

CS261 Review

This class is all about data structures. Some colleges combine data structures and algorithms into one semester-long class, so I’m happy that Data Structures got its own dedicated 10 weeks in OSU’s program.

Some of your new friends in CS261

Class structure

  • 10 weeks
  • 6 assignments total, evenly distributed through the quarter
  • Proctored midterm, proctored final
  • Nice slow-down in assignments and workload as midterm and final approach, giving sufficient time to study
  • Weekly group obligation: 2-5 worksheets to submit as a group (however you divvy it up is up to you) and typed weekly meeting minutes
  • Steady, even workload

The first 4 weeks will revisit topics from CS162, so if you wanted more practice reversing a linked list or resizing an array, you’ll get to do those things again in CS261.

After the midterm, the class spends 1 week on each topic: AVL trees (including tree sort), min heaps (including heap sort), hash tables (open addressing and chaining), and graphs (including Dijkstra’s). Big-O complexity is also covered in the context of the aforementioned subjects.

The video lectures are decent but to truly understand these topics I recommend searching the Interwebs for additional resources. These are big topics and there are many excellent explanations, diagrams, walkthroughs, etc. available on YouTube. (This is just one of them.)

The workload is consistent and gets lighter before the midterm and final, which left plenty of time to dedicate to studying for the exams.

CS261 books: the one they tell you to get, and the one you SHOULD get

I love a good book. The books we used for CS161, CS162, and CS225 were excellent. I did not love the lack of a book in CS261.

Instead of a book, CS261 provides pdfs to read every week. They are dry, boring, and do not display well on a mobile device. There are also worksheets that open with several paragraphs of reading. These are also dry, boring, and do not display well on a mobile device.

For some reason, this is the recommended (but optional) book for CS261: C Programming Language. It’s an okay book, but it’s almost completely beside the point of the class. It’s a reference to the C language. I don’t know why they recommend it – none of the class material relates back to it. If you’ve taken CS161/CS162/CS165, you know enough C++ to hobble along in C until you get your footing. If you run into any trouble (and you probably won’t past the second week or so) you’ll Google your error message, figure it out, and be on your way.

Then, at the end of fall quarter, I joined the CS325 Slack channel in preparation for my Winter 2018 quarter. There, I saw someone recommending the book Grokking Algorithms to incoming CS325 students.

THIS is the book you should buy for CS261.

I ordered it to get a jump start on CS325, but when I opened it my heart sank a bit: where the F*** was this book when I was still in CS261?! 

Every section of this book is concise and clear, with simple explanations and memorable illustrations. Most topics get multiple explanations and diagrams. The book covers so many topics and I’m just kicking myself for not having this book while I was still in CS261.

Grokking Algorithms has everything from visualizing Big-O runtimes…

to performing a search on a graph…

to adding neighbors as you traverse nodes on a graph…

to sorts, complete with graphs, Big-O complexities, and pseudocode…

to understanding how the stack can be used to perform a set of instructions recursively.

This is just a small sampling of what’s in this amazing book.

I wish someone had told me about this book before I waded through CS261’s long, tedious PDFs on these subjects (which often felt like they were written for people who already understood the topic).

Do yourself a favor. If you are about to take CS261, get this book and refer to it often. It is way better than the materials they provide you in the class.

CS261 uses C, not C++

I’m pointing this out because I see a lot of questions (and complaints) about the switch to C from C++ in CS261. It’s true: unlike CS161 and CS162, CS261 assignments use the C language. HOWEVER – it’s really not a big deal. Any panicky feelings you may have over this at the start of the course will soon pass.

Instead of this:

for (int i = 0; ...)

you’ll do this:

int i;
for (i = 0; ... )

And you’ll write comments like this:

/* comment goodies here */

Little things. Nothing you can’t solve with a quick Google query and by the 2nd or 3rd week you’ll probably forget you even went through this.

They ask you to use an IDE… but you don’t need to

This surprised me: CS261’s first week includes an assignment in which you bring your code into an IDE and then submit a screenshot to show you did it.

As far as I could tell, there’s no reason to keep using the IDE past week 1. You don’t have to choose a particular IDE (or an IDE at all) for the sake of CS261. The class doesn’t teach you how to use the features that make an IDE worth using, like using the IDE’s debugger to step through code.

I tried CodeBlocks for a week, but it crashed so often it was a serious roadblock to productivity until I dumped it and went back to Sublime Text. (I’m on a Mac and the last release of CodeBlocks is from 2013 – maybe that was part of the problem.) 

An IDE is just a tool, and I feel like which IDE you choose is a personal choice and none of the school’s business unless the class is going to teach specific features of that IDE or provide workflow tools that only work with the IDE, which CS261 does not. There’s no reason you should have to abandon whatever tools you’re already comfortable with. This was a strange requirement, in my opinion.

CS261 assignments

The 6 assignments are like “coding madlibs” – they provide you with a collection of files and you fill in the functions that are missing code. The assignments offer little opportunity for creativity, which probably makes grading them easier but also made them more forgettable.

The real shortcoming with the assignments was the missed opportunity to tie the data structures and sorts to real world applications. The greater context of why you might choose a particular data structure or how to analyze a problem and then decide what data structure or sorting algorithm to use is, sadly, largely absent in this class’s materials.

I felt like the “fill in the blank” nature of the assignments didn’t help my brain make links between Real Life Problems and All That Code I Wrote in a Vacuum for CS261.

Here’s a ton of code I wrote. What’s it for? Getting a good grade in CS261, of course.

This “missing context” was further illustrated to me when I told a friend about the class I was taking, and he posed a question:

"Suppose you have a million images. Filenames/filesize/etc. don't matter, just the content of the image. I give you a new image and you have to tell me if you already have this image in your set. How do you figure it out? What data structures do you use?" 

                                                   - my smart friend

CS261 isn’t going to prepare you for this kind of question.

The solution – and surely there’s more than one – to my friend’s question was basically to hash all the image blobs into a hash table, then hash the new image to figure out where it would go and compare it to what’s in the table. You don’t hash on filename or filesize or anything like that, because with image hashing, you want to go by the content of the pictures themselves.

I include this example not to point out what a dunce I am – I already know that – but to illustrate a missed opportunity in CS261 to tie the course material to real life applications. Here’s some more reading on the image hashing question, if you’re curious.

CS261 group work

The weekly group work is going to be either great or a chore depending on who you get grouped with.

In the first week of the quarter everyone was assigned to a group of 5, with the sorting criteria being our time zones and general availability as noted in a spreadsheet that the instructor shared the week before class started (hope you were checking your email!).

For 10 weeks, my group was responsible for submitting 2-5 completed “worksheets” each week by end of day Sunday and a typed log of our discussion, called “meeting minutes” (basically who said what). I use the term “worksheet” loosely, some of them were solidly in “assignment” territory.

In a perfect world, your group will engage in vigorous, insightful discussion on each worksheet, leading to new insights and reinforced learning. (Some of my classmates assured me this is what they were getting out of their CS261 group experience.)

In the actual world, your group will probably struggle to find a meeting time that works for everyone and cope with weekly absences from the group meeting. Our “discussions” were rather thin – we either agreed the worksheet was easy or hard, and then kind of struggled to find anything else to talk about.

I don’t blame my groupmates, I think the worksheets just didn’t lend themselves well to discussion. There wasn’t anything controversial or debatable about the worksheet problems, just cut and dry “fill in the blank” code.

CS261 exams

The midterm and final exams for CS261 proctored, so you’ll have to go to a nearby test center or get set up with an online proctor. Both exams are 1 hour, 50 minutes long.

The midterm is coding heavy – expect to write methods in Word docs, save out a pdf for each problem, and attach them to the test. Many questions require you to download an image or attachment from the test, open it, and answer the question in the test’s text box. This was a clunky workflow and I was constantly afraid I would accidentally navigate away from the test. The final exam, however, only required one external doc to be produced and attached, and only a couple questions required opening an attachment. (Phew.)

As for what to study: study trivia. There’s a ton of trivia sprinkled throughout this course. You’ll want to memorize the runtime complexity of every sort, when to use what data structure (according to the class materials), properties of each data structure, and so on. A lot of that trivia will show up on the test. I found it helpful to make notecards of little tidbits of info that are sprinkled throughout the lectures and reading materials – they helped, but I was still caught off-guard by some of the questions.

My CS261 flash cards and worksheet organizer were invaluable.

A few final tips for CS261

Do all the worksheets yourself, even if your group comes up with some kind of “worksheet rotation”. By the time this class was done I think I’d done every worksheet at least 2 or 3 times, because they’re good practice for the tests.

Use a visualization tool. This is the one I used – it’s not perfect (I wish it showed individual steps for things like AVL rotations) but it’ll help you check your work.

Print all the worksheets. I didn’t have a printer going into this class but I quickly saw the need for one. Most worksheets provide you with function signatures and helper methods, and your job is to “fill in the blank”. Therefore, I felt it was better to have the worksheet printed in front of me so I could fill in the blanks, rather than working in an editor (or worse, a word processing doc), separated from the rest of the worksheet.

Some of my CS261 final exam prep: I redid the weekly worksheets until I had them down cold, and I printed the questions from the practice final.

Practice on paper, and get fast. The tests are, collectively, over half your grade in this class, so your performance on the exams really matters. I felt pressed for time on both exams, finishing within 5 minutes of the time limit both times. I’ve never really been one to study for tests, figuring I should’ve learned the material during the class itself, but I had to buckle down and get serious about studying for CS261. I made flash cards, practice tests, and put probably 20 hours into studying for the midterm and over 50 into studying for the final.

Knowing the code (implementations) is important, but the final exam (which is 30% of the final grade) focuses more on knowing the step-by-step behavior of altering a particular data structure. Be sure you know how to draw specific kinds of trees and how they change when a node is removed.

Join the Slack channel! Lots of my classmates could be found there every week discussing the homework and answering each others’ questions.

Get the Grokking Algorithms book. Seriously, and while you’re at it, invent a time machine and tell me about this book before I take CS261.

And… that’s it for this quarter! I’ll be in CS325 Analysis of Algorithms next quarter (Winter 2018), so be sure to say hi if you see me (Mandi) on Piazza or Slack!

Reports from other students in the program

Are you also blogging about your journey through OSU’s eCampus CS program? Leave me a comment and I’ll add a link here!

Fixed: Missing images (403) when sharing WordPress posts on Twitter and Facebook

One of my WordPress-based sites uses this particular combination of plugins and utilities:

  • WordPress version 4.8.2
  • W3 Total Cache
  • MaxCDN

And this was the disappointing, image-less result I got whenever I shared one of its posts on Twitter:

Twitter/Facebook missing image debugging tools

Here are two tools I used while debugging my missing images problems on social media.

Rather than spam your friends or pollute your feed with tests, you can use Twitter’s own validator and Facebook’s sharing debugger to try your posts and see how they render.

Twitter: https://cards-dev.twitter.com/validator

Facebook: https://developers.facebook.com/tools/debug/sharing/ (you may need to hit the “Scrape again” button in between tries)

The Twitter/Facebook 403 fix

There were two problems with my site:

Problem 1: My site’s posts didn’t define any Open Graph images in the first place. I figured Twitter, Facebook, etc. were smart enough to scrape the post and pick an image all on their own, but it seems that’s not always the case.

To explicitly declare a social media image for each post, I installed the “Facebook Open Graph, Google+, and Twitter Card Tags” WordPress plugin.

Now, at the bottom of every post, is the option to explicitly define an image to use when sharing. This image can be larger than images you might normally include in a post (maybe even custom-made for the purpose) and need not appear in the post itself. (Unfortunately, you do have to go back and manually add an image to each post.)

After doing this I was still getting a 403 when previewing my post in the Facebook and Twitter tools.

Problem 2: The other part of the problem was with my CDN settings themselves. Twitter (and Facebook, etc.) aren’t actually allowed to link to images hosted on my CDN – they aren’t whitelisted. My CDN is set up to only serve images on my site itself, so other people can’t link directly to my CDN images and effectively steal the bandwidth that I pay for (truthfully, I wish people were this eager to link to my content).

I had to add Facebook and Twitter to my W3 Total Cache’s list of rejected user agents.

Under the Performance tab (left side of WordPress interface), click on CDN:

Then scroll down into the Advanced section and find “Rejected user agents”. Type facebook.com and twitter.com. These agents are not allowed to access files hosted within the CDN. (Which is what we want, because the CDN won’t let them do it anyway.)

You may need to also do Performance > Purge All Caches from the top toolbar in WordPress, too.

Finally, the Twitter and Facebook previews have images!

OSU eCampus CS225 Discrete Structures in Computer Science review & recap

This post is part of an ongoing series recapping my experience in Oregon State University’s eCampus (online) post-baccalaureate Computer Science degree program. You can learn more about the program here.

Six-word summary: Not as bad as I feared

Here’s the deal: OSU’s eCampus CS degree only requires one math class. A lot of people dread it, though, because it’s their first math class in years (or decades).

However, I am happy to report that CS225 is completely doable by someone who isn’t a natural at math. You would be hard-pressed to find someone with less of a math background than me, and yet, I managed a 94% in CS225!

Behold, my math “credentials”:

  • I had to take algebra twice (in 8th grade, then again in 9th)
  • I only earned a B in sophomore year geometry despite really trying
  • My last high school math class was Algebra II (another B)… not pre-calc, not calc, not physics, nothing past Algebra II
  • My only college math class (and I do mean only) was Math 118, and it was the sort of math class you take when you are pursuing a fine arts degree
  • I got a single digit score on my ALEKS assessment at the start of OSU’s CS program

Not my strongest subject, by far. But I think there’s plenty of room in programming even for those of us who suck at math, so if this is you, worry not – CS225 won’t derail your dreams.

CS225 Review

This was a good class. The homework problems made sense, the pacing was good, and the test questions were (mostly) recycled from the book, homework, and practice quizzes. The instructor seems to run the whole thing on autopilot but I didn’t need to contact her for anything.

There’s only a handful of homework questions due each week, but potentially dozens more you can do from the book and “last quarter’s homework” if you want. (I did all the extra work, and I think it really paid off at test time.)

Good news: this didn’t happen in CS225!

Class structure:

  • 10 weeks
  • 2 homework assignments per week
  • 1 quiz per week (7 total, no quizzes before/after midterm and none in the final week)
  • 1 midterm around week 6
  • 1 final in week 10

The tricky part about this class is the grade weighting. 90% of the grade is from quizzes and tests. The midterm is worth 30%, the final is worth 30%, and your 6 best-score quizzes are worth 30% (collectively). The homework is a mere 10% of your final grade. Since both the midterm and the final are proctored, you do have to know your stuff inside and out before you sit down to take the exam.

Fortunately, nearly all of the test questions were outright copies of, if not very similar to, questions you would have seen in the homework and practice quizzes.

If there’s anything this class isn’t so good at, it’s the video lectures. (Seems none of these OSU courses so far have decent videos.) On the bright side, YouTube is bursting with math enthusiasts who have made short, memorable videos on every topic this class will cover.

My little CS225 algebra prep guide

Many people ask online what they should study in preparation for CS225. I think the ALEKS modules are complete overkill. I found myself Googling these seemingly basic concepts that I completely forgotten in the 15 years since my last math class:

  • factorials – what does 5! mean?
  • adding fractions – a/b + c/d = ?
  • multiplying fractions – a/b * c/d = ?
  • dividing fractions – (a/b)/(c/d) = ?
  • factoring these things – (2a + 1)(a + 2)

And that’s it. The rest you can pick up in the class itself.

More CS225 tips

Here are my general tips for succeeding in CS225.

Do the extra assignments, too

Every week has the homework that’s required, and then a larger set of extra questions that are just for your own edification. I did those extra problems and found them worthwhile come test time. I also did all the practice quizzes.

Get a Chegg subscription

I never heard of chegg.com before I took this class (I found it through Googling my questions). $15/month gets you unlimited access to the book’s answer key. Not because you’re going to copy the answers and blow off the homework, no – you need to know what you’re working towards on every question you tackle. How else will you know if you got it right? :D

Warning: not every single answer is in Chegg. I think I found maybe 4 of my assigned problems that were just blank in Chegg. But.. chances are if you Google the problem, someone on the math Stack Exchange or their own blog has posted a solution. Or you can solve a different but similar one that does have an answer, and then take a pretty good guess at the one you’ve been assigned.

Get the physical copy of the book

Yes, this is the most expensive book of the entire program, but you can buy it used on Amazon (which is how I got mine, and the book was in great shape).

A physical copy is great. It’s easier to jump around in than a .pdf, you can sticky note various topics, and you can take it with you and study in more places! I also rented a .pdf version of the book, but it didn’t display well on my tablet or my phone.

Study hard for the tests – and attempt every question

The two proctored exams are 60% of your grade (30% is your 6 quizzes, 10% is the weekly homework). Some of the questions are taken word for word from the book or homework.

Here’s a hint: simply attempting an exam question is worth a lot of points. Every exam question is worth 10 points and they’re ‘free form’ (you type in a box, not multiple choice). Even if you can’t (or don’t have time to) solve it, explaining what you would do to solve it can get you 7/10 or more points on the problem. Therefore, the winning-est strategy is to pace yourself such that you have enough time to at least lay out the basics of your answer to every question.

I ran out of time on the midterm and had to slap together half-baked responses to the last three questions. However, since I was able to type out what I would do if I had more time, and still ended up with a 93% on the test. Phew!

I took the class by itself

I’m on the 4-year track and while CS225 is popular to pair with CS161, I’m glad I took it by itself. As I said earlier, I am not the greatest at math – so taking the class by itself helped me have plenty of time to dedicate to extra problems, studying for exams, and re-watching the same videos until I felt like I understood the topics.

And.. that’s it! My next class starts in autumn, so I’ll report back on my OSU studies in December.