My Programming Philosophy: Not the Last X Percent

When you’re a mediocre programmer (read: me), it’s easy to conjure great ideas because you know their solutions to be possible.

It’s slightly more difficult to implement the main constituent concepts of your idea, but only (and hopefully) because there’s some research and learning involved. Recognizing your skills as mediocre, there’s likely a better way to do things than your current level of knowledge permits. A bit of reading and examination of examples set forth by those less-mediocre than you result in slightly-more-elegant code for your idea.

It may be difficult to stitch together all your elegant concepts into the idea, because you want the implementation of your idea to be elegant, as well. Don’t you?

This is the universally-loathed “Last x Percent”.

If you are unfortunate enough to have developed each of the elegant concepts in isolation, your stitching will involve dealing with myopically-complex data structures, and attempts at creating workable interfaces to them. It will be hellish; you’ll wonder why you opted to do things the way you did. But you’ll be too far into the project to go back and change the basics of the concepts to retain their elegance, yet offer graceful interaction.

Or will you?

The majority of the work you should do after dreaming up a great idea is: Work it through completely, or as completely as you can.

Start by thinking of how you would implement the whole shebang with your current (mediocre, remember?) knowledge and skills. Then, make a list of things you wish existed that would make it easier (tools, definitions, whatever). Next, see if those things already exist; do a moderate amount of homework, but don’t kill yourself. If you can’t find them readily, you already have a concept of what you must do to create them. Perhaps you’ll discover new tools, definitions, whatever that will facilitate making those things on your own.

Either way, you’re making progress.

But there has to be a sweet spot.

As you learn more, your functional knowledge will grow, and how you envisage the path to realizing your elegant idea will change. As every programmer’s painful memories can attest: Scope creep is bad. But it’s worse when it’s self-imposed.

You must consciously determine when you’ve learned enough. You have to be able to cut bait on theory and start typing code that works. Otherwise, you’ll never get it done.

Fulfill your personal need to collect fragments of new knowledge. Feel satisfied that you’ve done enough homework to become a better programmer.

Then do your shit. Make it work.

You can always come back later and repeat the process.


Leave a Reply

Fill in your details below or click an icon to log in: 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