Test-driven development goes hand-in-hand with any type of incremental development. Writing tests to define what you want to achieve in each iteration and then writing the code to pass them is exactly what’s needed to make regular process. As an added benefit, having the tests from previous iterations makes it easy to find out if a new feature’s implementation breaks existing functionality.

For unit testing in PHP, the natural choice in PHPUnit. At first, I had some difficulty getting PHPUnit set up from the installation instructions, but adding a sudo to the beginning of each instruction solved all my problems.

At the very basic level, I want my application to be able to take in a string which is the hex representation of a MIPS machine code instruction and output the instruction in assembly code. I’d like to accomplish this in a class structure, and knowing that the machine code for add $t1, $t2, $t0 is 0×01484820, the first test verifies that this is the result my code gives.

public function testGetAssemblyCodeAdd() {
    $input = '01484820';
    $expected = 'add $t1, $t2, $t0';
    $temp = new MipsInstruction($input);
    $this->assertEquals($expected, $temp->getAssemblyCode());
}

The easiest way to code this to make it work is to hardcode the output:

class MipsInstruction {
    public function __construct($machineCode) {
        // does nothing
    }

    public function getAssemblyCode() {
        return 'add $t1, $t2, $t0';
    }
}

Running phpunit on the one test now results in OK (1 test, 1 assertion), whoo! A commit is in order for this. Unfortunately, the code doesn’t do anything other than pass this one test, so the next step is to add a couple more tests:

public function testGetAssemblyCodeSub() {
    $input = '01484822';
    $expected = 'sub $t1, $t2, $t0';
    $temp = new MipsInstruction($input);
    $this->assertEquals($expected, $temp->getAssemblyCode());
}

public function testGetAssemblyCodeOr() {
    $input = '01484825';
    $expected = 'or $t1, $t2, $t0';
    $temp = new MipsInstruction($input);
    $this->assertEquals($expected, $temp->getAssemblyCode());
}

resulting in:

FAILURES!
Tests: 3, Assertions: 3, Failures: 2

Once again, I’m making these pass the easy way first and can improve the code later once I know it works.

class MipsInstruction {
    private $inst;

    public function __construct($machineCode) {
        $this->inst = substr($machineCode, -1);
    }

    public function getAssemblyCode() {
        switch ($this->inst) {
            case '0':
                return 'add $t1, $t2, $t0';
            case '2':
                return 'sub $t1, $t2, $t0';
            case '5':
                return 'or $t1, $t2, $t0';
        }
    }
}

Now that all tests pass, it’s time to commit and I’m ready to start refactoring.

Step one: Come up with an idea

This was a project I was interested in doing while studying for Computer Architecture. It’s a simple web application that takes a MIPS instruction in machine code and then displays it in assembly code with details on the conversion. Honestly, the idea originated a semester earlier while learning the LC-3 toy language, and expanding the project to handle multiple languages is a possible future enhancement.

Step Two: Come up with a plan

The main reason I never really got started on this project before is because I always started with the architecture. I drew out diagrams of class hierarchies and debated the pros and cons of every possible design decision but never got to the coding part. To avoid this problem, this time I’m going with a pure incremental development approach and only a general overview of the desired end product.

As far as a technology stack, I’m using PHP mainly as a language refresher along with Git for my repository.

Step 3: Set up a repository

Subversion is my tried-and-true, so this is an opportunity to try another popular version control system that’s new to me. Fortunately, git has super easy set-up and hosting on github is free for open-source projects.

As everything is flif to me, you can find this project under the name Flif Risc. For now, it’s just an almost empty README, but it’s a start for things to come.

I started by working off of the WordPress Default theme before realizing that I really didn’t want a fixed-width theme and switched to WordPress Classic. Classic may not be my favorite theme, but it was easy enough to modify to get the layout I wanted.

Obviously, I’m not a designer. I did start by looking at some reasonable color schemes, but in the end I stuck with the colors that are already in my favicon. Those colors actually looked much, much worse before creating the funky background which integrated the scheme a little bit. Eventually, eventually, I’ll create something a bit more professional.

