So my strategy is as follows: I use Windows to run web browsers, the odd desktop app like Photoshop, handy GUI utilities like calculators, media playback, and the like. On top of all this, I have installed VirtualBox and the easy-to-install Windows version of Vagrant, running a VM with the Ubuntu server distribution (I have no need of the gnome or any other GUI therein.. yet. That may change when I need to start running Selenium-based tests, but it’ll do for now). I use two PuTTY windows – one on each monitor – to connect to the VM, which is configured to startup at boot. I forward the necessary ports from the host to the guest (made easily configurable by Vagrant) and provision the whole affair with Chef.

Internally, I use tmux, vim, and all the usual CLI tools of the trade to ply my own. Servers, databases, services and the like all run internally to the VM, and the only crosstalk I’ve yet needed to make use of is accessing guest-hosted websites with my host-based browser, a feat easily enabled by Vagrant’s port forwarding. RDBMS GUIs will likely be needed soon enough, and the same solution will presumably apply thereto.

So, how has it been? So far, the experience has actually been pretty pleasant. After getting the VM’s hardware and the general translation and keyboard layout bells & whistles configured to my liking, I feel for the most part that I’m back in my native Linux land when developing. No issues arising from the system being a VM have yet reared their heads, and aside from the MS chrome peeking around the corners of my terminals, I could almost be convinced that I’d never left. As far as the desktop bit goes, I’m still acclimating. However, the fact that the sound, the graphics, the power management – all the hardware in general – works perfectly without my having to tweak arcane configuration settings is a very great improvement over my earlier experience; and not having to forcefully implement hacky workarounds is a weight off of my shoulders.

That all said, I do have a few qualms. If you know of an acceptable solution to any of these, please comment and share!

1. PuTTY is the best SSH client out of all those I’ve tried, and it’s not that great. It’s profile saving/loading system is nightmarish from a UX standpoint, the built-in fonts are fugly (though I can presumably use others once installed on the OS), but the thing that irks me the most is that I can’t go fullscreen! I have absolutely no need to see any of that garish MS chrome on the edges of my screen, and having it present detracts from the real estate available to me for tasks of actual importance, as well as simply clashing aesthetically.
2. The price of the full-featured Windows is prohibitive. There are certain features available only in the Professional or Business or whatever-they’re-called versions of Windows 7 that I would’ve found quite useful, but that I don’t really count as being worth the extra few hundred I’d have to lay out so to acquire (group policy editing comes to mind).
3. No real shell script to speak of. Sure, there’s VBScript and whatever that trash is that passes for a shell in cmd, but these simply don’t possess the power and terseness of bash.
4. The godforsaken automatic restart after update. I understand that Windows needs to update itself frequently in order for the boys in Redmond to have the slightest hope of plugging security leaks as fast as they’re discovered, but I do not at all appreciate having my viewing of some video on Hulu interrupted without discernible warning by my computer suddenly rebooting itself. Turning this trash off is apparently one of the features they reserved for the “Professional” users, and I quite frankly don’t see how this isn’t a bigger issue among Windows users at large. I understand they’ll “fix” this garbage in Windows 8, but for now, it is pretty off-putting.

Anyway, those rants aside, all in all my experience has not been unsatisfactory. Neither, however, has it been revelatory, and I believe I’ll need more time to make a decision one way or the other. I’ll keep you all posted!

Due to many factors, setting up Linux turned out to be Hell. Both the kernel and GRUB wouldn’t have the ability to recognize the aforementioned pseudo-RAID array as a single disk until later (I’m still not sure if GRUB does), so I first had to effectively wipe the filesystem in its entirety and destroy all partitions; turn off the pseudo-RAID functionality in the BIOS (a miracle they allowed me to do so, considering everything else they expressly hid therefrom), re-partition the two drives as truly separate devices, and reinstall Windows on one disk while setting up Linux on the other. That was a night of my life I’ll never get back, and I considered dropping Windows from the lot entirely, but figured it might be handy to have as a last resort / testing platform and so opted to keep it at the last moment.

