No More Pencils, No More Books: An Academic Computer Science Adventure

This week, I finished my last final exam for the Graduate Certificate in Software Design & Development.  It was a nine month program, with six classes.  Two classes per quarter, in the evening.  One class was a computer science class, the other a software engineering class.

The software engineering class only met once a week, for two hours (so a two credit hour class).  The professor was a retired Microsoft engineer who had his own career counseling business for software developers and took the teaching position for something else to do.  He taught all three of the software engineering classes, so I saw him every Wednesday evening for nine months.  Honestly, he was an excellent, very engaged teacher.  He was seriously organized, he knew his material cold (didn’t have to look at his own slides very often), and had the timing of each lecture solid (and always had time for anecdotes and questions).  The first hour of class was lecture, the second hour was the group assignment of the day (no homework!).  He also was not a big fan of exams, but the school required a midterm & a final, so he made them straightforward, allowed us generous exam notes, and made sure we knew what was going to be covered.

The class content was all about the high level software design process.  First quarter was project management (Waterfall, Agile, etc.), second quarter was software modeling (customer analysis, system architecture, data flow, interface design, test driven development, etc.), third quarter was software testing and quality (usability, availability, integration, security, functional, incidents & root cause analysis, etc.).  Nothing with much technical detail, so we didn’t have to know necessarily how to test the software security for a vulnerability, but we had to know that software often had a given vulnerability and it was something that we would need to learn how to test for.

Basically all the parts of developing a software product that are not writing code and developing algorithms.  And the business side of it all is included in there, although again, from a high level view.  And it all had to be high level, because every workplace is going to do it differently, so getting to deep into the weeds isn’t much help.

The computer science class met twice a week, in the evening, for two hours a day (a four credit hour class).  We had a different professor for each quarter.  Of the three, the professor we had during the second quarter was the best, and by best, I mean she was acceptable.  The other two were rank disappointments.  Now before I get into the details of these classes, I should note that one of the program requirements was that you had taken Computer Science 101 & 102 (or 101 & 201), which is your basic first two semesters of how to write code.  101 is your introduction to object oriented programming (OOP), and 102/201 is basic algorithms and data structures.  If you did not have those on your transcripts, or they were too far in the past, you had to write and submit a small coding project (it was a pizza vending machine simulation).  I had to do the project, because I took 101 and 102 back in the late 1990’s.  I think I spent maybe 8 hours doing the project, and that includes testing.  It wasn’t a difficult thing, I did it in Java, and I demonstrated that I understood OOP and how to use data structures and simple algorithms.

So, given that I had already proven that understood OOP and the rest, as had everyone else who was accepted into the program, of course the very first computer science class was essentially a combination of 101 & 102, but using C++.  Now I should say that the class number was 501, which at the university, denotes a graduate level class.  That’s not to say the class wasn’t handy, in that I was not well versed in C++, but a lot of students were, which means for them, the class was a waste of time and money.  They learned nothing new.  A graduate level class, it was not.  Even for me, conceptually it was a waste.  I didn’t need to go over the conceptual stuff again, I just needed to understand the differences between how C++ does things, and how Java does it.  I actually have a book on my shelf called “C++ for Java Programmers”, which does exactly that.  And yes, some of it is critical to understand (C++ forces the programmer to manage memory usage carefully, Java does not; C++ exposes memory pointers, Java hides them; etc.), but it’s the kind of stuff that would take maybe four or five class periods to cover, because EVERYONE has already shown that they understand the basics of writing software.

And to top it off, the professor who was teaching it could not have been more disengaged from the class.  He was teaching it like he lost a bet, or was being forced to do it in order to keep research funding.  It was a night class (usually a good indicator that most students had day jobs), but he held office hours once a week at 2PM.  He would rarely answer emails, and if he did, he’d get back to you a few days later.  Lectures were a dull droning as he spoke to the podium.

He did not get a good review from me.

The second quarter (502) was more useful, as it went over more advanced data structures and algorithms (compression algorithms, graphs, trees, heaps, hash maps, etc.).  Granted, I already knew a lot of it, but I also still learned things.  However, there was nothing that was a struggle to learn, so once again, it didn’t really feel like a graduate level class.  That said, the professor did a respectable job.  She was very engaged, and easy to understand.  Nothing outstanding, mind you, but no complaints either.

This last quarter, 503, was basically operating systems (although again, this seems like undergraduate level stuff to me).  The material was mostly new to me, like the details of how computer memory works, how data is stored on hard drives, how CPU time is scheduled.  I did spend a lot of time in IT, which means I knew bits here and there on how it all works, but the class went into a greater level of detail than I ever managed on my own, including discussions on the basic algorithms used to manage CPU time, memory, and disk storage.  It was also very UNIX/Linux-centric (Windows?  What’s that?).  All the assignments required us to work against Linux, and to use Linux specific C++ libraries, etc.

