The Flash and the Slog

Programmers (especially interviewers) seem to measure skills against a “flash of insight” standard: if you have four hikers, walking at different rates and arguing about which coin is counterfeit, does the lady get eaten by the tiger?

I mostly get stuck, though, in “slog out of it” sorts of issues: the latest version of Visual Studio has some grudge against an old library, or someone has overloaded ‘string’ so it behaves very oddly, or Mercurial has eaten my patches and no grepping can find them. This turns into an Internet Slog, where somehow all the unhelpful newbie forums have SEOed their way to the top of Google.

And such slogs can be particular to very small scopes. What prospective employer will care that I’ve incorporated old string manipulation libraries into a recursion exercise? At the end of the day, they’ll never know that I skipped number 4 on a self-assigned problem set. And will I really be hired in a Unix environment? Odds are, I’ll have to start all over to learn the ins and outs of some other code repository system; how much of this source control knowledge will map to that?

Other slogs, though, remind me of the Faun’s statement at the end of the Narnia world: “The further up and the further in you go, the bigger everything gets. The inside is larger than the outside.” Human knowledge is wonderful this way: I could start by reading up on updating old libraries and VS restrictions, then swim further into rationales behind language features and updates, and ultimately end up deep in Theory Land.

This would not be so bad if I could count on multiple Theory Lands a) having some solid bottom and b) having adjoining borders, so I could build a fantastic architecture of applied skills with perfect foundtations.

The problem is that I don’t believe there’s ever a bottom; a friend of mine was working with a company that cared about 0s being faster than 1s, and below that, there are people working with materials, and then sub-particles, and dear God but–where does it all end?

I have to depend, I think, on building blocks study enough for the task at hand. I do not need to understand the kernel for my current projects, so I can leave that aside for now. I do need to understand source control. I haven’t run up against design patterns yet (since my projects are so small); I should, however, have a rock-solid grasp of references in recursive functions. This means that sometimes my Faun Slog will take hours or days, but because I’ll limit the scope to “helping me complete the task at hand,” I won’t get thrown too far down the rabbit hole.

And I will keep adding projects that demand sturdier and deeper foundations–which, I suspect, will become the sorts of giants from whose shoulders I can touch insights so easily, it will look like a flash.


Leave a Reply

Please log in using one of these methods to post your comment: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: