A few years ago, I finished my B.S. in Computer Science through UMUC, online and while traveling as a Consultant for Red Hat. When I moved back to the US, I knew I wanted to use the remainder of my GI Bill entitlement on a Master’s degree. These days, there’s a lot of options for online programs - for example, Georgia Tech’s online MSCS program. My coworker did a nice write up of his experience so far.

I decided to opt for a local program, and narrowed down my choices between Tuft’s part-time M.S. in Computer Science, and Harvard Extension’s awkwardly named Master of Liberal Arts in extension studies, field: Software Engineering. There’s a difference between computer science and software engineering, of course, but the Harvard ALM was flexible enough that I could include the theoretical stuff I wanted and it was easier to get to Harvard on public transportation. The degrees from the extension school seem to be awkwardly named to differentiate the Extension school from the other more traditional schools at Harvard. Still, I don’t get why it’s a Master of Liberal Arts, that’s not really reflective of the coursework. There’s been some effort to change that, although I doubt I’ll ever see it as I’m nearly done.

I’ve mostly taken one course at a time, but this year my awesome employer graciously let me take a leave of absence to study full time to wrap things up quickly as my GI Bill benefits expire soon.

Update: I’ve since returned from my LoA, and finished all but my last course (the Capstone). I’ve updated this blog post with reviews of everything I’ve taken so far, and some conclusions I’ve made so far about the ALM.

Courses

CSCI E-97: Software Design Patterns

This class was a deep dive into software design patterns. It taught most of the key patterns from the “Gang of Four.” It was also a heavy deep dive into UML.

I thought the class was useful, but the material was dry. It is a required part of the ALM.

CSCI E-93: Computer Architecture

This and the following two classes (CSCI E-95, and E-92) were my best experience at Harvard so far. I used this class as my “theoretical foundations” requirement for the 3 admissions courses.

In this class, I built a computer processor from scratch. I designed an instruction set, wrote an assembler, an emulator, and then finally implemented the processor using VHDL that ran on a physical piece of hardware (an FPGA development board from Altera). My final project video is on YouTube.

This and the other 2 classes are designed such that if you work through each of the problem sets, you’ll get a working thing in the end. Out of all 3 classes, this one had more freedom as you could really design any kind of processor you wanted. Some people tried more adventurous things like stack machines or getting pipelining working, but this was my first experience at this layer so I ended up doing a 16-bit, mostly MIPS-like architecture. My final project’s special feature was an LFSR. Many students opt for interrupts or hardware multipliers as theirs.

If you end up taking this, go to section. It’s extremely useful and a lot of implementation suggestions are given.

CSCI E-95: Compiler Design

I wrote a compiler for a large subset of C using C along with classic compiler tools (Flex and Bison). Whereas many other universities teach classes where you only learn theory, or only implement a “simple” language - this class stood out in that you literally write a compiler for C and have to understand all of its quirks.

It’s essentially C89 minus structs, unions, and function pointers. The final project is implementing an optimization stage in the compiler, mostly adding simpler peephole optimizations on basic blocks. Many students also work on more advanced register allocation strategies like graph coloring.

My final project video is here.

It’s worth noting, I didn’t know even know C when I started the class, but I knew it pretty well by the end.

CSCI E-92: Operating Systems

In this class, we learned the important operating system concepts, and then implemented an OS on a Freescale K70 Tower. You start out writing a small shell, your own implementation of malloc, various system calls in the OS, and towards the end of the class everything comes together when you write own scheduler and get multitasking working.

My final project was a rather complete POSIX-like permissions system, and interrupt-based Semaphores. I also got multiple serial ports working on the device, which made the demos a little more interesting.

My final project video is here.

CSCI E-28: Unix Programming

This class dives into the details of how POSIX systems programming works (and more specifically, the class touches on a lot of Linux-specific things). I took this concurrently with CSCI E-92, which it was a nice complement for. I’d reccomend taking this first, or also concurrently, to see how real operating systems design their system calls.

During this class, I wrote a shell (a bit more complex than the one I wrote for CSCI E-92), a pong game using curses, as well as a multithreaded web server for my final project. I wouldn’t say this is a particularly demanding course if you’re already familiar with Unix-like operating systems and know C. Most of the problem sets come with significant starter code.

The class is taught by the author of Understanding UNIX/LINUX Programming.

STAT E-100: Intro to Statistics

This class was underwhelming. I was hoping for a deeper dive into R, but it was much more using R as a REPL with 99% of the R code given to us. It provided a good introduction to statistical concepts, but was rather shallow in the depth of the topics that were covered.

I also took this as an online-only class, as it was the only stat class that’d fit into my schedule. The video lectures were really great, however the problem sets were not very challenging and mostly multiple choice. I expected it to be a little harder, and was disappointed I blew one of my elective slots on this class considering I could’ve got this out of Khan Academy on my own.

