Computer science is no more about computers than astronomy is about telescopes.

This quote, attributed to the brilliant Edsger Dijkstra is such a perfect little summary of what Computer Science is, and it explains so much about the field in a very short space, it’s ideal for explaining CS to those outside of the field.

The problem is, it’s bullshit.

This quote is an attempt to explain that Computer Science is about Computation, not Computers. It’s about algorithms, complexity, and so on; those whirring boxes under our desks are just TOOLS for studying the real SCIENCE. I’ve been guilty of using this quote myself on more than one occasion, largely as a way to make my degree sound more academically pure (harder) somehow.

If the quote were about “purely theoretical computer science” then perhaps I could agree. Indeed, Alan Turing created the foundation of computer science well before computers existed, and the Church-Turing thesis suggests that “computer science” can be studied with purely theoretical models of computation such as Turing machines, or with just $$\lambda$$-calculus. But anyone with a CS degree will tell you that turing machines and calculus generally only come up in classes with the word “theory” or “model” in the title. Whether originally intended or not, Dijkstra’s quotation is generally used with regard to the entirety of the modern-day Computer Science college degree. And in that context, the quote is nonsense.

When you major in Astronomy, you take courses about the galaxy, physics, gravity, cosmology, black holes, and so forth, but not telescope construction, telescope optimization, historical telescope engineering, and lens alignment.

A typical Computer Science degree will include computer architecture, compiler design, compiler construction, networking, and operating systems. These are courses that are unquestionably about actual computers. Sure, they are informed by the theoretical material, but ultimately the thing being studied is an actual machine. Go find a CS major in an architecture class, studying the way that processes are laid out in memory and how to optimize memory allocations to be in multiples of the cache size for memory optimization, and tell them that their degree has nothing to do with computers.

I’ve also often heard “Computer Science is a branch of mathematics.” This, too, is nonsense. Computer Science uses a lot of math, but it’s no more a subset of math than physics is a subset of calculus. You could take every single math course offered at every single school in the world and never wind up learning anything about how file systems are implemented. It’s not a subset. Go ask a mathematician if CS is a branch of math.

Despite the constant drive to figure out which thing Computer Science is most like, the truth is that no analogy is good for Computer Science. Computer Science isn’t like any other discipline. It’s a weird hybrid between science, mathematics, and engineering. It’s all of those things at once, and none individually.

When I was an undergrad, my school had 3 divisions under their College of Arts and Sciences: humanities, social sciences, and natural sciences. Computer Science was categorized as a natural science. A few years after I graduated, the major was moved not only out of that category, but out of that entire school, and into the School of Engineering. It went from being considered a science to being considered engineering. I think it’s bizarre that so many people try to claim they can explain what Computer Science is with a 12 word pithy quote when universities can’t even seem to settle on it.

"Computers, pish-posh! Naturally I majored in CS because of my childhood passion for the halting problem!"

I respect Dijkstra immensely, and this quote may be true of theoretical computer science, or even CS within academia, but it’s not based on what a typical Computer Science major will study. I can understand using this phrase as a way to avoid providing technical support and virus removal services to friends and family, but in terms of actually understanding the nature of the degree, I think it’s quite unhelpful.

When high school students post to various forums asking about CS, expressing interest in computers and programming, inevitably some pompous jerk will roll his or her virtual eyes and explain that CS has as much to do with computers as astronmy does with telescopes. I think someone who truly has that view of Computer Science has about as good an understanding of the degree as the people who “just want to make games”.

Computer Science isn’t really a natural science, but it’s also not really a math, nor is it really engineering. Computer Science isn’t like anything, it’s like Computer Science.

This return to school was the first time since I graduated from the University of Rochester that I attended actual classes on a campus (my Master’s program was entirely distance learning). I wanted to record some of my thoughts about returning to school, since it’s been such an adjustment for me.

University of Colorado at Denver

The University of Colorado at Denver turned out to be exactly the kind of school I wanted.

The University of Rochester was a great school, considered to be one of the “New Ivy” institutions. The Computer Science program was very intensive there, and I was barely able to survive a few of my classes. This was good for me as an undergrad – that was the right time in my life for an extremely intensive program, since I was in school full-time and focused on nothing else. These days, however, I’m a full-time Software Engineer professionally, and I didn’t want to be part of such an intense program for graduate school. I went back to grad school for fun, not for my career, and I wanted a program that would not burn me out due to difficulty. Often I found undergrad classes so difficult that I was unable to comprehend some material, leaving me to feel lost, like I was missing out on interesting stuff because I couldn’t understand it before moving on. I wasn’t interested in that kind of experience.

My master’s program with Regis University, on the other hand, was too far at the opposite end of the spectrum. Since it was online and largely self-taught, I didn’t have much interaction with academics, professors, or even other students. Often I wouldn’t bother doing the readings, and there were very few actual assignments (usually just a few projects per course). In short, I felt like Regis was too easy, and I was often bored while attending. I really enjoyed my thesis work, but the actual courses were so low-key that I was able to get straight A’s without really focusing on school, which reminded me way too much of high school.

I wanted something that would challenge me enough to keep me engaged, but not so challenging as to frustrate me. I wanted actual lectures, homeworks, and exams, but I didn’t want them to be so difficult that I felt lost with the material. This is precisely what I found at the University of Colorado at Denver.

The material was thorough, but the more difficult topics were always taught at a slightly slower pace, and the professors have been great about making sure their students understand. There were definitely some frustrating nights doing difficult homeworks, but I was always able to correctly solve the problems with enough time and effort (as compared with undergrad, where no amount of time would have helped me with some assignments). It was exactly the right level of challenge – enough that I knew it felt like a challenge, but never enough that I couldn’t find the solution. Completing homeworks was intensely satisfying.

If I had applied the same level of effort to UCD that I had applied to Regis, I would have failed out. But applying the same level of effort that I applied at Rochester yielded me two A’s, rather than the B’s and C’s I got as an undergrad. It was perfect.

Campus

Like I mentioned, this was the first time I was back on an actual campus in seven years. I worried I would feel old and out of place. As it turns out, the UCD physical campus is shared between UCD, the Metropolitan State of Denver, and the Community College of Denver. As a result, the diversity of people on campus helped me feel completely at-ease. I definitely wasn’t part of the younger crowd of undergrad college kids (wearing what is apparently a nationwide school uniform of “skinny jeans, boots, North Face jackets, and huge sunglasses”), but I wasn’t part of the older “I’m-changing-careers” crowd either. It felt just about right, and I felt about the same age as the other students in my graduate courses.

I really enjoyed going to campus and attending classes. Both classes were taught in a single building, so any time I was on campus I was in that building, save for a few rare instances of grabbing lunch at the food court. I’m really glad I lived on campus as an undergrad because of the socialization doing so provided, but I went back to grad school exclusively for education, so the lack of social aspects worked well for me. I probably wouldn’t recommend UCD to young undergrads, but it’s great for commuters and grad students.

My classroom building is a ten-minute walk from where I work (and the Computer Science department might soon move into a closer building). My employer has been great about letting me leave work to attend class, and it’s so conveniently close that it’s been a real pleasure. I’m pretty sure that my classes are even closer to my office than my classes were to my dorm room as an undergrad.

Classes

Graduate Algorithms

Testbook: Introduction to Algorithms, 3rd ed.

My first class, taught by Dr. Ellen Gethner, was a continuation of my undergrad Algorithms and Analysis class. Algorithms at the graduate level focused a lot more on proving correctness and runtime boundaries than my undergrad classes. I always struggled with proofs, but the constant practice I got with this class made me understand the techniques far better. The sense of satisfaction I felt when I completed a difficult proof was great.

3-Coloring of the Peterson graph

I’m lucky in that my undergrad course lightly touched on a few subjects that many undergrad courses don’t mention, namely Graph Theory. Having seen a bit of Graph Theory before, I found that section of the course a bit more familiar than some of my classmates, and I really enjoyed learning a lot more about it (it helped that it’s Professor Gethner’s research area, so she was very excited about it and it showed). Another large portion of the class was devoted to studying Number Theory and Cryptography, both of which I was a little familiar with thanks to a Cryptography course I took as an undergrad. It was nice to learn in areas that I had seen before but never fully understood, thus really rounding out my grasp of the subjects.

My professor for undergrad Algorithm Analysis and Design was a really nice Japanese man who had a great passion for the subject, but who I had a hard time understanding due to his extremely thick accent. I never really understood a lot of the material as well as I’d have liked, particularly Dynamic Programming and Greedy Algorithms. Professor Gethner is a native English speaker, and it made it so much easier for me to follow the lectures. I finally came to a thorough understanding of the material from undergrad, but I also learned about a lot of new subjects such as M-pire/Earth-Moon graphs, Huffman encodings, Fast Fourier Transform, and computational geometry.

Homeworks were fun and interesting, often with a slightly humorous slant (one encoded message we had to decipher decoded to “CHILL OUT EVERYONE”). Exams were extremely fair, largely based on the homeworks and never testing material that hadn’t been discussed in class. I did quite well, getting an A as a final grade.

Theory of Distributed Computing

Textbook: Distributed Computing

Taught by Dr. Bogdan Chlebus, this was the first course I’ve taken that had virtually no connection to anything I did as an undergrad. I took a “Parallel and Distributed Systems” course before, but that was a Systems course, focused primarily on implementing shared memory systems at a low level. This class was much more theoretical, focusing a lot more on proofs (and counterproofs) than implementation. Occasionally I’d see terms I was familiar with from previous classes, but 95% of the material was brand-new. I learned about the Consensus problem, various types of shared memory registers, fault detection, byzantine processes, the attack problem, the theoretical differences (and similarities) between shared memory and message-passing distributed systems, linearizability and sequential consistency, theoretical mutual exclusion models, and the wait-free hierarchy.

The Dining Philosopher's Problem

I found the course extremely interesting, though sometimes I felt like the presentation of the material left me wondering where it was going. Rather than present a difficult problem, then discuss the tools used to solve it, often we would be presented with the tools first. Many times this left me (and other students) studying completely academic-seeming tools without any understanding of how they related to anything else. For some of the subjects we learned about, the payoff wasn’t until the very end of the course.

Though the material presentation order left a bit to be desired, the decision as to what material to include in the class was excellent. We never got into any system-implementation details, always staying very theoretical, focusing on proofs and reductions rather than actually writing code. All assignments were written with text and occasionally drawings, never any programming required. Since I went back to grad school to focus on theory and algorithms, this was right up my alley, and I really enjoyed it.

Professor Chlebus was very passionate about the subject, and though he had a pretty thick accent, I was able to follow him extremely well. The homeworks were all really interesting and thought-provoking, and he even supplied hints for many of the problems if you read his lecture notes closely. Exams were very difficult, often relying more on memorization than understanding, but he also curved the grades to compensate for the obscene difficulty. In the end, I actually got the highest grade in the class.

Grading: Fundamentals of Computing

I also volunteered to be a grader for an intro course, Fundamentals of Computing. This was the least rewarding part of my semester, by far.

Though I enjoyed getting a refresher on C++ by reading a LOT of student code, a particular aspect of grading this class marred the experience: cheating.

After a few assignments, I began to notice peculiar similarities between student submissions. I gave the same feedback, word-for-word, on a handful of assignments and around the third time I decided to look at the assignments a bit closer. It was clear to be that some students were submitting the exact same assignments.

I was really disappointed in my fellow students for this. I don’t know what it is about cheating that bothers me so much, but it really irritated me. I informed the teacher for the class and he gave these students zeroes for the assignments, but it didn’t seem to have that much effect.

On the next assignment, I noticed the same thing, only this time some of the students clumsily renamed variables in arbitrary ways, hoping to trick me. It was still obvious they were copying, so I brought it to the teacher’s attention again. Moreover, there were actually 3 or 4 different clusters of students that copied off of each other within the group. I spent hours combing over code to find patterns indicating cheating between 40 different assignments, and sent my findings to the teacher.

Finding these cheaters was extremely time-consuming for me, taking far more time than what grading should have reasonably taken. And yet, despite students getting zeroes as a result of the cheating, students were still turning in identical, copy-pasted assignments even as late as the final assignment for the class at the end of the semester.

This really ruined the grading experience for me, so I don’t plan on doing it again.

Overall

Overall, I’m incredibly happy with my decision to return to school. I’m learning fascinating stuff in a tough but manageable academic environment, and it’s been very rewarding.

I honestly don’t know if it’s the school itself that’s been so enjoyable, or if it’s been a matter of getting out what I put in. Since I’m paying for school myself and I’m attending voluntarily (not because I “have to if I want a job” as I did as an undergrad), I find myself much more motivated to do the readings, give my best effort on assignments, and pay attention in class. I only missed one lecture the entire semester, in stark contrast to times as an undergrad where I’d skip the entire day because it was cold out (sorry Mom).

I speak up in class, ask questions, and have even felt a bit like a teacher’s pet a few times due to my enthusiasm. A number of other students have come to me asking homework questions like I’m some kind of expert (I’m not), which feels great.

Taking only two courses at once (rather than 4 or sometimes 5 as an undergrad) has allowed me to really focus on the material and I’ve gotten a lot out of it. There’s very little from the semester that I feel like I didn’t understand fully (looking in your direction, Fast Fourier Transform), which gives me a real feeling of accomplishment. Being able to work in both the academic world of theoretical Computer Science and the practical world of professional Software Engineering has kept a nice balance of satisfying my interests.

I’ve absolutely loved being back in school, and I can’t wait for next semester.

Writing this blog post is probably a mistake. A few years ago I shared my thoughts on Ruby after a similar amount of time using it. When I went back and re-read that post to get the link for this one, I was stunned. I don’t even remember disliking Ruby at any point. Today, Ruby is one of my favorite programming languages, and the tool I reach for most readily for almost any project outside of work. I still love Python as I did in that post, but my view of Ruby has, apparently, completely changed.

Nonetheless, I have some thoughts on Scala and because I have a blog, I suffer from the delusion that there are people who give a shit what I think about it.

As with any “first impressions” post, it’s entirely possible I will literally discover something that invalidates my complaints tomorrow (maybe even in a comment on this post), so take this with a grain of salt.

What’s Bad?

Compilation Is Slow

Our Scala codebase is quite large, divided into many different modules. At the moment, we have over 57,000 lines of Scala code in a series of modules that make up a central Common Services Tier, which is nothing to shake a stick at. One observation about using Scala in this way is that compiling and running the Scala code takes a very, very long time. Far longer than with Java or even Groovy.

I am aware of the existence of the Fast Scala Compiler, which offers a substantial speed improvement. However, while I was able to get FSC working in IntelliJ without an issue, getting Gradle to use it to build our project has proven surprisingly difficult. I’ve followed the tutorials that are available, but ultimately I failed.

And no, the Scala Build Tool is not an option. It simply doesn’t offer the kind of power that we require and are getting out of Gradle.

It’s not like compilation is taking hours or anything, but it’s a minute or so longer than it ought to be for the amount of code, which adds up to a lot of time. It’s much faster to compile and run Scala from IntelliJ because I got FSC working in it. As a result, I rarely have to compile from command-line, but when I do I wish it was faster.

Interop Is A Bitch

We didn’t convert to Scala whole-hog, and I dont think we intend to. Most of our client-facing sites are written with Grails, with the controllers calling a number of services written in Java and Groovy.

Using Java or Groovy from Scala is a breeze. Using Java and Groovy from each other are also a breeze. Using Scala from Java or Groovy pretty much makes me want to drink a pitcher of boiling lava.

I won’t pretend to understand the design decisions that went into Scala, but I’m definitely annoyed at the fact that scala.Lists do not implement the java.util.List interface. It seems to me that Scala could have had the full benefit of using its own lists within the Scala language while still implementing that trivially-small interface. Doing so would have made it so much easier to at least pass Scala’s lists to Java or Groovy methods that are expecting a java.util.List or a java.util.Collection. I’ve had to import scala.collection.JavaConversions into more .java and .groovy files than I care to recount.

Of course, this wouldn’t solve the problem of passing Java Lists into Scala, which resembles this beauty:

scala.collection.JavaConversions.asScalaBuffer(existing).toList()

Using traits, Scala can give you something resembling multiple inheritance. This is a powerful addition to the toolbox, but it also makes classes surprisingly difficult to use (and, in particular, mock) in Java or Groovy. As a result, we tend to use this powerful ability sparingly, which is a shame.

It’s Young

Scala is so young that there isn’t much in the way of idiomatic guidelines for it. I don’t have a good grasp on Scala best practices or patterns.

A lot of the Scala code I write I have little confidence in, in terms of design. When I write good Java or Groovy code, I know it’s good, and part of that is I’ve read so much about those languages that I know what most other developers consider easy to understand.

Java has been around so long that the Java community has learned what kinds of things you can do that make code hard to maintain, and countless books have been written on how to avoid those things. Most of those tips extend to Groovy as well, but not to Scala. In fact, some of those patterns and practices seem like antipatterns in Scala.

Whatever book is the “Effective Java” of Scala, I’d love to read it (though I don’t think it yet exists). A coworker told me that it was unnecessary since “Scala is effective Java.” What a douche.

The APIs Can Be Ugly

I’ve argued with Java developers before about operator overloading. Many feel like operator overloading leads to ugly APIs, but I’ve always said that more power is better, and developers can simply have the discipline not to overuse a feature like operator overloading. Scala has convinced me I’m probably wrong.

We are heavily using the Scala library Dispatch in our code. Here are some methods defined on the class RequestVerbs:

• / – Append an element to the request path.
• <& – Combine this request with another
• <:< – Add headers to the request.
• << – POST the parameter.
• <<< – PUT the parameter.
• <<? – Add query parameters.
• <& – Combine this request with a handler.
• >\ – Set the character set.

This is terrible. It’s impossible to write clean code against this API, because there is no way to express intent. Any developer reading the code will have to pull up the API to understand what is happening unless he or she is intricately familiar with the library already.

It would be one thing if this object had regular, English methods and the overloaded operators called them (or vice versa), but that’s not the case. There’s no way to call these methods without invoking these random-seeming combinations of symbols. The code ends up looking like Brainfuck.

