Careening Toward Craftsmanship: My First Assessment at Dev Bootcamp

**For the uninitiated, arrays are [“structures”, “like”, “this”] and the items in them are counted in order: 0, 1, 2. Hashes are {noun: “structures”, preposition: “like”, pronoun: “this} and you can get their values if you know the right keys: :preposition returns “like”. Don’t worry about the differences too much, just know that they’re similar but different, and they each have suggested uses, kinda like spoons and forks. This post is about how I keep trying to eat ice cream with a fork.**

Alright, alright, Captain Persnickety. It was technically my first mock assessment. But it still mattered, and it still felt a lot like a test.

Thursdays at Dev Bootcamp are solo coding days, and during the second week of the first two phases, the biggest solo challenge comes in the form of a three-hour morning exercise that gets reviewed by an instructor later in the afternoon. The idea is to make something by using principles you’ve been practicing and then get near-immediate feedback on your process and its result.

I was nervous but hopeful when I sat down at my assigned station and started setting up my work environment. I figured I’d do a pretty good job executing whatever method I chose to solve the assessment challenge, but I knew I’d have to be careful about the strategy I chose. I seem to have a knack for choosing the least natural data structure to do whatever job needs to be done. When arrays are best, I choose hashes. When hashes make the most sense, I choose arrays. When it’s time to deal with objects, I choose arrays again.

I choose arrays a lot. Arrays aren’t the best choice for most things we’re working on, but they’re the things I understand best, and I often retreat to the comfort of using them instead of digging deeper in my tool belt. Right now, the array is my Swiss Army Knife. It does one thing excellently (handling small groups of easily-countable data whose order isn’t expected to change frequently) and 25 other things poorly. But instead of going to the hardware store and shopping for a real screwdriver, I keep figuring out how to hold my wrist just so to force incompatible screw heads to comply with the one shape I happened to have in my pocket when I started the project.

That’s what I did on my assessment. We were faced with a few different files and asked to find a way to put them together into something that could complete a task. The objective was kind of like something I might see in the real world someday: read through a set of customer requirements and find the quickest, easiest, most natural way to satisfy them. There were plenty of opportunities to implement the Single Responsibility Principle, which involves separating program functions into single “verbs,” so that no single method performs more than one task. And there was a really obvious opportunity to implement a variable naming strategy we had learned yesterday.

And, alas, I missed it by a mile. I zigged when I should have zagged. I beeped when I should have booped. I arrayed when I should have…well, I won’t spoil it here, because you future boots deserve the learning experience (and also, as a student, I’m contractually forbidden from revealing specific details about DBC curriculum).

That’s not to say I spiked the challenge. My execution was about as elegant as my clunky choice allowed. There were points in the challenge when my strategy was perfect, but I overextended it and fell a little short of my own expectations.

At the end of the mock assessment and subsequent code review, boots get a frank assessment of the phase completion track they’re on – there’s the Passing track, the Repeating track, and the agonizingly nuanced Passing But Could Benefit From A Repeat track.

I’m on the third track, which feels like this huge weight of pressure to accelerate my pace. Maybe I have it in me to pass this time around, maybe not. I’m pretty sure I do. Either way, I don’t think my speed this next week will be nearly as important as my direction.

Dev Bootcamp believes software development is a craft, not an art. Artists get the luxury of using one tool to make beautiful things. Think of a chanteuse’s voice, a sculptor’s chisel, a dancer’s body, an illustrator’s pen. Developers aren’t so lucky. Every year, there are new languages, libraries, APIs, and…other things I can’t think of because I’m a noob…that devs have to lean on to do their work well. It doesn’t make sense to get hyper-focused on gaining one set of expertise when you know it might be obsolete by the time you break even on the time and effort investment. There is space for experts in the software world, but there is much more space for flexible craftspeople who can move with agility through changing client requirements and newly-patched coding tools and anything else that might come up.

I believe I’m here to become more flexible. And I think my teachers share that belief. If we’re to become hirable developers, that means learning how to function in the real world. And real world knowledge isn’t just learning what people are doing now, it’s learning how they are doing it. I didn’t know what Agile Development was when I first got here, but I recognize a lot of similarities between it and the requirements of my former position at a small communications firm: talk with your client frequently, work efficiently, leave wiggle room for adjustments, and don’t grab a hammer and run around assuming everything is a nail. Even though I can mentally grasp these ideas, practicing them is a real struggle, especially because I’m trying to learn a new language at the same time.

But it’s not like I don’t have help. My favorite mentor has a way of spotting me staring off into space, taking me off to the side, and directly challenging all of my most comfortable habits:

“You’re good at leading in a group; maybe try hanging back sometimes and letting other people lead. You’re good at experimenting with code directly; maybe try reading the source code of other people’s successful experiments and getting some information that way. You like to be the one who’s talking and sharing; listen more today. You’re pretty slick with those arrays…but can you do the same stuff with a hash?”

There’s a lot of nuance to this process. Our optimal DBC learning flow is in the stretch zone between comfort and panic, but sometimes I’m stretching into new design principles and I realize that I don’t understand how a hash can get the next step done and I smell panic and retreat to the comfort of an array, and now I’ve managed to occupy three spaces simultaneously, even though it might outwardly look like I’m just stretching.

Take a step back, though, and the shape of things becomes clear. I came into this program as someone very comfortable with doing very few things, like eating pesto and writing songs and making my daughter laugh. I will leave it as a more well-rounded developer and a more complete human being. I fully expect that the stretching I do into new and uncomfortable data structures will prime me for the kind of stretching I’ll need to do when my employer suddenly decides I need to know another coding language, or when the job environment transforms to accommodate a glut of new programmers, or when science realizes pesto is highly toxic when people consume it as much as I like to.

I need that kind of stretchiness, because so much in my life is up in the air and dependent on the result of these 9 (12? 15?) weeks, and I’ll probably stay up in the air for a long while as I figure out what happens after. This assessment was a fun little awakening, a bell of mindfulness ringing far outside my comfort zone. The code review feedback I got today told me that my capacity to understand is not my problem, it’s actually my comfort zone.

As for my capacity to slog through repeated practice, enduring the fear and frustration that comes from learning new ways to say the coding ideas in my head…I’m not sure if that’s in anyone’s comfort zone. At least not at first. And yet here I am, in a place where I get to see my trajectory in time to change it, and I get to decide if I’m ready to make those changes every single day.

This is what I paid for, this safe space for wild reinvention of my oldest habits, this invitation into transformative discomfort, this contract negotiation between the person I am and the person I am capable of becoming.

It’s the first time in a long time that the two of us have been in the same room, but I’m confident that we can hash something out.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com 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 )

w

Connecting to %s