There’s a few other statistics classes at Harvard Extension (100, 102, 110, etc), offered by a number of different instructors. Perhaps some are better than others.

PHYS S-123: Laboratory Electronics: Analog and Digital Circuit Design

This was an 8-credit (2 course) summer program that ran Monday through Thursday, 9 to 1pm (officially) over seven weeks. On days with labs, the time was more realistically 2:30 or 3pm. Add on homework and study time, I was getting home in the evening nearly every day.

Typically, this is taught as two separate classes: a semester on analog electronics and a semester on digital electronics. This summer school version is intense - covering this amount of material in 7 weeks is daunting, and for the summer course some of the more interesting things are removed. Instead of the “big board” path where you build up your own computer on breadboards, we worked with a SiLabs microcontroller that had most everything built-in.

Still, it was a great experience and I’m glad I took this class. The analog section starts off covering voltage, current, and resistance and building passive circuits. It moves on to transistors, both BJT and MOSFETs, and you go on to build an op amp from discrete parts to understand what’s inside. It goes on to cover op amps in detail covering usages of positive and negative feedback, and on the final day of the analog part of the course, we designed and built a group project that transmitted and received an audio signal using infrared light.

The digital part of the class starts off with boolean logic, HDLs, and logic gates. CSCI E-93 covered a lot of this, but the electronics were abstracted away from us in VHDL. In this course, you look at what’s actually inside both TTL and CMOS logic gates, build analog-to-digital or digital-to-analog converters from parts, design and build state machines using flip flops, etc. The final week of the class is working with the SiLabs microcontroller, and writing assembly programs for it.

The text book we used is The Art of Electronics, along with the accompanying student lab manual.

CSCI E-55: Java, Hadoop, Lambda Expressions, and Streams

This met the ‘cloud’ requirement in the ALM program – because of the short section on Hadoop. It was the only available class that met the cloud requirement, so I had to take it. It would be a useful class if you did not know Java, but were already an experienced developer in something else. I did know Java so it was largely review. The overview of Java 8 features, and Hadoop were great, but that only made up about the last 1/4 of the course.

The instructor is great, and provides a history of his experience as a software developer over several decades. That was my favorite part of the class.

CSCI E-15: Dynamic Web Design

Another requirement for the ALM is ‘web design.’ The course was very well organized, and helpful if you knew HTML/CSS and did not have any background with a MVC framework. The course teaches Laravel, PHP, and HTML and students get a handle on git and work a bit with the LAMP stack.

For me, a waste of time and I wish ‘web design’ was not required, and instead given another elective spot.

CSCI E-134: Networks

This course I had intended to fulfill my ‘data communications’ requirement for the ALM. It was an exploration of all kinds of networks, such as social networks. It was marketed as an intersection of economics/computer science. It was run concurrently with the Harvard College version of the class.

I dropped it early on, as the advertised pre-reqs were not correct. One needs a deeper background than I had in math, including linear algebra. I’ve always regretted not having a better background in math. Maybe something I’ll improve after I graduate.

CSCI E-48: Secure Mobile Computing

Instead of E-134, I took this for the ‘data communications’ requirement.

The video lectures were largely reading the text slides word-for-word, unfortunately. Students do get some experience with packet sniffing WiFi networks with kismet and such, and some content related to 3G/LTE mobile networks. However, I didn’t like the course structure. Weekly requirements were forced discussion: watching a video and writing a summary post, and then replying to two other students’ posts.

The course staff was in general great, and I found them knowledgable and the labs OK, but I was hoping for more. Labs were interesting, but not very deep. Had I known CSCI E-134 wasn’t going to work out, I’d have taken one of the internet architecture courses on offer, but they did not fit with my schedule by the time I dropped it.

CSCI E-599: Capstone

Currently in progress for Spring 2018, will update when complete.

Conclusion

I have finished all but the Capstone, which I’m currently taking in Spring 2018.

There are many amazing courses at HES, but the 5 elective slots in the ALM program are not enough, especially when they’ve filled up the requirements with fluff like web design, “cloud”, and data communications where the classes only very loosely fit into those buckets.

I am a little bit disappointed by how many courses I felt like were wasting my time. My own professional goals do not align with how HES has structured the ALM. I’d rather have more elective slots, which I could’ve used to correct my weakness in math (MATH E-23A and others), or get more experience with research (CSCI E-191).

However, overall my experience at HES has been a good one. There are a number of classes that I think were high quality and well worth my time. I wrote a compiler, an operating system more or less from scratch, and designed my own instruction set and processor. I’ve built op amps on breadboards from transistors, and a combinational lock out of push buttons, LED’s, and flip flops. I’ve written a multithreaded web server, my own shell, and my own implementations of a ton of Unix utilities. All of this gave me a better foundation in how computers actually work, something I don’t think I had a good grasp on before I began this journey - even though I had been working as a developer and sysadmin for a number of years.