Rather than seeing Dispatch as an embarrassing wart on the Scala community, it seems to be generally highly regarded, even praised for its abysmal API. There seems to be a large constituency of Scala developers who are enamored with operator overloading, seemingly without regard to the adage “just because you can do something, that doesn’t mean you should.”

What’s good?

The Paradigms Are Great (But Are They Exclusive?)

There is no doubt that our Scala code is highly functional, emphasizing composing functions together rather than declaring steps. I love functional code, I think it reads much more clearly than iterative code, so this is a huge win. Our objects are always immutable and much more thread-safe.

But are we doing this because of Scala? Scala may encourage immutability, but it does not demand it. You can declare variables as vars even though you’re encouraged to declare them as vals. Our team is following functional coding practices because we chose to, not because Scala is enforcing it.

I’ve been making my Java classes immutable and relying on the Builder Pattern for object construction for years. And I’ve been writing functional-style code using Google Guava in Java for about as long, which is even easier with Groovy.

These paradigms have been part of my coding practices for a while, and since we’re only using them in Scala because we agreed to do so (and could have just as easily not done so), couldn’t we have agreed to do them in Java or Groovy as well?

Clojure, I’d understand. Clojure pretty strongly enforces the functional paradigm, it’s not a matter of choice really. But since Scala doesn’t, at least not as much, I’m not really sure I know what Scala is buying us, though I suppose there are some particular functional practices that Scala makes much easier.

It Keeps Idiots Out

The biggest advantage of Scala, at least so far, is that it keeps a certain type of coder out of the codebase. Groovy did not accomplish this, since Java code can compile as Groovy with minimal modification.

GTFO.

Because Scala is a bit more cutting-edge, and involves some pretty serious shifts in thinking, the kinds of coders who are capable of doing their job with Java but have no interest in learning new languages have little interest in understanding Scala well enough to make changes to Scala code. Most half-assed attempts to do so are met with compilation failures.

Basically this boils down to Paul Graham’s Python Paradox, in which he claims that the caliber of developers who know Python will, on average, be better than the typical Java programmer, which creates an advantage to using Python in your project that is completely separate from the capabilities of the language itself.

I feel kind of bad including this as an advantage, because it’s esssentially “functional programming is difficult to learn, so it excludes dumb people,” but it’s kind of true. It’s had a positive impact, and I appreciate Scala for this, even though it’s a backhanded benefit.

Conclusions

Though I list more cons than pros, I’m enjoying Scala. I like learning new languages and Scala has a lot of movement in the JVM ecosystem, so it’s nice that I’m not behind my peers in learning it.

I also like that my team is writing immutable, thread-safe, highly functional code. Personally, I think we could be doing that in Java or Groovy or any other language really, with a little added discipline. That said, to some extent if Scala is what’s making everyone do that, then Scala is good thing, in a “the ends justify the means” sort of way.

Overall, I view Scala very much how I view C++. C++ is not really a good language at all, but it was of great historical importance. C++ supplied a Object-Oriented Programming layer on top of C, which allowed iterative-style C programmers to transition to OOP at their own pace. Not a great language, but a necessary compromise to help the transition. I view Scala in much the same way, as a transitional language to help get professional Java programmers more comfortable with functional programming. Today’s Scala programmers are tomorrow’s Clojure or Haskell programmers, and in that sense Scala serves a very valuable purpose.

I’m definitely still getting comfortable with the language, and I can easily see myself viewing it more and more favorably as time goes on, but I’m not quite at a point where I’m sure it’s buying me much. I love functional programming and always have, and Scala does encourage me to do so, which is nice. I also love Pattern Matching, that’s a badass feature I could see myself eventually seeing as indispensable.

A lot of my issues with the language (compilation speed, lack of best practices) are due largely to how young the language is, so they’re likely to improve over time as well. In a way, even my complaint about the ugly APIs is due to the age of the language: if it were older there would probably be a decent alternative to Dispatch.

Overall, I’m excited to continue using Scala and see it improve over time.

I’ve already discussed how I’m not a huge fan of the various modifications made to the original Star Wars trilogy, so it’s reasonable to assume I’m not a big fan of the prequel trilogy either. There are many people who dislike the prequel trilogy so much that they don’t even consider watching them. On bad days, I’m one of those people, but on good days I see some value in the prequel trilogy, even though I consider them inferior in virtually every way.

For people that couldn’t care less about the prequel trilogy, I suggest Harmy’s Despecialized Editions. They are 720p blu-ray discs (AVCHD discs actually) that are the result of “Harmy” from The Original Trilogy forums painstakingly reconstructing the theatrical releases of all three films utilizing a wide variety of video sources as well as custom mattes. Downloading, burning, labeling, and printing cases for these films is one of the neckbeardiest things I’ve done (aside from writing this blog post), and I’m extremely glad I did it. When I feel like watching Star Wars for just me, these are the ones I watch. If that’s enough for you as well, stop reading now.

Harmy, king of nerds

But what can you do if you do wish to involve the prequel trilogy? Maybe you’re showing the films to a younger crowd that won’t be able to appreciate and enjoy films with distractingly dated special effects. Maybe you don’t want to spend the effort to download and burn your own discs, and purchasing the official Blu-rays is fine for you. Maybe you’ve accepted that the original theatrical editions are no longer considered canon, and you’re a nerd that cares about things like that. Hell, maybe you actually like the prequels (seriously?).

Whatever your reason, if you are showing someone the official editions of Star Wars for the first time, you have to make a decision about which order to show the films.

Two Choices

There are two obvious choices for watching the Star Wars saga.

• Release Order – Watch the films in the order they came out, recreating your experience with the films for someone new to them.
• Episode Order – Watch the films in the order George Lucas intends, starting with Episode I and going straight through to Episode VI

There are two critical flaws with both of these orders, unfortunately, that prevent either from being appropriate.

The problem with Episode Order is that it ruins the surprise that Vader is Luke’s father. If you think that this reveal doesn’t matter since it’s common knowledge, I suggest you watch the looks on these kids’ faces. This reveal is one of the most shocking in film history, and if a newcomer to the series has managed to avoid having it spoiled for them, watching the films in Episode Order would be like watching the ending of The Sixth Sense first.

The other problem with Episode Order is that the prequels don’t really have a story. They’re just background for the real story, which is Luke’s attempt to destroy the Empire and save his father. Watching 3 films of backstory is boring if you’ve never seen the films they’re the background to. Hell, that’s why George Lucas made A New Hope first, he knew if he started with Episode I he’d never be able to complete the series. Starting someone off with Episode I is a surefire way to ensure they don’t make it through the entire franchise.

Unfortunately, Release Order is also an instant failure, and the reason is a single shot. If you’re watching the original trilogy first, then after the Empire is destroyed and everyone is celebrating, Luke looks over at his mentors, Ben Kenobi and Yoda, and suddenly they are joined by… some random creepy looking teenager who needs a haircut. Placing Hayden Christensen in the ending of Jedi, since he’s not in ANY of the other films, turns an ending that should be celebratory into one that is confusing for the viewer. The fact that Christensen looks like he’s undressing someone with his eyes doesn’t help.

So neither order really works. What to do?

An Alternative Suggestion

How can you ensure that a viewing keeps the Vader reveal a surprise, while introducing young Anakin before the end of Return of the Jedi?

Simple, watch them in this order: IV, V, I, II, III, VI.

George Lucas believes that Star Wars is the story of Anakin Skywalker, but it is not. The prequels, which establish his character, are so poor at being character-driven that, if the series is about Anakin, the entire series is a failure. Anakin is not a relatable character, Luke is.

This alternative order inserts the prequel trilogy into the middle, allowing the series to end on the sensible ending point (the destruction of the Empire) while still beginning with Luke’s journey.

Effectively, this order keeps the story Luke’s tale. Just when Luke is left with the burning question “how did my father become Darth Vader?” we take an extended flashback to explain exactly how. Once we understand how his father turned to the dark side, we go back to the main storyline and see how Luke is able to rescue him from it and salvage the good in him.

The prequel backstory comes at the perfect time, because Empire Strikes Back ends on a huge cliffhanger. Han is in carbonite, Vader is Luke’s father, and the Empire has hit the rebellion hard. Delaying the resolution of this cliffhanger makes it all the more satisfying when Return of the Jedi is watched.

Narratively, it’s just like a movie that starts with a big opening, then fades to “2 years earlier” for most of the movie, until it catches up with the present time and concludes.

Introducing: Machete Order

Now I’d like to modify this into what I’ve named Machete Order on the off chance that this catches on because I’m a vain asshole.

Next time you want to introduce someone to Star Wars for the first time, watch the films with them in this order: IV, V, II, III, VI

Notice something? Yeah, Episode I is gone.

Episodes II and III aren’t exactly Shakespeare, but standing next to the complete and utter trainwreck that is Episode I, they sure look like it.

Episode I is a failure on every possible level. The acting, writing, directing, and special effects are all atrocious, and the movie is just plain boring. Luckily, George Lucas has done everyone a favor by making the content of Episode I completely irrelevant to the rest of the series. Seriously, think about it for a minute. Name as many things as you can that happen in Episode I and actually help flesh out the story in any subsequent episode. I can only think of one thing, which I’ll mention later.