Finally having completed the installation, I booted up Linux for the first time and went about the standard post-installation rigamarole of bringing in my dotfiles and configuration settings, installing the basic tools I use everyday, etc. There were other problems during the process, but I cannot fairly lay the blame for them at HP’s feet. Switchable graphics – as this machine possessed – were still a relatively new and uncommon affair, and the distro kernel hadn’t been built to include certain systems associated therewith. So that’s one kernel rebuild right there, and I can assure you there were many more as time went on. Other issues include ACPI issues that to this day have not been completely resolved and reappear intermittently and seemingly randomly, a total inability to recognize the microphone, and other hardware-related woes. Still, I persisted, expending the elbow grease to fix what I could and resigning to live with the rest. When finished, I had a perfectly usable little hi-res Linux machine upon which to do my development that I could call 100% my own.

I have now used this machine for a year, and have thoroughly enjoyed it… when those issues I said I’d “live with” weren’t driving me absolutely insane. Lately, however, I been having doubts about my choice of OS, cataloged as follows:

1. I had started to miss certain proprietary software that is not made readily available on Linux (Photoshop comes to mind – I need it rarely, but when I do, GIMP simply isn’t an adequate substitute). I could run it on Wine, sure, but all my experience with Wine has been less than pleasant, and I didn’t want to go through that business again.
2. I was becoming sick of the desktop quirks. I love Linux, and the developers of the various distros have my absolute and utmost respect; but the unfortunate fact is that drivers for hardware show up there last. Due to its low marketshare among PC OSes vendors have little incentive to develop them themselves, and in many cases, open-source and initially imperfect options are all that is available. That said, give it year or so, and you’ll likely see solid drivers made available; but that year is one in which I’m not getting my full money’s worth.
3. Honestly, I was doing a bit of introspection and reexamining my prejudices against Windows. Why do I hate it so? Could it be that I’m not giving it a fair chance, not having used it in nearly 10 years? Windows 7 is purportedly a vast improvement to Vista; maybe it was time to give it a chance.

Because of these and other thoughts, I decided to try an experiment: I would switch back to the Windows 7 installation on my other, nigh-forgotten drive and try it out as my primary desktop for a few weeks, and see how it went. This post is the story of the start of that journey, and how i reached a place where I was at least not anthropomorphizing my machine in the most violent of fashions.

Now, Windows has its problems: certainly it’s an absolute crap development environment if you want any real, low-level control of a machine, or if you want to do any development in a language that wasn’t pinched off from the Great Golden Sphincter of Redmond. The registry’s a horrid design that – despite purportedly being recognized as such by its own engineers – has stubbornly persisted through multiple versions and will almost certainly be there in the next. The built-in command-line interface (cmd) and nearly every third-party one I have yet discovered are all so underpowered as to be little more than curiosities and toys. I won’t even get started about security. However, it does do one thing quite well: provide an ultimately pleasant, consistently usable desktop environment. For everything else – as they say – there’s Linux.

Continued in Part III!

I have been a *-nix man for many years, starting with Mac OS X and it’s largely-FreeBSD/NetBSD-derived platform. I have literally nothing bad to say about the software of Mac OS X. Nothing. I adore it. What I don’t adore is the inflated price of the hardware. Certainly, it is of excellent quality; but I in my frugality have this crazy idea that I shouldn’t have to pay what Neal Stephenson referred to poetically as “<expletive-redacted>-you money” (e.g. $2500+) for a laptop with ultimately mediocre specs. I can get a laptop with just about *twice* the power for virtually half the price from a fully reputable manufacturer if I make what I consider to be the relatively small sacrifice of a sexy, top-of-the-line desktop experience and the social mating plumage that is that familiar, brushed aluminum case.