Going the easy route of modifying only the CSS, there are a few other things lacking still, like an RSS link with icon as well as a copyright notice at the bottom. Additionally, the titles of the sidebar widgets would be much easier to style if they had their own class. I may end up modifying the templates to make these changes, but for the time being it works.

CS 341: Automata Theory (Rich)

The topics for this course were a succession of finite state machines, pushdown automata, turing machines, and a bit of complexity theory. Some of the homework assignments take many hours to finish, but unfortunately they’re necessary to really understand the material. Rich lets you work in groups for the homeworks, which is useful because it’s easy to just stare at a problem for an hour without any ideas as to how to proceed. Just make sure that after you gain a better understanding you’re also able to work things out on your own. As long as you can do that, the tests should be alright.

CS 345: Programming Languages (Cannata)

Unfortunately, this is a required course. That’s about as much as I can say for it.

CS 378: Network Security and Privacy (Shmatikov)

Last year I was disappointed when this class was cancelled, but after taking it this year I’m really glad I got that extra year experience. Shmatikov expects you to know some C and Javascript going in, as they’re required for the projects and parts of the lectures won’t really make sense if you don’t already know the basics. There is a lot of material covered quickly in this class, so be prepared to do a bit of extra reading to get a full understanding. Overall, though, it was a great class and was probably one of the classes that I’ve gotten the most out of.

CS 361: Introduction to Operating Systems (Dahlin)

If you love spending long nights coding in the basement labs, you’ll love this class. The focus is mainly on multi-threading. Dahlin was in the middle of writing a textbook for the class, so we only had the first two or three chapters. Since we went over the same material in lectures, though, it wasn’t much of a loss. We were also an experimental class in that we had projects in C, C++, and Java just to see how it would work it. I really enjoyed it, because it’s a way of getting different perspectives at what are sometimes similar problems. Just make sure to do the homeworks also, no matter how little credit they may be, because that’s the best way to prepare for exams.

When I started as a proctor, I didn’t expect this problem. Upload scripts from previous semesters had been passed down and looked promising… but failed.

A quick look over the script was enough to identify the problem. The web addresses in the script were http:// when what I really needed to use was https://. The obvious solution was to update the addresses in the script, which of course still failed.

My next idea was to use replace the whole curl part of the script and instead use wget. However, wget doesn’t support multipart form data so that was another dead end.

At this point, I figured I was stuck using the browser, but maybe a Greasemonkey script would be able to perform bulk uploads. After all, it’s just adding extra forms to a page and submitting them. But no, modern browsers don’t let you auto-fill the path of file input in forms, which in retrospect makes complete sense.

So I was stuck with curl, which I was already able to use to set cookies or to fetch a page or text file. However, downloading zip files also wasn’t working. Time to look up the curl man page and just try anything:

• Added -i to also include the headers for extra feedback
• Added -referer, although no one in their right mind would rely on the referrer given
• Added -A to specify Firefox as user agent, also dubious
• Used -H 'Accept-Encoding: gzip,deflate' to attempt zip downloads
• Changed the keep-alive settings

Nothing helped.

I switched between using the -d and -F flags to specify the content type, but only got Error - bad file data and 403 Forbidden respectively. One of these must at least be a step in the right direction, but which was it?

Finally, I figured out how to use --trace-ascii dump.txt to see exactly what was going on but didn’t know what to look for until downloading an HTTP analyzer for Firefox and using that for comparison. At last things finally started making some sense. As noted in a blog post from Ian Dennis Miller, an Expect: 100-continue header was also in the trace.

I added -H 'Expect:' to the command and it finally happened. I uploaded a comment file remotely. Halfway through the semester and finally some down time to get things working. Damn, I love Spring Break.

• when we’re working with unfamiliar code, we can split up and then guide each other through the parts we know
• hearing/seeing other people’s thoughts keeps my mind fresh with new ideas
• I’m not so tempted to be checking my email or playing Mines
• at least someone knows how to get C/C++ code to compile

However, pair programming does come with its challenges. For college computer science courses, one of the biggest is finding a time you can work together, but the challenge I’m most interested in is agreeing on an editor to use together. Sometimes it’s simple. For Network Security and Privacy, there was barely any coding involved so my partner and I managed to do the whole thing with gedit. (Well, okay, I did type up one short script in vim). In Software Design last year, we were learning how to use tools with NetBeans, so there wasn’t even a choice there.