Every character established in Episode I is either killed or removed before it ends (Darth Maul, Qui-Gon, Chancellor Valorum), unimportant (Nute Gunray), or established better in a later episode (Mace Windu). Does it ever matter that Palpatine had an apprentice before Count Dooku? Nope, Darth Maul is killed by the end of Episode I and never referenced again. You may as well just start with the assumption that Dooku was the only apprentice. Does it ever matter that Obi-Wan was being trained by Qui-Gon? Nope, Obi-Wan is well into training Anakin at the start of Episode II, Qui-Gon is completely irrelevant.

Search your feelings, you know it to be true! Episode I doesn’t matter at all. You can start the prequels with Episode II and miss absolutely nothing. The opening crawl of Episode II establishes everything you need to know about the prequels: a bunch of systems want to leave the Republic, they are led by Count Dooku, and Senator Amidala is a senator who is going to vote on whether the Republic is going to create an army. Natalie Portman is called Senator Amidala twice in the first 4 minutes of the movie, so there’s no question of who’s who.

What Gets Removed?

Here’s some stuff that you no longer have to see as part of your Star Wars viewing experience, thanks to skipping Episode I.

Buh-bye, Binks!

• Virtually no Jar-Jar. Jar-Jar has about 5 lines in Episode II, and zero in Episode III.
• No midichlorians. There is only one reference to midichlorians after Episode I, and in the context it appears to mean something as benign as “DNA.”
• No Jake Lloyd. Sorry Jake, your acting is terrible and I never really wanted to see Darth Vader as a little boy.
• No confusing Padme/Queen switcheroo. The whole subplot with Padme and her decoy makes absolutely no sense. It’s clear that this was just so people could interact with Padme without knowing she was the Queen, but it’s incredibly convoluted and pointless.
• Less confusing master/apprentice relationships. Darth Sidious is training Count Dooku, Obi-Wan is training Anakin. No other trainer/trainee relationships exist to confuse the backstory. Fewer characters to learn about, so the story is more focused.
• Nothing about trade disputes. The “problem” as of Episode II is that a group of systems want to leave the Republic. This is much easier to understand for a kid than trade disputes.
• No pod racing. Seriously, who gives a shit? An action sequence for the sake of an action sequence and it goes on forever. A huge number of plot holes surrounding gambling and the subsequent freeing of Anakin are removed as well.
• No virgin birth. We simply don’t know or care who Anakin’s father is, and the subtle implication that it’s Palpatine is gone.

But booting Episode I isn’t merely about pretending a crappy movie doesn’t exist. Viewing Episode II immediately after V and Episode III immediately before VI actually tells the story better than including Episode I does.

Why Does This Work Better?

As I mentioned, this creates a lot of tension after the cliffhanger ending of Episode V. It also uses the original trilogy as a framing device for the prequel trilogy. Vader drops this huge bomb that he’s Luke’s father, then we spend two movies proving he’s telling the truth, then we see how it gets resolved. The Star Wars watching experience gets to start with the film that does the best job of establishing the Star Wars universe, Episode IV, and it ends with the most satisfying ending, Episode VI. It also starts the series off with the two strongest films, and allows you to never have to either start or end your viewing experience with a shitty movie. Two films of Luke’s story, two films of Anakin’s story, then a single film that intertwines and ends both stories.

Beyond this, Episode I establishes Anakin as a cute little kid, totally innocent. But Episode II quickly establishes him as impulsive and power-hungry, which keeps his character consistent with eventually becoming Darth Vader. Obi-Wan never really seems to have any control over Anakin, struggling between treating him as a friend (their very first conversation together in Episode II) and treating him as an apprentice (their second conversation, with Padme). Anakin is never a carefree child yelling “yippee”, he’s a complex teenager nearly boiling over with rage in almost every scene. It makes much more sense for Anakin to have always been this way.

In the opening of Episode II, Padme refers to Anakin as “that little boy from Naboo.” The opening crawl establishes that she is the “former queen of Naboo.” The two of them look approximately the same age in Episode II, so the viewer can naturally conclude that the two of them were friends as children. This completely hides the totally weird age gap between them from Episode I, and lends a lot of believability to the subsequent romance. Scenes in which they fall for each other seem to build on a childhood friendship that we never see but can assume is there. Since their relationship is the eventual reason for Anakin’s fall to the dark side, having it be somewhat believable makes a big difference.

Obi-Wan now always has a beard for the entire duration of the series, and Anakin Skywalker always wears black. Since these two characters are played by different actors (and are the only characters in the series with such a distinction), having them look visually consistent does a great deal toward reinforcing they are the same people.

This order also preserves both twists. George Lucas knew that watching the films in Episode Order would remove the Vader twist, so he added the Palpatine twist to compensate. Since we don’t really meet the Emperor until Episode VI, this order preserves the twist around Palpatine taking over as Emperor. Episode I establishes that Darth Sidious is manipulating the Trade Federation in the opening scene of the film, and it’s pretty obvious Sidious is Palpatine. But if you skip Episode I, all we ever see is that Count Dooku is leading a separatist movement, all on his own. He tells Obi-Wan that the Senate is under the control of a Sith lord named “Darth Sidious”, but at the end of the movie, after Dooku flees from Geonosis, he meets with his “master”, who turns out to be Darth Sidious. This is the first time we realize that the separatist movement is actually being controlled by Sidious, who later turns out to be Palpatine in Episode III. This order also keeps the fact that Luke and Leia are siblings a surprise, it simply moves the surprise to Episode III instead of VI, when Padme announces her daughter’s name. This is actually a more effective twist in this context than when Obi-Wan just tells Luke in Return of the Jedi.

What Works Best?

Best of all, this order actually makes a particular tension in Return of the Jedi stronger.

Remember, we see in Episode V that Luke’s vision in the cave on Degobah is that he turns into Darth Vader, then we find out Vader is his father. Then we watch Episodes II and III, in which his father turns to the dark side in order to protect his loved ones. After that we go back to VI, where eventually Luke confronts the Emperor.

The first time we see Luke in Return of the Jedi, he’s wearing all-black, just like his father did. He gives R2D2 and C-3P0 to Jabba the Hutt, much to their surprise. Luke isn’t exactly looking like a clean-cut Jedi like he claims. Then, when he finally enters Jabba’s palace, the musical cue sounds a bit like the Imperial March, and the way he enters with the light behind him makes it unclear if he is Luke or Vader. Then, he force chokes Jabba’s guards, something only Vader has done in the series! Nobody else sees him do this.

When he confronts Jabba, he warns him that he’s taking his friends back. He says Jabba can either profit from this, “or be destroyed.” Furthermore, he tells Jabba “not to underestimate my power.” The last time this phrase was used, it was by Anakin when dueling Obi-Wan. When watching Jedi on its own, Luke just seems a tad arrogant during these scenes. When watching Jedi immediately after watching Revenge of the Sith, the message is clear: Luke Skywalker is moving toward the Dark Side.

Why does this matter? Because at the end of Jedi, Luke confronts the Emperor. The Emperor explains that the assault on the new Death Star is a trap and that his friends are going to die, and he keeps taunting Luke, telling him to grab his lightsaber and fight him. The film is trying to create a tension that Luke might embrace the Dark Side, but it was never really believable. However, within the context of him following in his father’s footsteps and his father using the power of the dark side to save people, with Luke’s friends being killed just outside the Death Star window, this is much more believable.

Shortly after, Luke goes apeshit and beats the hell out of Vader, clearly succumbing to his anger. He overpowers Vader with rage and cuts his arm off, just like Anakin did to Windu in Episode III. Having the very real threat of Luke following in his father’s path made clear by watching II and III before VI heightens the tension of this scene, and it actually makes Return of the Jedi better. Yes, watching Revenge of the Sith makes Return of the Jedi a better, more effective film. Considering it’s the weakest of the original trilogy films, this improvement is welcome.

What Doesn’t Work Better?

Machete Order isn’t perfect. There are a few tiny issues that arise watching the films in this order.

The Kamino sequence is a little confusing. Since the cloners seem to have been “expecting” Kenobi, it leads the viewer to wonder if Episode I showed him creating the clone army or something. Hilariously, Episode I doesn’t actually explain anything or make this scene less misleading, but the fact that the viewer knows a movie got skipped amplifies the confusion.

Qui-Gon is mentioned once in Episode II and once in Episode III. Luckily, both times he is mentioned, his relationship to the characters is restated, so it works. Dooku explains that Obi-Wan’s old master Qui-Gon was once Dooku’s apprentice, and then in Episode III Yoda tells Obi-Wan that Qui-Gon has learned to communicate after death. It’s alright, just a little weird.

Episodes II and III both talk about Anakin being part of a prophecy which is never really explained (because it was explained in Episode I). This is unfortunate, but on the plus side the last time it’s mentioned in Episode III, Yoda says it may have been misinterpreted.

The weakest part of this order is when Anakin returns to Tatooine. We don’t know his mother is a slave, and we don’t know he built C-3P0. When he has visions of his mother dying and returns, Watto says he sold her. That’s not something you expect to hear about a Jedis’s mother, so it’s a bit jarring. When Anakin goes to the Lars moisture farm, Threepio calls him “the maker” and they act like they know each other, but it’s not stated outright that Anakin created Threepio. This definitely draws attention to the fact that one of the films was skipped. This is the one, singular thing made genuinely more confusing by skipping Episode I.