Up until recently the cost wasn’t really a factor, as my development machines were supplied largely by my employers, including Centresource. My first day on the job, CS set me up with a brand-new, perfectly splendid little 13″ MBP, 4GB RAM, 250GB HD (this was before they were offered with SSDs) and all the other usual trimmings; in addition to a new 27″ external monitor and even one of those mini-display-port-to-VGA adapters. This machine was an absolute pleasure to develop upon for nearly any task I was asked to complete. Unfortunately, as the size and scope of my workload increased (both as commissioned by CS as well as my own, personal, “for-fun” work), I began feeling the pinch of those 4GB. So, of my own volition, I sent out to NewEgg and got myself a couple of 8GB chips for a total of 16GB RAM. Good heavens, did that machine fly now.

However, I was now faced with a few issues:

1. CS owned the machine, but I owned the RAM. This isn’t really a tangible problem since I don’t expect to be leaving any time soon, but it was nevertheless an admittedly personal reservation based largely in my perhaps-paranoid concerns for privacy and security.
2. Being that I have crap eyesight to begin with and like viewing multiple documents simultaneously, 13″ was becoming a bit of a pinch-point for my own development whilst away from a desktop station with its extra monitor, whether at home or the office. I frequent coffee shops quite often as remote work environments, and the degree to which my productivity faltered as a result of being limited to the resolution possible on this machine was becoming unacceptable to me (note: I have what some might consider to be ridiculously high standards for my own productivity). In short, I wanted more real estate on the go – much more; something like 17″

This being the case, I decided it was high time I bought my own computer, since my last personal purchase of same had been nearly 4 years back and a desktop unit besides (as well as now lying disemboweled and largely forgotten upon a table in my garage). I looked at the prices for an Apple laptop with the specs I desired (even the refurbished models), and almost immediately made the decision to buy a PC and switch to Linux as my main desktop environment – a decision I had toyed with in the past but never really committed to.  However, in order to maximize my very recent investment in the aforementioned memory, I had to find a machine that would accept the same chips in the same configuration.

I found several candidates, but for the money I settled upon an HP Envy 17″. I will say here that I will never buy another HP computer again: they had loaded down Windows with a truckload of proprietary crapware, they lock out almost every part of the BIOS worth mentioning, and they had taken up all 4 permitted primary partitions on the weird Intel pseudo-RAID array (one with a restore disk-image because they’re too cheap to print the thing to a DVD, the other with something called HP_TOOLS the purpose of which I cannot readily fathom and have no desire to learn lest it anger me further). Of course, my usage of Windows while in possession of this machine was intended to be minuscule if present at all, and so I quickly set out about installing my preferred Linux desktop distro, Linux Mint (then version 12).

Continued in Part II!

Now, while I’m totally guilty of bandying around big scary terms like “asymptotic notation” (I’m a notorious stickler for nomenclature), what this boils down to is the following mathematical notation (and its related brothers, which we’ll get to later):

[O(g(n))]

Most typically, you’ll see this used and referred to not as (O(g(n))), which doesn’t serve much purpose unless we know already what (g(n)) is, but rather in terms of a specific (g(n)), say, (n^2):

[O(n^2)]

Moreover, for the purposes of this discussion, we’re going to look primarily at the following notation style:

[f(n) = O(n^2)]

So what on earth does this mean? Well, let’s think about algorithms. What is an algorithm? Simply a series of instructions for performing some task, right? In computing specifically an algorithm is implemented as an actual, written program in your language of choice. But under the hood, mathematically, an algorithm is a function (sometimes pure, sometimes not): it takes some input(s) and delivers some output. In the above block o’ math, let us equate (f(n)) with some algorithm we would like to implement, say, sorting an array of integers from least to greatest. With an algorithm such as that, you would give it an array of dubiously sorted values, and it would give you back an array containing exactly the same elements but in sorted order. Represented mathematically, we have:

[s(a)]

where (s) is the algorithm function itself, and (a) is the array to be sorted. Now, let’s keep in mind that there are many different ways of going about sorting an array – naturally, we would like to pick the fastest one for the task at hand. So in order to know anything about the performance of an algorithm, we should probably come up with some way to represent how long it takes to run. To wit:

[T(s(a))]

