Another semester is over, and it was quite the doozy like the last one. This time, however, it wasn’t because I hated the workload (like last semester) but because I hated the material. Or more specifically, half of it, but more on that later.

This semester, I finally took the cross-department course from the Business School that I was dreading. My school’s program is a joint-degree, Computer Science and Information Systems, with the CS stuff coming from the Engineering school and the IS stuff coming from the Business school. The degree has a number of requirements but one of them is that you must take at least one PhD-level class in each school. This means that I am able to take nothing but pure-CS courses, except I have to take one PhD-level course in the Business school. I’ve been dreading this since I started, somehow hoping this requirement would be removed before I had to take it, but this was not the case, and I had to take it this semester. With the credits I am able to transfer from my Master’s degree, this actually completes all of my course requirements, but because I was interested I also took a course on Graph Theory, which was a class crosslisted as both an undergrad and master’s level class. And once again, I somehow managed to get stuck grading.

Continue reading ‘Spring 2013 Semester in Review’ »

Brief Thoughts on Software Craftsmanship

To catch people up on some blogosphere drama:

Last month, Heather Arthur posted on her blog about an unfortunate incident in which some people on Twitter had found some code she wrote in GitHub, and people started trashing her on Twitter for it. Some of those people are considered leaders in the Software Craftsmanship movement, in particular Corey Haines. Corey immediately apologized for acting like an asshole, and I think his apology was sincere because I’ve met Corey and frankly the guy is almost annoyingly nice (he went around RubyConf 2012 taking a picture with every damn person there). But Ted Neward saw this turn of events and concluded that Corey’s actions were not orthogonal to his involvement in Software Craftsmanship, but actually influenced by them, and he posted as such on his blog.

Neward’s basic point is that this is the exact kind of behavior we should expect as a side effect of the Software Craftsmanship movement. By it’s nature, it attempts to create a segregation between those who are “in the know” and those who are not, and he felt the behavior of Corey and others was a byproduct of this segregation. They saw Heather as an “other” and were overly harsh in their criticisms, emboldened in so doing by their sense of Craftsmanship. Neward took a lot of shit for this view on Twitter, with most people arguing that this was done by Software Craftsmen, but it wasn’t done because they were Software Craftsmen, and it makes no sense to criticize the entire movement based on the action of a few members, regardless of how high their profile is. Neward responded to all of this feedback in a second blog post, where he reinforces his original point.

Uncle Bob Martin, one of the first five signers of the Software Craftsmanship Manifesto and author of Clean Code and The Clean Coder, then responded to all of this drama with his own post. Bob takes particular issue with Neward’s promotion of what he sees as the opposite of a Software Craftsman, a Software Laborer. In Neward’s words, a Laborer is someone “who cranked out one crappy app after another in (what else?) Visual Basic [...] their apps were sloppy, bloated, and ugly…cut-and-paste cobbled-together duct-tape wonders.” At the end of the post, Neward bows “with respect to the “software laborers” of the world, who churn out quality code without concern for “craftsmanship”, because their lives are more than just their code.”

Bob finds these kinds of developers to be problematic, as his experience suggests that people who make a mess of their code create lots of defects and headaches for themselves and other developers. Finally, Ted Neward responded to Bob as well with one more defense of himself in another blog post which he proclaimed on Twitter as his “last word on the subject.”

It was this last post that inspired me to post my own thoughts. I’m not going to speak much about the drama itself, or the definition of Craftsmanship vs Laborer, follow the links above if you’re interested in that debate.

Continue reading ‘Brief Thoughts on Software Craftsmanship’ »

Fall 2012 Semester in Review

My third semester in the PhD program is over, and it has unquestionably been my hardest yet. I bit off way more than I could chew, this semester was extremely unpleasant and, for the first time since going back to school, I was glad for the semester to end.

I took two 7000-level PhD courses at once (previously I had only done one in a semester) which was part of the problem. Originally I was planning on doing three, but quickly decided that was insane and dropped one of the classes, which I’ll now be taking in the Spring. One of these two remaining classes was material I had never been exposed to at all, and it also happened to be structured in a way that would have made it exceptionally difficult even if I had, while the other was material to which I had minimal exposure. I also took two courses on Coursera during this period of time, both of which I took quite seriously, as though they were credit courses. And if all of that wasn’t crazy enough, I managed to once again get roped into grading.

Continue reading ‘Fall 2012 Semester in Review’ »

A Stroll Through the Complexity Zoo

This Fall, I took a course on Computational Complexity. I’ve been exposed to complexity in Computer Science before, but as an undergrad it rarely went beyond discussing P, NP, and NP-Complete. While I enjoyed the class a great deal, I was slightly disappointed that we mostly studied some of the space complexity classes like PSPACE as well as went much, much deeper in depth on P, NP, and NP-Complete, without covering many of the other complexity classes, of which there are lots.

For a final paper, we had to pick a topic of our own choosing in Complexity Theory and research it on our own. For my topic, I choose to explore a bunch of the other important classes in complexity theory. I had never had any exposure to any of these classes before, so I really enjoyed this project, though I was unable to cover as many classes as I’d have liked, and none of them in as much depth as I was hoping.

Complexity Classes, from Math ∩ Programming

Nonetheless, I’m pretty happy with my paper, which provides an undergraduate-level explanation of 26 other complexity classes, based off The Complexity Zoo, kept by MIT professor Scott Aaronson. I tried to boil these classes down to the bare essentials and explain them with examples in plain english as much as I could. The goal of the paper is to expose those new to Complexity Theory or early in their Computer Science careers to a handful of interesting classes and explain how they relate to each other, the more common classes, and of course the $$P =? NP$$ question.

You can download the paper here.

Continue reading ‘A Stroll Through the Complexity Zoo’ »

Scala Second Impressions

In December, I posted about my early thoughts on Scala after using it for a short time. Initially, I thought that using Scala didn’t buy very much – the functional style could be adopted in in Java, and the syntax and libraries could be ugly.

Since that time, I’ve been using Scala almost exclusively, and I wish to revise my view: Scala is awesome.

While some of my initial thoughts still stand, particularly that Scala APIs often overuse operator overloading, much of my perception has shifted otherwise. Scala not only allows, but encourages solid functional programming principles that are difficult or impossible in Java.

Continue reading ‘Scala Second Impressions’ »