Give It A Shot

You might be wondering if it’s worth skipping II and only watching III, just to establish young Anakin in time for Jedi. I don’t recommend this, every character you need to know for Episode III who was introduced in Episode I is reintroduced in Episode II with a quick line of dialogue, but Episode III just assumes you know who everyone is.

This order doesn’t even interfere with canon – everything that happens in Episode I is still canonically compatible with this ordering, we simply don’t watch it.

I’ve tried clearing my brain out and watching the films in this order and it makes the overall experience vastly more enjoyable. If you find someone who has never seen any Star Wars movies, try showing them the films in this order and post a comment explaining any particular points of confusion they had while watching. My hunch is there won’t be many if any at all.

K5 and K3,3

Of course, this theorem relies on the fact that $$K_5$$ and $$K_{3,3}$$ are, themselves, not planar. While it’s pretty easy to see $$K_5$$ is not planar, $$K_{3,3}$$ is a bit more involved. I’ve read a lot of proofs of this, but frankly I found most of them sorely lacking. Here I try my hand at providing a clearer proof than what you may find elsewhere. Hopefully my explanation will make things click for a Googling student.

Intuition

First I want to simply convince you. This won’t be as formal a proof as I intend to provide, but I want to give a sense of the intuition. I’m a visual learner, so often I find that an informal explanation or a series of examples is more convincing to me personally than a proof.

First, let’s remove three edges from $$K_{3,3}$$. This will be a new graph that we’ll call $$G$$. The edges we’re removing are going to be the straight vertical edges, the ones that join a vertex with it’s counterpart on the opposite side of the graph (treating the top and bottom as sides). We’ll be adding these back later, but we’re going to remove them for now.

Modified graph G

We’ve also labeled the vertices clockwise from $$a$$ to $$f$$ for clarity.

Now, it’s easy to see that $$G$$ is planar. We can re-arrange the vertices and make a simple hexagon out of the graph.

Clearly, $$G$$ is planar. But the real question is, what about $$K_{3,3}$$? Remember, we removed three edges from the graph to get $$G$$. If $$G$$ is planar and $$K_{3,3}$$ is not, then it must be impossible to add those three edges back into the graph without having at least two of them overlap.

The edges missing are $$(a,f)$$, $$(b, e)$$, and $$(c, d)$$. You can see that all of of those edges have to cross the middle of the hexagon, so there’s no way to put three, or even two edges into the middle of it without them crossing.

Even going around the outside of the graph doesn’t help. If you put one edge outside and one edge inside, you still have one more edge to reinsert. No matter what, at least two of the three edges are going to have to cross each other. Clearly, $$K_{3,3}$$ is not planar.

Formal Proof by Contradiction

Intuition is great, but let’s nail down the proof with a bit more mathematical precision. We’re going to do a proof by contradiction.

First, let’s assume for the purpose of contradiction that $$K_{3,3}$$ is planar.

If it is planar, then is must obey Euler’s Formula, which is that

$$$V – E + F = 2$$$

for number of vertices $$V$$, number of edges $$E$$, and number of faces $$F$$, which can be rewritten as $$F = E + 2 – V$$. In this case, there are 9 edges and 6 vertices, so $$F = 9 + 2 – 6 = 5$$, so the number of faces must be five. We’ll come back to this fact in a bit.

Labeled K3,3

So what would it take to have a face in this graph? How many edges would surround any given face? Let’s say we start at some vertex, for example $$a$$. We want to walk along edges from vertex to vertex and return to our starting vertex $$a$$. If we can do this in a planar graph, we have a face (and remember, we’ve assumed the graph is planar). What’s the smallest number of edges that can get us back to our starting point?

It can’t be one edge, because there are no loops. And it can’t be two edges, because that would mean that there are two edges between two vertices, in other words a multi-edge, and we don’t have any of those either. It also can’t be three edges, because after two edges we’re going to be back on the same side of the graph as our starting vertex, and we know those two don’t connect because the graph is bipartite. For example, if you start at $$a$$, moving one edge away puts you at either $$f$$, $$e$$, or $$d$$. Moving another edge away puts you at $$b$$ or $$c$$ and there’s no way to get back to $$a$$ with one more edge. So no face can be surrounded by three edges.

The minimum number of edges needed to draw a face is four. Four edges can get you back to the starting node, creating a face. For example, $$a$$ to $$e$$ to $$b$$ to $$f$$ and back to $$a$$.

If there are at least four edges per face, then the total number of “face boundaries”, meaning the number of times an edge (any edge) is counted as the border of a face, is at least $$4F$$.

Any edge can only sit between two faces (since a face must use an entire edge and cannot use part of one). Thus, each edge can only count twice as a face boundary, so there are at least $$\frac{4F}{2} = 2F$$ edges.

We know that $$F = 5$$ from earlier, which means the graph must have at least $$2*5 = 10$$ edges. $$E \ge 10$$, but we know that $$E = 9$$. Thus we are left with $$9 \ge 10$$, which is obviously not true, so we’ve found a contradiction, Q.E.D.

One particular intern on my old team was a lot of fun for me. The company was the first place he worked since graduating with his B.S. in Computer Science. The things he said were so similar to things I said when I first graduated, and his approaches to problems reminded me so much of my own approaches to problems eight years earlier that it bordered on creepy.

One particular exchange between him and I stood out in my mind. It was exactly the conversation that 28-year-old me would have had with 20-year-old me.

Him:

Arggh, the other team changed the interface of something my code is using, and now it’s broken.

Me:

So? Just fix it.

Him:

I will, but it’s annoying. I mean, if they had just started the application they would have seen it’s broken. They’re so stupid.

Me:

Wait, it breaks right away?

Him:

Yeah, you get an error when you hit the front page. The front page!

Me:

Then they aren’t the ones who are stupid. We are.

He was frustrated the other team had made a change and not even run the application. They had checked code in without even giving it a run-through in the application live. How unprofessional could you be?

My answer? A lot more unprofessional. How? By not creating any tests for your functionality.

The other team’s code immediately broke the entire application. Yet, every single test in the commit suite passed.

The team that failed here was my team. We had not created good test coverage, and the proof was in the pudding. A change that completely crippled the application turned no tests red.

Early in my career, I was afraid of making changes that could affect unexpected aspects of the system. My first job out of college, whenever I made changes, I’d read lots of code and was extra careful. Of course, nobody can ever be careful enough with this methodology, so I’d wind up breaking things. I’d feel awful for this, completely embarrassed. I’d panic and try to fix the code as quickly as possible, assuming my co-workers thought I was an idiot.

Today, I take the exact opposite approach: fearless refactoring. I refactor code without even the slightest bit of concern about the ramifications. If I break something, a test will let me know. If no test lets me know when I broke something, I don’t feel embarrassed. I feel like someone else should be embarrassed.

If I break your code but all of the tests passed, it’s not my fault, it’s yours.

I have unapologetically embraced this attitude, and I’m more than happy to share it with people. If someone makes a change that breaks my code, I don’t give them hell for breaking my code, I thank them. They found a part of my code that I had not correctly covered with a test. Code coverage can only do so much, sometimes the only real way to know if you’re missing a test is for someone else to break your code in unexpected ways.

This attitude extends to deployments as well. Just recently I was having a conversation with co-workers about whether it was safe to deploy some code that had a lot of changes in it (including mine). Without even thinking, I said it was fine. They looked at me like I was crazy. How could I be so confident in the code without even looking at what anyone had written? Simple: all of the tests were passing on the build. I assume that all code with a passing build is deployable.

Is it possible that I’m wrong? Absolutely, there’s lots of undeployable code in the world that passes a build. But deploying it and having it fail miserably is extremely valuable – the failure indicates a big area that needs to be covered by automated tests. I’m happy to deploy code and have it fail spectacularly, it helps me know what tests need to be written.

I take the attitude that passing tests indicate the underlying code is perfect and, should I be proven wrong via failure, I immediately write tests to justify my attitude.

If you assume your code is right because the tests pass, and you are shocked every time that assumption is wrong (and respond appropriately), then after a short time your assumption will be true.

I’m slowly rebuilding my movie collection in Blu-ray, but the main difference between my Blu-ray collection and my DVD collection is that I intend for my Blu-ray collection to be limited. Rather than buying the Blu-ray of every movie I like, I’m only buying the Blu-rays of the films I absolutely love. Many of my DVDs were never watched after purchasing, a few of them were even sold on eBay without the cellophane removed. New purchases are just my favorite films of all time (or at least related, which is why I own Terminator Salvation).

The Last Physical Format

When I was buying DVDs, I knew they’d eventually be replaced. I’ve owned movies on Betamax, VHS, and DVD. No format ever felt like the “final” format. I always knew I’d have to replace any movie with the next version of it at some point. Blu-rays, however, don’t feel the same way.

I believe Blu-rays will be the last physical format of movies I ever buy. It’s clear that the world is moving toward streaming or online storage of movies. Maybe people will ‘rent’ movies via Netflix or Amazon Instant or a similar service forever, or maybe there will be something more iTunes-like where you can ‘buy’ movies and watch them any time. There will be a day, eventually, when buying a film on physical media will seem like buying a CD today.