represents the “time” (T) it takes to run algorithm (s) on input (a). OK. So, how can we begin to reason about what the range of this function might be? Actually, perhaps that’s jumping the gun – what would really be the domain of this function? What measurement of your general work-a-day sorting algorithm would dictate how long it takes to run? The answer, my friend, is the size of the input: it should make sense to anybody who’s actually had to do it that sorting a 10-element array is a heck of a lot faster than sorting a 10,000,000-element array. So, really, our (T) function can be abstracted further as a function of (n), where (n) is the size of the array to be sorted:

[T(n)]

Since the value of (T(n)) will grow as (n) grows (presumably), this seems like a solid footing to start our thinking upon.

Alrighty. Now that we’ve got some notation to start thinking about how we’ll build this bad boy, let’s actually pick a real, concrete algorithm and think through it. For the purposes of simplicity and succinctness (cue laughter), I’m going to go with Bubble Sort. If you want to learn more about the actual algorithm, I suggest you read the wikipedia article linked to above, because I’m gonna skip over a fat exposition on what it actually does and how it does it in favor of thinking about how long it takes to do it, and specifically how long it takes to do it to the worse possible case of input: an array that’s already been sorted, but reversed. Please note I have copied the following pseudocode directly from wikipedia, and credit therefor is due directly to the author of the page linked to above.

OK, so that’s the algorithm from wikipedia – but what’s all that nasty-looking business on the right? Put quite simply, that’s our best guess as to how long that line of code takes to execute! Note that each line is some function of (n) and some constant (c_{i}). Now if we wanted to figure out exactly how long this algorithm takes to run, we’d need to know the value of those contants, e.g. (c_{1} = 12.2ms) or something. You’ll notice that some lines only seem to take a constant time to run; that’s because those lines are only executed once regardless of how big the input is. Other lines are the associated constant multiplied by (n) – those lines will execute once for every unit of input. Still others are multiplied by (n(n-1)) – these lines are executed (n-1) times for each input. Now, handily, we can figure out our overall formula by just adding all these things together:

[T(n) = c_{1} + c_{2} + c_{3}n + c_{4}n + c_{5}n(n-1) + c_{6}n(n-1) + c_{7}n(n-1) + c_{8}n]
[T(n) = c_{1} + c_{2} + c_{3}n + c_{4}n + c_{5}n^{2}-n + c_{6}n^{2}-n + c_{7}n^{2}-n + c_{8}n]
[T(n) = (c_{5} + c_{6} + c_{7})n^{2} + (c_{3} + c_{4} + c_{8} - 3)n + (c_{1} + c_{2})]

But it turns out that the precise value of each constant is practically useless – the constants in question represent such complex matters and concrete facts of the real world as language of implementation, hardware specs, how many other processes are fighting for CPU time, etc. Remember that we only really care about the performance of the algorithm – not the performance of the hardware or implementation thereof, which is not affected by the algorithm itself. So we can happily simplify our job by just getting rid of all those pesky constants!

[T(n) = n^{2} + n]

Wow, much nicer! But guess what: it gets even simpler. Since, for large enough inputs, the contribution of the lower-order term (n) makes virtually no difference to the output number, we can happily drop that too:

[T(n) = n^{2}]

And voilá! Unfortunately, we’ve boiled this timing function down so far and stripped so much from it that we can’t really say that (T(n)) is exactly (n^{2}), just that (in the worst case) it follows a similar curve. More precisely, we have virtually guaranteed that, for large enough inputs, it can never be bigger than some constant (c) times (n^{2}). This is the crux of asymptotic notation – specifically what is referred to as “Big-O notation”. As such, when we say that:

[T(n) = O(n^{2})]

What we mean is that there are some constants (c) and (a), such that for all (n) where (0 le a < n), we know that (T(n) le cn^{2}).