In Operating Systems, though, my partner and I need an editor that’s more sophisticated. Okay, there are plenty of those, no problem, right? But the fact of the matter is that he’s an Emacs afficionado and I’m vim all the way. I prefer simple keystrokes to Meta-combos, and he just doesn’t grok command mode.

I’ll admit it. Honestly, the Esc key often seems kind of far away, and after years of use I’ve only recently started getting the hang of visual mode. (In retrospect, I have no idea why it took me so long.) But he’ll open up Emacs with our project, I’ll have a burst of inspiration, grab the keyboard, and at the end type in :w. Ugh! Other times I’ll open up vim and then he has a burst of inspiration but causes crazy stuff to happen because I wasn’t in insert mode.

By now I think he does know how to get into insert mode and I’ve at least learned how to save in Emacs, but it’s obvious that one editor isn’t going to work for the two of us. We needed a new plan…

So screw the former pair programming paradigm! We now sit happily side-by-side with two different monitors, two different machines, two different keyboards. He keeps Emacs open, and I’ve got my vim. Whoever’s driving at the time gets to use their preferred editor and then check in the code once there are any changes or we want to switch off. And whenever we’re absolutely stuck on something, we both get to fiddle around with the code individually until one of us finds something that looks like progress.

It’s kind of weird, though. The last time we were working on a project together, I was using DVORAK and having to switch back to QWERTY regularly to pair program. If we managed to agree on an editor, I’m sure we’d find something else crazy to disagree on. Then again, anything’s better than fuv.

CS 337: Theory in Programming Practice (Misra)

From the name of the class, I thought this would be a theory class, but it’s really more just a set of programming exercises to give you a little more practice before you take on the more advanced computer science courses. Of course, there are some proofs thrown in as well, but it’s not much more advanced than what you learn in CS 336 (as long as you remember it). If you take Misra and aren’t paying attention in class, prepare to be called on. Otherwise, just make sure you set aside enough time for the programming projects. They often appear easier than they really are.

CS 347: Database Management (Miranker)

I thought this would be my best class last semester. Since I took Software Design and simulated the Gamma join architecture as one of our projects, I’ve found databases interesting. Unfortunately, this class just glossed over the areas that I found interesting. The course was also very disorganized (once we had just two lectures between exams and the homeworks were over-vague), which made it difficult to learn anything in much depth. Other students who had no previous experience with databases say they got a lot out of it, but if you already know a bit then doing some reading or taking an online course may be more useful.

CS 344M: Autonomous Multiagent Systems (Stone)

Going into a research class for a topic you have no interest in is never a good idea, but I can see how almost anybody else would have loved it. We worked in pairs to create new or improve on existing teams for the Robocup soccer simulator and had a tournament at the end of the class. By starting from a complex team (though not improving much on it), my team won the 2D tournament. We also discussed automated traffic controls, chatbots, bidding agents, and other applications of autonomous agents. If you’re not familiar with C, getting started may be a bit difficult. This is the only computer science course so far in which I made a B, but it was worth it overall.

CS 361: Introduction to Computer Security (Young)

This is probably one of the easier upper-division CS courses. There wasn’t any required textbook, which was nice. The lectures were usually pretty straightforward and just a little bit interactive. Other than the occassional stories about security blunders, it could get a little boring, but what really made the class worthwhile was the projects. We learned how to crack UNIX passowrds, implement AES, simulate covert channels, and more. I’d recommend this class to pretty much anyone.

Multilevel security (MLS) presents a set of users and a set of objects to be accessed. Both the users and objects are classified hierarchically with a security level as well as need-to-know categories. For example, you may have an “Unclassified” user trying to read a “Classified” object or a “Classified Crypto” user trying to write a “Classified Nuclear” object.

The Bell-La Padula model defines a way for deciding whether to grant access in each of these cases. This model uses a formula to define whether a certain level combined with a category dominates some other level combined with a category. We’ll define “Classified” as a higher level than “Unclassified”, so in the first example “Classified” (with no category) dominates “Unclassified” (with no category). I’ll ignore categories here for simplification, but in reality for one classification to dominate another, both its level and category set must dominate the other.