There were also a section on networking, and threading…

I know a lot about threading.  I had to do a lot of thread programming and management at the last job, and I got really good at it.  C++ is NOT the language one should use for threading, but the class was committed to C++, so that’s what we used.

Course content aside, the real issue was the instructor.  The class was supposed to have an experienced instructor teaching it.  Decent lecturer, has a lot of quality YouTube videos out there (I know, I watched a bunch).  That’s not who we got.  We got a new instructor, teaching his first class (the original instructor was supposed to be helping him, but seemed to give up after the second or third week).  He was a developer at Nintendo, clearly knew his stuff, but spoke with an accent, through a mask, and talked to the podium or the white board.  He seemed incapable of projection or enunciation.  That’s not to say he wasn’t capable of communicating, because if you called him up on Zoom during office hours, he was easy to understand on the Zoom call.  No mask, spoke directly into the microphone, all that.  But lectures pretty much weren’t worth attending.  To pile on, he could not figure out how to use the LCD projector in the room.  His screen was always projected small, into the upper left corner of the projection screen, and the projector was cutting off the left 50 or 100 pixels of the slides.  He needed to center the screen lower down and increase the size, otherwise it was impossible to read the screen unless you were right up at the front of the room.  When I mentioned it to him early on, his response was that he couldn’t find the projector remote.  Somehow, calling campus AV support for a new remote was beyond him?

And his time management was horrendous.  He would regularly pause to figure out what he wanted to talk about next, he jumped all over the slides, he would finish talking about a slide, stop for a few minutes, then switch over and start writing code without an explanation.  He never finished a topic during the class it was supposed to finish in, so part of the next class was spent wrapping things up.  It was so bad that there were topics on the midterm we had talked about in lecture, but not yet had a chance to practice in the homework, and the final included material that we never even had a lecture on, we just had to review the slides and the text book.

None of us were impressed with him.

And to rub salt in the wound, when it was exam time, our exam notes were limited to Linux C++ function prototypes only.  For those of you who are not programmers, a function prototype is the equivalent of having a geometry exam where you are expected to find, say, the volume of a sphere, and the only thing you are allowed to put on your exam notes is:

Volume_sphere=f(Pi, radius).

So all you know is that the equation for finding the volume of a sphere involves Pi and the radius of the sphere, but what the actual equation is ((4/3)*Pi*(r^3)) is something you better have memorized.  Thus we had to know what all those function calls did, which is a pain, because C++ function calls are not exactly descriptive.  Forgot what is the difference between the call to execvp versus execlp is?  Too bad.  And, of course, there were plenty of exam questions that had nothing to do with C++ Linux functions, so you had to have all that in your head as well.

This is why I hate exams in academia, because IMHO most faculty absolutely suck at writing exams.  They have no idea what they want to test us on, nor how to test us for it in the time allowed, even if they had a clue.  So the exams almost always feel slapped together with little thought, and then they do crap like force you to memorize trivia for the exam (literally, each exam had questions like “Who developed Unix?  Who wrote C++?).

He did not get a good review either.

On the whole, though, the program is called Software Design & Development, so I expected coursework covering how to design software.  Let’s go over how to leverage abstraction, inheritance, generics, interfaces (regular and functional), and polymorphism in the design of complex code.  What are design patterns and how are they used?  How about Clean Code, writing tests for test driven development, actual process and thread management?  How does one develop an architecture for a large piece of software, and then break it down for the individual bits?  How does AI, machine learning, or data science fit into all this?  How about designing for parallel processing?  Some of this got touched on, but in only the simplest of terms and exercises.  It wasn’t the focus.

What this tells me is that academic computer science is still largely ignorant or uninterested in how to create quality software.  They love their algorithms and research, but beyond that…  It’s something I intend to write a letter to the program director about.  Perhaps they should not have academic faculty developing (or teaching) the computer science part of the program.  As much as I complained about the instructor for 503, the fact is, he’s a smart software engineer who has written software professionally.  He may not be the best instructor, but I bet he could put together a three class program that didn’t start out assuming the student had no clue how to write code or how computers worked.  And the thing is, modern software isn’t written with tools that require a developer have a deep understanding of how the computer does things (unless the software being written is a compiler).  These days, it’s more important to understand how to create complex software that is usable, scalable, secure, maintainable, and has a minimal amount of technical debt.  That’s the kinds of things that need to be taught.

Did I learn anything?  Yes, especially the software engineering stuff.

Was the program worth the money or time?  Not really.  Certainly not the computer science classes.  I enjoy learning new things, but I don’t think I’ll be relying on a CS department to help me next time.