Between now and then, will anything replace Blu-ray? I highly doubt it. Blu-ray’s big improvement from DVDs was the enormous increase in resolution and quality. Blu-ray is pretty maxed out in this regard – increasing resolution further would be virtually imperceptible to the human eye, so that won’t be the selling point of the next big thing.

The next big advance in film is probably going to be increasing the framerate. But there’s no way to increase the framerate of older films the way we’ve been able to increase resolution for Blu-ray releases. Any attempt to increase framerate would be done by interpolation, which could just as easily be done algorithmically on hardware. With resolution, the data was fundamentally there already, in analog format on physical film, but framerate is fixed. This all means that the next big format can’t use framerate as a selling point, because there’d be no incentive to buy older films.

Most good Blu-ray releases already have the absolute maximum amount of data associated with the film on-disc. Every deleted scene, blooper reel, audition tape, and commentary ever recorded for a movie is usually on the Blu-ray release, having been dug-up from vaults as needed. My Blu-ray of Blade Runner has five different versions of the film. There’s literally nothing Blade-Runner related that could be unearthed to cram onto another release of the film.

For all of these reasons, I’m nearly certain that, when I got the Alien Quadrilogy on Blu-ray, it would be the very last time I purchased it (I owned the box set of 1-3 on VHS, then the quadrilogy box set on DVD). I can imagine an occasional double-dip for some films (my copy of The Truman Show is pretty barebones, I could imagine a later release with more special features), but for the most part when I buy a Blu-ray, it’s meant to be the definitive, final version of the movie. At least for me.

The Pressure of Perfection

The unfortunate side-effect of this attitude toward Blu-ray is that it makes me unwilling to purchase Blu-rays that I don’t consider perfect. When I buy a Blu-ray, I want to be buying, the final, definitive, essential edition of the film. This has led to a Blu-ray collection that is sadly missing some of my favorite films.

Predator

As a simple example, one of my favorite action movies of all time is Predator. I would love to own Predator on Blu-ray, but there are two versions of the film.

The first version, released in 2008, is a simple conversion from the DVD. There’s not much in the way of visual upgrade, but even more importantly, virtually none of the extras from the Widescreen Collector’s Edition DVD (released 4 years earlier) are included. The commentary, deleted scene, and extensive featurettes were all removed for the Blu-ray. If I buy a Blu-ray, it needs to include the union of all possible special features from all DVD releases. Thus, as much as I want to own it, I have to pass on Predator.

Another Blu-ray of Predator was released in 2010, the Ultimate Hunter Edition. This version contains all of the extras the first Blu-ray should have had, porting over all of the content from the 2-disc DVD, and adding a few extra featurettes. Unfortunately, the video itself has been given the Digital Noise Reduction treatment. Digital Noise Reduction is an algorithm that attempts to remove graininess from low-quality source material – a lot of Blu-rays of older films are given the DNR treatment. The problem is, Predator is intentionally grainy – shot with low light in the middle of the jungle, the graininess is part of what gives the film its organic look. Applying DNR, especially with the dial turned up to 11, smooths out way too much.

Look at Carl Weathers’s face. He looks like a porcelain doll. The scenes in the jungle are even worse. I’d rather have the DVD transfer.

If I want the special features, I’d have to get Ultimate Hunter. If I want the better video (which isn’t great either, but at least it’s not in plastic mode), I’d have to get the first Blu-ray. I’m not willing to buy both because that annoys me on principle, so I’m stuck with neither of them.

The Thing

The Thing is one of the greatest pre-CGI special effects films ever made. It’s the gold standard for makeup and effects in a pre-digital age, the movie against which I judge any other. In addition, it’s a damn fine flick.

Unfortunately, the Blu-ray has had almost all of the extras from the DVD completely removed. It retains the best feature, the absolutely phenomenal commentary with John Carpenter and Kurt Russell, but that’s about it. Like with Predator, if I’m going to buy a Blu-ray, it needs all of the supplements from every DVD release, otherwise I feel like I’m not getting the real deal.

I have high hopes that the remake/reboot/prequel will motivate Universal to release a new edition of the Blu-ray with loads of extras, but I also worry that it might get the Predator treatment and have the excellent visual transfer altered.

UPDATE: While researching if The Thing would get a re-release with the remake’s release, I discovered that the UK version of the The Thing Blu-ray actually has all of the special features restored, including the phenomenal documentary (which was previously cut to shreds for a Picture-In-Picture exclusive feature on the US Blu-ray). The disc is region free, and it played just fine in my Blu-ray player. As advertised, it has all of the special features as well as a beautiful high-def video transfer. It also came in a much, much nicer case (with slipcover) than the picture on Amazon implied. Really nice, very happy with it. If you like The Thing, that’s the one to get.

Commando

Schwarzenegger just can’t get any love in Blu-ray.

Commando was the first action film I ever loved. I taped it off HBO and played it so much that it wore the tape out. Every month when the little “HBO This Month” booklet arrived in the mail, I’d look to see if Commando was airing that month so I could tape it again.

In 2007, the Director’s Cut of the film was released on DVD, complete with an audio commentary, some deleted scenes, and a couple featurettes. So can someone please explain why the only Blu-ray version of this awesome one-liner-fest is the theatrical version only and contains only a single special feature, the trailer? Fuck you, Fox.

Lord of the Rings

I would also love to own Lord of the Rings. The films are shot majestically, with wide sweeping landscapes and fantastic visuals. They’re perfect for Blu-ray.

There are two sets of Blu-rays. The first set is the regular theatrical editions, with many of the special features from the best versions of the DVDs removed. Screw that.

Recently, a the Extended Editions were finally released on Blu-ray in a beautiful boxed set, absolutely loaded with extras. I really want to buy it, but I’m unwilling to do so for one simple reason.

Here is a shot from the theatrical edition of the film on Blu-ray. This transfer is of much lower quality than the Extended Edition Blu-ray in terms of resolution and clarity, but what we really want to look at here is the color.

And here is the same shot, from the Extended Edition Blu-ray:

This is somewhat infamous for both Lord of the Rings fans and film aficionados. What’s particularly disturbing is that this green/blue color-tinting ONLY applies to Fellowship of the Ring. The Two Towers and Return of the King are both fine. It seems incredibly clear to me that this was an error in the transfer. The right thing to do is issue replacement discs after fixing the glitch.

Unfortunately, New Line’s attitude is that the colors are correct and Peter Jackson approves of them. Like I said, this is obviously a glitch, but instead of taking responsibility and fixing it, they’re claiming it’s meant to be this way.

Fellowship of the Green

I’m not interested in owning the box set of the theatrical editions, but I’ll never watch Fellowship of the Rings if I feel like I’m watching it through snot-covered glasses the whole time. Once again, another amazing Blu-ray I’m unwilling to purchase.

UPDATE: I borrowed a copy of these films from a friend to see for myself if I found it annoying. There is definitely a green tint to many scenes in the film, but not the entire film, which leads me to believe it was intentional for those scenes. Most of the time the green is within the Hobbit village, and the earthy tones fit there. There were a few scenes where the green didn’t quite seem appropriate, but I had to really be looking for them. Overall, the green is subtler than a lot of the screenshots above imply, and it was never distracting, nor did it affect my enjoyment of the film. It’s not ideal, but the Blu-ray is such excellent quality that it’s ignorable, so I’ve decided to get this set after all.

Star Wars

I would love to own Star Wars on Blu-ray, but I can’t do it for one particular reason.

First off, let me make something clear: I’m not a Star Wars purist. I’m not looking to get the theatrical editions or anything – I actually don’t mind a lot of George Lucas’s changes. A lot of the changes made to the original releases over the years have been vast improvements. The opening crawl re-rendering, the cleanup on matte outlines, the color fixes for lightsabers. All of it vastly improves the appearance of the aging films.

I even don’t mind a lot of the more invasive cosmetic differences that others complain about. The digital Dewbacks in New Hope, even the extra CGI garbage in Mos Eisley, all of it serves to better illustrate the size and scope of the organic life on the planets. The digital erasing of walls in Cloud City to show the sky in the background does a much better job of illustrating the nature of the city. Ian McDiarmid’s Emperor insert is a vast improvement over the original in Empire; the whole “superimposed chimpanzee eyes” thing never looked right to me, I could never tell if the original Emperor had eyes or if I was looking at something behind him. I don’t even care about the most recent addition of Ewok blinking. Let the little fuckers blink.

I even prefer the special edition ending of Return of the Jedi. Specifically, I always felt that the stupid Ewok song was a complete anticlimax. The special edition cuts to various planets celebrating the fall of the Empire. There’s even a scene on Coruscant where the citizens topple a giant statue of the Emperor. These scenes are an enormous improvement over the original ending. The film still ends at a personal level, with Luke seeing his father with Obi-Wan and Yoda, but it also conveys the sheer immensity of the accomplishment across the galaxy, and it nails the celebratory tone.

These changes are all cosmetic-only. They don’t change the story in any appreciable way. The story and characters from the original versions of the film are completely preserved by these changes – the films simply look better.

There are some changes, however, where this is not the case. These changes actually alter the story of the film, and as a result I hate them, because they’re not merely better-looking versions of the same movies, but are in fact slightly different movies.