Having this domination function defined, we can describe the two main properties in the Bell-La Padula model:

• The Simple Security Property – A user can only read an object if the classification of the user dominates that of the object. (Also known as “read down” or “no read up”.)
• The *-Property – A user can only write to an object if the classification of the object dominates that of the user. (Also known as “write up” or “no write down”.)

The reasoning behind the Simple Security Property is pretty straight-forward. If you’re concerned about confidentiality, you definitely don’t want people to read anything that they don’t have to. It’s the second property that raises some eyebrows. Why should a user be able to overwrite something that they can’t even read? Doesn’t this create huge issues with integrity?

The answer is simply that BLP doesn’t concern itself with integrity. But when you look at the property solely from the concept of confidentiality, the idea becomes a bit more clear. A user at a certain level knows information that users at lower levels don’t, so he shouldn’t be able to write anything to those other levels. However, users at a higher level already know that information so in that sense it’s okay to write to a higher level. You don’t have to worry that someone will see something they shouldn’t know about.

Another question in this model is how can someone give an order to their subordinate at a lower level? Here BLP adds the concept of trusted users. These are a special type of users who are proven trustworthy and who have the ability to write to lower levels. To me this seems like a cheap way of adding in functionality that should be provided by the basic system. “How do you make sure someone is trustworthy?” seems like as much of a complex question as “how do you make sure information isn’t written where it shouldn’t be?” Perhaps the reason for considering the first is that it’s easier to just have a person decide the second.

Overall, it’s interesting to find that the Bell-La Padula model has retained such influence despite its inherent shortcomings. As we continue in my Computer Security course, I look forward to seeing how more modern models compare and how they’ve solved the integrity problem.

Compared to my former 71 wpm in QWERTY, my peak in DVORAK is only around 55 wpm. Of course, this is partly because whenever I use any computer other than my own, it’s in QWERTY. If there’s someone who can maintain finger fluency in two keyboard languages, they have all my respect. I’m not like that. And I’m not quite sure what my typing speed on QWERTY has dwindled down to. If there’s a potential to type faster, that’s just in ideal situations. As for any possible ergonomic benefits, that simply doesn’t matter. Switching back and forth between two keyboard layouts does not work.

Goodbye, DVORAK. I’ll miss your home-row words like “the” and “sound”. I’ll miss the lack of single-handed words. But none of my friends like you so it just won’t work out.

CS 336: Analysis of Algorithms (Myers)

This class focuses on formal proofs of algorithm correctness, including topics such as weakest preconditions, developing invariants, induction, and probability. Even for a computer science course, it’s very math-intensive. One of my favorite things about this class, though, was having a support group available. There are some classes where you’re supposed to figure out everything on your own and not discuss the homeworks at all, while here we were encouraged to attend ACM’s weekly theory reviews or our own groups to meet up and work on the homeworks. For a class where the students have such varying backgrounds (everyone teaches 313k differently), it’s really necessary. I may not have been able to get a firm grip on recurrence relations without it.

CS 352: Computer Systems Architectures (McKinley)

This was McKinley’s first time teaching CS 352, and unfortunately it was at times very obvious. Reading the textbook was helpful, but the exercises often used terminology not in the rest of the book and were very confusing. The midterms were also insanely difficult. I’d go in thinking I had a good understanding of the material but then leave completely stunned. (Being able to keep the graded midterms would have been nice.) But for the final at least, I had almost a whole week to study. I read the book, worked out extra exercises, summarized the class notes, checked Wikipedia for clarifications, and everything came together. Sure, there were a couple of small things that I couldn’t remember ever going over, but in an hour and a half I was done and ended up with a 90.5–the highest grade on the final for any student. If you want to do well in this class, you need to have a lot of time to devote to it.

CS 378: Software Design (Batory)

This has been probably my favorite computer science course. We learned how to reason about programs using UML and studied refactorings, design patterns, and architectural patterns. For even common design patterns like hooks, I had never understood before exactly what they were. My favorite part, though, was learning about parallel architectures and having the opportunity to simulate everything from a basic join up to the parallelized Gamma join architecture. It’s a difficult class, but Batory’s generally an entertaining lecturer and I would recommend it to any computer science student.