It should also be pointed out that the notation’s use of the “equals sign” is a little unusual – we’re not saying that (T(n)) is equal to (O(n^{2})), but that it is of equal or lesser order to (n^{2}). This might be a bit of a trick to wrap your head around at first (it certainly was to me). If I’d have written the notation myself, I’d have tried to use some symbol that didn’t already carry all the connotations and denotations the “equals sign” itself does; but c’est la vie – this is the way it’s done. Another way (in fact, the proper way) to think of it is to think of (O(n^{2})) being some set of functions that follow the above definition, and for the notation

[T(n) = O(n^{2})]

to in fact mean

[T(n) in O(n^{2})]

i.e. that (T(n)) is an element of the set (O(n^{2})).

OK, so we’ve been able to put an upper bound on some hypothetical order of our function (T(n)), but what does that really tell us? Not a whole lot, in isolation. But it really comes into play when you consider other algorithms, such as, say Merge Sort, which is bounded on top not by (O(n^{2})), but by (O(nlog_{2}n))! Graph those two functions and here’s what you get ((n^{2}) is in black, (nlog_{2}n) is in red):

This is a bit of an oversimplification, but sufficient to demonstrate the idea – notice that very quickly, (n^{2}) begins to overtake (nlog_{2}n), and continues to do so, the gap getting ever wider as n gets ever bigger; and just like in golf, the lower score is the one you want.

So, in what I hope was nutshell-ish if not perfectly so, that’s the basics of asymptotic notation! There are other, related notations like “Big Theta” (Theta(g(n))), “Big Omega” (Omega(g(n))), and the lower-case versions of omega and o, but I’ll leave those to you to explore.

Finally, as a disclaimer, I have tried to make the math herein as simple as possible for the purposes of the demonstration, and I could easily have borked something up terribly (I’m still getting the hang of LaTeX). If you spot an error, comment and I’ll see that it’s corrected. Thanks!

In your development environment file at /config/environments/development.rb, place the following command in the <Your App>::Application.configure block

ENV["RAILS_ASSET_ID"] = ''

Voilá! Timestamps gone in development.

class DeveloperArsenal < Programmers::Toolset
  include CentreSource::JeremyHolland
end

1. What tools do you use daily in the course of your development, and why those tools in particular?

1. MacVim The more-or-less canonical port of the fantastic Vim text editor (itself an extension of the vi editor). While the benefits the GUI MacVim offers over and above the native CLI vim are minimal for an experienced user, I wholeheartedly recommend MacVim for beginners new to the editor; you'll still retain use of your mouse and all the classic OS X key shortcuts (cmd-s, cmd-w, etc) so you can stay productive while learning the new paradigm. Yehuda Katz has a great blog post on just this subject.
2. iTerm2 Hands-down beats the native OS X terminal application. The features I particularly like are automatic copy-to-clipboard on mouse selection of text, true fullscreen, the ability to split a single pane both vertically and horizontally so as to keep multiple shells open and visible simultaneously (even in the aforementioned fullscreen mode), and a number of other little perks and pluses.
3. Sequel Pro Holy smokes, I cannot say enough good things about this product. It is a shining example of doing one thing and doing it incredibly well - which is providing a simple, beautiful, and easily usable interface that just plain old shows you the data in your database. No crazy-ass graphical query builders, no wonky schema fiddling screens or massively over-complicated index-generation wizards, none of that crap. Everything provides all the functionality I need in what is likely the best possible interface with which said functionality could be represented. My only complaint is that it's MySQL-only, though myself and others are crossing our fingers for PostgreSQL and SQLite support down the road a ways.
4. Google Chrome Simply the best, fastest browser out there. I used to be a Firefox man, but that browser's javascript engine needs to get off its behind and catch up to the rest of the world.

2. How did you get into development/programming/engineering, and what keeps you in it?

I've always kind of been intrigued by software development. I started with BASIC on my family's Apple IIGS (10 PRINT "[redacted - ed.]"; 20 GOTO 10;), though I obviously didn't publish any world-changing papers based on my experience therewith. I had tooled around with HTML while I was still in high school, back in the SGML-esque days when tag names and attributes were still written in all caps, and even started studying computer science at college. Of course, college being college, I promptly decided to go be a bohemian and make no money. Subsequently, real life being real life and lack of money being a serious impediment to the living thereof, it wasn't long before I took up the programming mantle once more, fell back in love with it, and made it the focus of my career. So here I am today!

