DEV Community

Cover image for When will I feel like I know what I'm doing?
Jon Hilton
Jon Hilton

Posted on • Updated on

When will I feel like I know what I'm doing?

15+ years into life as a "professional developer" and I'm wondering when I will finally feel like I have a clue what I'm doing!

And what exactly is "an experienced developer" anyway?

When I was 15 or so, I had an Amiga computer and I loved it. I could happily spend entire afternoons trawling through the thick, printed manual for Deluxe Paint, figuring out which exciting options to try next.

Or lose entire weekends to Putty, or F1, or The Settlers.

And every month I could barely contain my excitement waiting for the postman to bring the next issue of Amiga Format.

Ah Amiga Format how I miss thee.

This was back when magazines were the font of all knowledge. If you wanted to know what was going on in the world of Amiga, what games were "must haves" (and which ones to avoid) Amiga Format was the answer.

If you were an Amiga user back then, you'll almost certainly recognise every single Amiga Format cover.

It also used to come with a floppy disk crammed with "free" versions of popular software.

The World Wide Web (in the palm of your hand)

Then CD-ROMS came along (like floppy disks but better!) and you'd get an entire CD's worth of free stuff!

At one point, they even started including a kind of Internet archive, along with a browser (called Voyager) on the CD-ROM!

Just think of that, for most of us who didn't have an Internet connection, you could still fire up a browser and navigate hitherto unprecedented amounts of free content, all served from a single CD-ROM.

It was around this time when I got the bug. The "hey, there's the Internet, what can I put on it?" bug.

After messing around with GeoCities for a year or two (you know, writing a load of obligatory marquee tags and what not), I took my favourite TV programme (Red Dwarf) and made a site dedicated to it.

And, this could just be nostalgic memories playing tricks, but life was good. I could write simple HTML, add an image or two, link it all together and that was that. Instant results.

As I've gone on to build countless software using endless frameworks; "Classic" ASP, ASP.NET, AngularJS, Angular, React.JS etc. I don't think I've ever got back to the speed and simplicity of knocking up an HTML site and getting it out there for the world to see.

Oh how I long for the naivety of youth

Now, with 15+ years of professional development experience under my belt, a few things strike me.

It seems reasonable to assume that being "experienced" means you generally know more than someone with less experience, who's just starting out.

But with this extra knowledge comes a problem. You've no doubt seen every fad come and go; REST, SOAP, XML, Microservices, Containers, SPAs, WebForms, MVC...

And you've read enough articles on the Internet, and seen enough code, to have picked up a boatload of "knowledge" about how to build effective software; SOLID principles, functional approach, architectures.

That's a lot of noise to live with.

And if you're anything like me, there's always a nagging voice in the back of your head saying, "hmmm, that's not very good is it?" and "you really gonna leave that code looking like that?".

The very real danger of having more knowledge and experience is that you become paralysed, in a state of perpetual "second-guessing" yourself.

Why is it that a junior can come along and spin up a new feature in hours, whilst you seem to spend days working on the same thing and still wind up unhappy with the results?

I think (and I'm really just guessing here) that it's because we know the cost of that short-term hack.

We have an instinct for when quickly spinning up a solution is actually adding technical debt. We have a sense, before it happens, that this controller is going to wind up thousands of lines long if we don't whip it into shape now. We've been burned supporting and modifying terrible, terrible code and we don't want to inflict the same fate on ourselves (or anyone else for that matter) in the future.

But, at the same time, maybe the junior developers are on to something.

Maybe a KISS approach is the right way to start a feature.

Get something up and running, build momentum by keeping it simple but know when (and how) to refactor along the way, so you can proactively prevent the big ball o' mud from building up and eventually killing your velocity.

Better together

I'm a big fan of pairing and all of this brings me to one simple conclusion.

Experienced and less experienced developers pairing on a feature is a good thing.

I've sometimes found pairing when you're the "experienced developer" to be a stressful experience.

Mainly because I felt some kind of innate pressure to "know what I'm doing" and get to the ideal solution quickly.

But I now think that's a mistake.

The benefit of experienced and inexperienced developers working together is not that the experienced developer will "coach", "teach" the junior or speed up development.

I suspect the real benefit is that experienced and inexperienced developers working together really rounds out the extreme edges (over-simplifying or over-complicating).

That, by effectively working together, a better solution will emerge; one that isn't just "hacked together" but also isn't over-engineered from the get-go.

Now, more than ever, the challenge is to figure out how to "effectively work together".

And that responsibility falls to me and you :-)

Want to join me on this journey through the weird and wonderful world of software development?

Top comments (0)