Sometimes, I wish I had just gone to college right after high school, but I didn’t. I joined the Navy, and when I got out I got my first job as a systems administrator without any formal education. That worked well for a while, but it caused a lot of headaches when I immigrated to Germany – they very much prefer a formal education. I also really wanted to fill the gaps in, I wasn’t much of a programmer nor did I have a good idea of how things really worked under the covers.
So, I took advantage of the GI Bill and finished my B.Sc. in Computer Science through UMUC, all by distance learning. As I was a Consultant at the time, my nomadic life in hotel rooms in rural Switzerland was pretty conducive to being able to do my homework.
In 2015, I moved back to the US and with some entitlement left on my GI Bill, I decided to pursue my Master’s degree. 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.
However, I decided to opt for a local program and try to have one normal in-person college experience. I 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. In the end, I opted for Harvard due to it being a much easier commute.
I mostly took one course at a time, but this year my 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. I took a full-time Summer and Fall semester in 2017, and then in the Spring of 2018 I returned to work and completed the Capstone part-time.
So, now that I’ve completed the program: 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 do feel like I would’ve been better served if I had more freedom to pick things that were interesting to me.
However, overall my experience at HES was 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.
Below, I’ve included a write-up of each of the courses I’ve taken at HES, hopefully future students find it helpful. One piece of advice: if you are coming with any exerience already as a software developer working on a team, pursue a thesis instead.
- CSCI E-97: Software Design Patterns
- CSCI E-93: Computer Architecture
- CSCI E-95: Compiler Design
- CSCI E-92: Operating Systems
- CSCI E-28: Unix Programming
- STAT E-100: Intro to Statistics
- PHYS S-123: Laboratory Electronics: Analog and Digital Circuit Design
- CSCI E-55: Java, Hadoop, Lambda Expressions, and Streams
- CSCI E-15: Dynamic Web Design
CSCI E-134: Networks
- CSCI E-48: Secure Mobile Computing
- CSCI E-599: Capstone
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. 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.
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
The capstone is a semester-long group software project, where students are divided into teams and complete a medium-to-large software project. Before the semester began, the Professor looked for project ideas. There was a team working on a blockchain reccomendation letters service, and another who was working on data mining the pubmed database to find studies with particular demographic data.
Our team of 6 worked on a system for tracking hand hygeine in medical facilities. Huge numbers of completely preventable infections are acquired in hospitals ever year, many resulting in death. Proper hand hygiene is the single most effective tool to reduce this, and there’s a lot of expensive, proprietary systems out there for ensuring compliance. Most facilities tend to use manual, paper-based methods, so our goal was to provide an open source, free tool to elimate the paper-based method. We had a stretch goal to come up with a cheaper commodity hardware method for tracking compliance with proximity sensors.
We spent a lot of time working on planning and requirements gathering, and the project evolved and morphed a few times around the edges. We didn’t end up demoing hardware, although the platform had interfaces for integrating it, and we ended up expanding to a more general observation platform with the presented use case being for hand hygiene.
Overall it was a good and interesting experience. We even had a real-world deployment of our project to a free clinic in Texas, where it was trialed and we gathered data about the usability of our platform. We also participated in BioIT World and presented our project in the poster area.