3. Who is another programmer or developer you admire, and why?

Martin Fowler. His books and experiences have contributed a great deal to my own understanding of object-oriented programming, and they remain among the first volumes I reach for when I'm facing down a particularly difficult modeling problem. When called upon to train new developers, I put Patterns of Enterprise Application Architecture on their required reading list, especially since a great many patterns comprising the Ruby on Rails framework are implemented directly from the book in question.

4. How do you keep yourself up-to-date with the latest technologies and what new or upcoming tech are you excited about?

I never stop being a programmer, and I never stop learning new things. While I definitely don't subscribe to umpteen-thousand RSS feeds, I have amassed quite a library during my career (of which I am quite proud - picture below), and am constantly reading a book at least somewhat related to the subject. As far as getting excited about new tech goes, it takes a lot to impress me, so said excitement is pretty rare nowadays. Still, if I had to say something, I'd say graph databases: still in their infancy, but I think a decade or so down the line we might be seeing some awesome implementations and uses for same.

A few aren't mine, but it's good to have our developer bookshelf in one place.

5. What's your favorite language of the moment? Why?

Ruby, for its flexibility and power; Erlang is a close second, because I'm a lambda calculus nerd.

6. Do you have any advice for nascent developers?

Get yo' math on, read like your life depends on it (it does), and most importantly don't cop an attitude. Help your fellow developers when they need it, and accept the help of the same when offered. The quality of our work always goes up when we work as a team (e.g. Pair Programming, which I also recommend you participate in early and often).

Think something along the lines of, say, the attribute “color”: valid values for “color” might include “red”, “blue”, or “chartreuse”; while it’s certainly a large set, it’s still finite in the sense that there are not an infinite number of values that would satisfy the condition of being a color, and in that the valid values have no common regularity – i.e. the validity of any string cannot be determined by a regular expression match as said validity is determined purely by semantics, with no discernable extrusion into syntactical space (at least in English and most other germanic and romance languages).

Now, MySQL handily supplies a column type specifically for this purpose: ENUM. When defining an ENUM column in MySQL, one must define along with it a list of its possible values. In the event that one attempts to store a value not in this list in the column in question, the database throws an error, thus handily preventing invalid values from entering the dataset and corrupting the state of the database.

However, when using a database abstraction layer in order to maintain database portability, we unfortunately lose this capability as it is more or less unique to MySQL in the base column-type implementation. PostGRESQL has the ability to create new column types which are predefined as ENUM (via a wholly different paradigm), but both Oracle and SQL Server lack the capability completely.

Given the above, it has been the habit of Rails developers to enforce ENUM-style behavior at the application level via (at least) a call to validates_inclusion_of, and often an overriding of the attribute accessor methods to allow the assignment and retrieval of the values as ruby symbols while still actually persisting them to the database as strings. An example follows:

class Paint < ActiveRecord::Base
  validates_presence_of :color, :in => [:red, :blue, :chartreuse]

  def color
    read_attribute(:color).to_sym
  end

  def color=(value)
    write_attribute(:color,value.to_s)
  end
end

Now, while this is a relatively small quantity of code, it has been my personal experience that the need for an application-enforced ENUM pops up often enough that it becomes somewhat tedious to repeat this pattern over and over and again for different attributes. As such, we at Centresource have just released the enum_simulator plugin for Rails 3+, available under the MIT license at our github repo. It isn't much, but once installed, the code above can be condensed to:

class Paint < ActiveRecord::Base
  enum :color, [:red, :blue, :chartreuse]
end

The validates_inclusion_of and symbol<->string typecasting are defined by the plugin, so we can shorten everything down to one call to the class method enum, wherein the first argument is the attribute in question, and the second is an array of possible values. Install and enjoy!