• Greedo Shooting First – Yeah, yeah, everyone hates this change. When Han shot first in the original, it illustrated he was a rogue character. It showed his primary focus was his own self-preservation and survival. George didn’t like this because it made Han look like kind of a dick. But that’s exactly the point: Han is kind of a dick at the beginning of A New Hope. Over the course of the film, because of the experiences of the film, he comes to see value in things bigger than himself. Rather than flying away from the attack on the Death Star, he comes back and saves Luke. His character completely changes over the course of the film, but having him shoot only in defense ruins his arc. Not to mention no version of his double-joined neck seems to look right. The Blu-ray actually improves this by having Greedo and Han shoot almost simultaneously, but it’s still dumb.
• Jabba’s Visit – After the Greedo scene, Jabba the Hutt confronts Han. This scene is absolutely idiotic.
  

  This looks like a turd.

  First of all, Greedo JUST said that he was basically there to collect the bounty on Han. If Jabba can just waddle his ass over to Han whenever he pleases, why did he hire a bounty hunter? And why is Jabba, who ruthlessly murdered people in Jedi, so nice toward Han, a smuggler who dumped his shipment? Jabba even tolerates Han stepping right on his tail. This is the same Jabba that kept a man encased in carbonite on his wall? Totally changes the character, making a major villain into a cuddly comic foil. Not an acceptable change.
• Hayden Christensen – One of the most offensive changes is the replacing of actor Sebastian Shaw with Hayden Christensen for the ending of Jedi. This changes a huge aspect of character and story. When Vader dies, then shows up as Sebastian Shaw, it’s clear that he was able to become a Force Ghost because he had been redeemed, coming back to the side of good before death, thanks to his son Luke. When Christensen appears, the message is that Vader died still evil, so his younger self was the last “good” version of him. This means Luke partially failed to redeem his father. This completely alters the message of the ending, and is an awful change. Why the hell does Luke even recognize him?

UPDATE: I watched the new Blu-Ray version of Star Wars and I found the whole “Han Shooting First” issue to be much improved. The time between the two shots is so reduced and the entire scene compressed to so few frames that, even as I watched it in slow-motion, I could barely tell who actually shot first. It’s not as good as Han clearly shooting first, but it’s tolerable. I no longer consider that an objection to the special edition.

Those three two changes are my most hated of all of the changes (except one, more on that in a second). If those were fixed, I’d happily take all of the other changes without complaint. But why do they stop me from buying the Blu-ray? After all, those changes were introduced in the DVD versions, which I own.

No, my problem with the Blu-ray comes down to a single scene, exclusive to it. I’m way, way too bothered by Vader yelling “NOOOO” as he kills the Emperor.

My favorite moment in all of Star Wars is when Vader kills the Emperor. Seeing Vader watch his son being electrocuted, then coming back to the side of good, saving his son and simultaneously destroying the Empire and saving the galaxy, is something that makes my eyeballs just a tad moist every time. The feeling of elation I get when I watch that scene is unmatched by any other scene in the series.

It needed to be left completely alone. It was perfect and powerful. Adding Vader screaming “NO!” serves to undercut the drama of the scene, as well as remind me of the inferior prequel trilogy. I could never, ever watch an altered version of that scene and have the same joyful reaction I’ve had to it every time I’ve watched it since I was young. This relatively minor tweak ruined my favorite scene in the entire trilogy.

I know it’s nitpicky to refuse to buy a gorgeous Blu-ray boxed set simply because of 2 seconds of additional audio, but when it’s my favorite 2 seconds of the entire series, I don’t think it’s that unreasonable. It also really irritates me that Lucas would even make such a drastic alteration to a movie that he didn’t even direct. In fact, the original director is dead, so he can’t even tell George what a dipshit he’s being. It’s disrespectful.

In any case, I can’t buy the Blu-ray boxed set of Star Wars, as much as I’d like to own it, because of this change.

Other Movies

I’m stunned that, at this point, there are no Blu-ray releases of the following films:

• The Abyss – In a way, James Cameron’s best movie, because its anti-war message make it clear he’s not just some gun-loving douchebag, which greatly improves his other films.
• WarGames and Sneakers – Two of the best geek-movies ever made. Perfectly capturing the state of technology in the 80′s and 90′s, respectively, and using it to deliver forward-thinking messages. Science fiction that isn’t about aliens or spaceships. Both of these films are lightning in a bottle for me.
• Being John Malkovich – Enjoyable both as a purely surface-level zany comedy and as a deeply introspective philosophical exploration. One of my favorite comedies.
• Bill and Ted’s Excellent Adventure – I can’t possibly justify liking this movie, but I do.
• True Lies – I liked Schwarzenegger movies a lot growing up, okay? Fuck you, this list is over.

My Sad Collection

If I could own the definitive version of every film I love in Blu-ray, I’d be one happy little boy inside of a man’s body. But while double-dipping seems possible for Commando and The Thing, it’s looking decreasingly likely I’ll ever see an unmolested version of Star Wars or a color-corrected Lord of the Rings. In some cases I think it’s just film studios being lazy, but Peter Jackson and George Lucas maintain an inordinate amount of control over their films, so I think it’s really sad that they refuse to satisfy the very fans that made their films successful in the first place. Lucas is a particularly bad offender, as each version of Star Wars he releases seems to be, on the whole, worse than the last version.

Star Wars: Now With 50% More Rocks!

Back when I was unsatisfied with the DVD release of a movie, I could hold out hope that when DVD was replaced by something, the film would be released again in an edition I could happily purchase. But since I think Blu-ray is the last physical format for film, that means I won’t merely be passing on one version of a film’s release, but I will, in fact, never own it at all. That means I’ll never be able to pop some of my favorite movies in to show my kids, and never be able to experience a classic from a fresh perspective by sharing it with someone else.

Why are studios half-assing it with the format that they themselves herald as the ultimate movie-collector’s dream?

Blu-ray, I am disappoint.

There are no rules in software development. Some suggest the existence of best practices, but really there are only guidelines and recommendations.

Despite these truths, there are a number of alleged “rules” in software development, often suffixed with “considered harmful” as a reference to Edsger Dijkstra’s famous “Go To Statement Considered Harmful” essay. I want to look at one of these rules a bit more closely.

Magic Constants Considered Harmful

“Magic Constants,” also often referred to as “Magic Numbers” break what is regarded as one of the oldest “rules of programming”, dating back as far as the manuals for COBOL and FORTRAN in the 60′s.

Magic Numbers are numbers that are used and re-used in code.

salePrice = 0.90 * regularPrice;

Above is a simple example. The usage of 0.90 is generally regarded as bad. Instead it should be replaced with something like this:

const double DISCOUNT_PERCENT = 10;
const double DISCOUNT_FACTOR = 1 - (DISCOUNT_PERCENT / 100);

// ...

salePrice = DISCOUNT_FACTOR * regularPrice;

It’s hard to argue with this reasoning. The second code snippet is easier to read and easier to modify. In this case, this seems like a no-brainer. This is how “rules” are created.

Why Is It Harmful?

A lot of times, once a best practice or a rule becomes codified in the industry, it stops being questioned. The why is forgotten over time, and it just becomes a rule that everyone follows blindly. Sometimes it’s helpful to remind ourselves of the reasons for a best practice, to avoid becoming Cargo Cult Programmers.

Why is the first code snippet bad?

1. It has no name – It’s not immediately clear to the reader of the code why the 0.90 is there. The variable salePrice gives a good hint, but it takes a bit of inferring. The second snippet labels the value clearly as DISCOUNT_FACTOR, which is much clearer.
2. It’s reused – Though not directly reused in the example, it’s easy to imagine repeated usages of the 0.90 value. This repetition is less than ideal, particularly because…
3. It can change – If we start offering a 15% discount instead of a 10% discount, we’d have to find every usage of 0.90 and replace it with 0.85. It’s much easier to change it in just the one place.

Don’t Go Overboard

Not too long ago, I came across some code that made me realize that this rule is perhaps followed to the letter without being followed in spirit.

The code has been slightly modified to protect the guilty.

class Example {
  private static final String FORWARD_SLASH="/";

  public String getUrlPath() {
    return FORWARD_SLASH + "books" + FORWARD_SLASH + "all";
  }
}

When I first came across this code, my instinct was to replace it with a simple

    return Joiner.on(FORWARD_SLASH).join("books", "all");

This seemed so reasonable to me at first, plus I get a nerdection every time I get to use anything in Google Guava.

But then I thought about it. This is following the letter of the “don’t use Magic Constants” rule, but is it following the spirit of it?

The "/" has been extracted to a constant, so now it has a name. But is the name descriptive? No, the name is simply FORWARD_SLASH, which is about as descriptive as if in the first example we had simply done const double POINT_NINE_ZERO = 0.90;.

The constant is clearly being used as part of an HTTP request of some type, so how likely is it that the next version of HTTP would use a new character for path separation? It’s beyond unlikely, so the fact that this constant is easy to change doesn’t seem to buy anything.

It’s also significantly more to type and read. return "/books/all" is 35 fewer characters and much easier to read.

So what about when the constant is reused? That’s actually the most significant problem of all.

Imagine a second class, Example2:

public class Example2 {
  private static final String FORWARD_SLASH = "/";

  public String getPath() {
    return FORWARD_SLASH + "directory" + FORWARD_SLASH + "file.txt";
  }
}

Someone may notice the repeated constant and pull them both into a Constants class, using Constants.FORWARD_SLASH in both Example and Example2.

Now we’re really guarding against change. If that changes, we can fix both classes by changing only Constant!

Except, now you’re really screwed. Even on the off-chance that HTTP changes its path separator character, or in the more likely case that you move your deployment environment from Unix to Windows, you haven’t saved yourself any time. Why? Because these won’t both change at the same time.

If that happened happened, you’d have to re-split the usages of these constants so that you were only changing, say, the file path separators but not the URL path separators. You actually have to modify even more code, not less. It would be far easier to have used "/" in both files, then done a simple regex replace on the relevant files in the unlikely event that the character had to change.

Don’t Follow Rules Blindly

The code example I’ve provided wasn’t made up for the post, it’s real. That means that some of my peers felt like it would be bad code to have simply used the forward slash character inline. There’s no way around it, this comes from internalizing rules without internalizing reasons.

I don’t mention this code because I’m specifically bothered by overuse of the “Extract Constant” IntelliJ shortcut, or because I want to pick on old co-workers (though it is fun). I mention it because, for me, it exemplifies the danger (and hilarity) of following “rules” without giving them due consideration.

Any time you find yourself doing something because it’s the “right” way, stop and make sure you understand the reasons for that best practice. Take two seconds and make sure those reasons still apply, otherwise you’ll wind up writing code that might embarrass you later on.

Your code should strive to maximize readability and maintainability. If that goal is at odds with the occasional “rule”, break the rule.

So you have two projects, old-project and new-project. You want to end up with a subdirectory inside of new-project called old-project with all of the code from old-project, and you want to preserve that project’s history.

For the purposes of this demonstration, old-project is cloned at /home/machete/old-project and new-project is cloned at /home/machete/new-project.

At the end of this, we want there to be a /home/machete/new-project/stuff/old-project with all of the commits from old-project intact.

The way we’re going to do this, it’s going to completely overlay old-project on top of new-project, so first we need to adjust the directories inside of old-project

cd /home/machete/old-project
mkdir -p ../stuff/old-project
mv * .gitignore ../stuff/old-project
mv ../stuff .
git commit -a -m "Preparing old project for move"

This just moves all of the files in old-project into a subdirectory structure matching what we want to have inside of new-project, then makes a commit.

Next we need to copy the history of this repository into new-project. So we don’t have to push our temporary move anywhere, we’re going to add our local directory as a remote git repository, then pull its changes in.

cd /home/machete/new-project
git remote add temp file:///home/machete/old-project
git pull temp master
git remote rm temp

This pulls the entirety of old-project’s history in. Since we did a pull (a fetch and then a merge), we will have a new commit at HEAD that has two parents, one for the regular old-project codeline, and one for the old new-project codeline.

That’s it, you can push new-project anywhere and the next fetch will pull down all of old-project‘s history.

I’ve had a lot of people ask me about how best to set up pair-programming environments at work, so I’m going to take you through a number of different ways to pair-program and discuss the advantages of each.

Level -1: Not Pairing

The first level of pairing is something I see surprisingly often. An inside-corner desk, typically an individual’s workstation. Another person scoots their chair over and leans in, looking at the same monitor.

It seems like no coincidence that virtually everyone I’ve seen “pair program” this way dislikes pairing. That’s because this setup is not actually pairing. It’s just coding with someone watching over your shoulder.

Nobody likes having someone read over their shoulder, let alone read code they are writing. This set-up basically ensures that the person writing the code (the driver) and person thinking about the next steps (the navigator) never trade places. Trading places involves not merely sliding a keyboard over, but actually scooting rolling chairs out of the way, so it never happens.

Just as importantly, the two programmers are not the same distance from the monitor. The monitor “belongs” to the person sitting closest to it, so the other person is really just watching. The navigator will probably just zone out and think about something else while the driver codes away, confident that their pairing partner is helping ensure they don’t make mistakes.

This kind of pairing is a waste of time. Corner desks are the office furniture from hell. Put it in a cubicle so that it’s basically impossible for two people to fit and you’ve essentially ensured that nobody on your team will ever pair program.

Level 0: Basic Pairing

The first level of actual pairing is simple. A rectangular desk with two people sitting at it, sharing a computer.

The great advantage to this setup is that it’s free. As long as you don’t make the mistake of filling your development area with corner desks, all that needs to happen here is have a second person scoot up to another person’s workstation.

The two developers need to make sure they sit equidistant from the monitor so that neither person “owns” the machine and both people feel like they can grab the keyboard at any time. If this is one person’s workstation that’s been re-appropriated as a pairing machine temporarily, the normal user of it may be more likely to hog the keyboard, so it’s important to be careful to avoid that.

One of the problems of this set up is that it’s probably not a devoted pairing machine. This means that the environment will be configured for the workstation’s usual user. Keyboard bindings, IDE color schemes, fonts, installed programs, and so on won’t be what a pair agreed to use, but what a single person prefers. The person who scooted over may feel like a fish out of water in an unfamiliar environment, leading to another situation where one person is doing all of the driving.

One way to help this problem is for the owner of the workstation to make a second user on the workstation, with its own desktop. Most operating systems make it easy to switch between users these days, so having a regular user and a pair user that can be switched into easily is nice. The only problem is that, of course, sharing information between users is difficult, so it may be hard if there is already work-in-progress when the pairing starts.

At least this is better than the previous level, since both people can see the monitor equally well.

Level 1: Good Pairing

At the next level, we add a second keyboard and a mouse. Each programmer has his or her own input device set, but the programmers share a monitor.

This is good because it’s easy to upgrade an existing workstation. All you need to buy is another keyboard and mouse, both of which are generally dirt cheap.

This empowers both developers to feel like they “own” the machine, and they can feel free to take control and write code without any ceremony whatsoever. Because of the setup, it nearly forces people to sit equidistant to the monitor, further aiding in the sense that both programmers have equal right to code at the machine.

One con of this setup is that there are sometimes “mouse wars” – two people using their mice simultaneously and causing problems. This doesn’t happen all that often and a little communication resolves it quickly, so it’s easy to move past.

Another problem with this set up is that a lot of mice these days are bluetooth, particularly on Macs. OS X has given me a lot of trouble with two identical bluetooth mice connecting to it simultaneously, it’s much easier to use a wired mouse.

The biggest win here is that the machine stops seeming like it’s a single developer workstation. Even when only one person is at it, it “feels” like a devoted pairing machine because there is an extra keyboard and mouse at the machine. This makes people less likely to apply strange customizations that alienate other programmers.

Finally, the biggest problem with this set up is that, because it forces people to sit equidistant to the monitor, both programmers may find that the monitor is actually too far away from them. Increasing the font size in the editor helps this greatly, but it still can lead to eyestrain. Large monitors are very helpful here.

Level 2: Great Pairing

At the next level, you add a second monitor to the machine. These monitors are mirrored, which can be done with either software or DVI splitters.

Both programmers feel equal control over the machine, and there are no eyestrain problems. This is a really pleasant pairing situation, and it only adds the cost of a keyboard, mouse, and extra monitor to a regular workstation.

One common problem is that developers, rather than mirroring the desktop on both monitors, may want simply expand the desktop to both monitors. This is a mistake. The main IDE will be on only one of these monitors, and whoever is sitting at that monitor will eventually become the permanent driver and you’re in a situation no better than the Level -1 setup. This is even worse on OS X, where even the menu bar “belongs” to only one of the monitors (though this can be somewhat fixed).

The other problem is that the desk can get pretty cramped, particularly for the person the left side, since their mouse may be constantly hitting the keyboard of the person to their right.

Level 3: Awesome Pairing

The cramped problem can be solved by simply adding an extra desk. But rather than pushing them next to each other, push them perpendicular to each other.

In addition to giving each developer plenty of space to move around and be comfortable, this sets up both programmers to actually FACE each other while working together by only slightly turning their heads.

Setting up pairing in this way makes a very noticeable difference right away. Switch a pair from Level 2 to Level 3 and you’ll notice them talking a LOT more. Developers will discuss design, bounce ideas off each other, and generally collaborate much better, simply because they are facing each other.

This setup takes up quite a bit of room and it looks a little silly, but it is absolutely fantastic. It leaves room for sticky notes, pens, a developer’s tablet or laptop, and lots of other things. The entire setup ‘feels’ like a pairing station, and it works exceptionally well.

There aren’t really any problems with this setup, though there is one way it could be better…

Level 4: “Pair”-adise (ha!)

Give the pair an extra laptop to share, put it between the programmers.

Often the navigator may want to look something up on Google or StackOverflow, but doesn’t want to take the driver off his current task to do so. Having a laptop sitting between the programmers allows either one of them to shift away from the code to look things up or even try things out in a REPL environment.

Another nice thing about this setup is that two identical set ups can be pushed together to make a nice square pairing station hub:

Yeah, it’s extremely expensive to go from Level 0 to here, but it’s an absolutely amazing setup. You may quickly find that, with pairing stations set up like this, developers no longer wish to work alone at all.