What (we) Devs Don’t Talk About
Developers are an interesting and diverse group of folks who generally keep calm and just carry on about their day — grab a cup of coffee and get to it! But there are times when a project turns into quicksand. Cartoons warned us all about quicksand. However, in our everyday adult lives, “quicksand” turned out to be the Y2K bug on our scale of worry. For devs, quicksand is real, and they rarely let anyone know they’re in it. With things like scope creep, bugs, and constantly striving for perfection, I’d argue that devs welcome the challenge of quicksand.
On Problem Solving
The developer community, for the most part, seems to have its shit together. Developers by nature are intelligent beings that thrive on problem solving. If there’s a problem, we fix it.
“Hold on. There’s a fire I need to put out”.
Key strokes, key strokes, ENTER.
Fire’s out!
But what happens in between establishing the problem and the end fix? More importantly, why don’t we talk about this?
To non-devs, we’re magicians, and I think most of us like that comparison. But there’s a process behind fixing and making things work. A process that most developers don’t like to discuss outwardly. After all, a magician never reveals their secrets. So why would a dev?
Yes, developers have platforms in which discussions take place. There are many step-by-step tutorials about How to setup Webpack and Vue on Medium, or posts concerning ES6 promises in IE on Stack Overflow. But that’s not what I’m talking about; what I’m talking about is the steps between identifying the problem to pixel perfect end result.
There’s a wide range of emotions that go on throughout a developer’s day. If there’s a problem, curiosity hits and developers welcome the challenge. But what if the problem is a deep-seated issue caused by that very same developer? On the outside developers appear cool, calm, and collected. On the inside developers experience what I like to call The 8 Stages of Problem Solving Your Way Out of Quicksand:
- Find the root of the problem (Actionable)
- Oh my God how could I have not foreseen this? (Doubt)
- No this can’t be my problem (Denial)
- Yes it’s my problem (Acceptance)
- Oh God what if this effected other modules? (Fear)
- I found it (Clarity)
- Think of a solution (Actionable & Or Doubt)
- Implement Solution (Resolution)
- Repeat
Being Comfortable With Uneasiness and Bugs
If you’ve ever lived in New York City, hopping from one apartment to the next, you know if an apartment has or had roaches. It’s an almost metallic smell, and it’s par for the course in NYC. Code is no different sometimes; you can just smell bad code.
Code smell usually indicates a much bigger underlying problem in respect to an overall module build or just general code quality. Here at Creative Market, we take it to the next level and have our ears to the ground listening for bugs scuttling about. And we’re comfortable doing so.
Bugs happen to the best developers; it just comes with the territory. I’d argue that most developers feel exposed and vulnerable when bugs come along and that’s totally OK. It’s not something that’s mentioned amongst the dev community. After all, an exterminator wouldn’t scream at the sight of a bug. With every bug, error, or weird UI interaction fix, it’s a chance to learn something new. I used to dread the thought of a bug I spawned within the codebase. Bugs such as:
- The Rhinoceros Beetle: Large, hidden. While it cannot bite or sting, it’s the kind of bug that could flip you on your back. Often requires hours to remove.
- The Grasshopper: Small, pesky. Can effect other modules as it can jump from one to the other.
- The Funnel Weaver Spider: Small, common. Often times removing other bugs and aiding in building upon other “web features”. Warning: its “webs” can get pretty large if ignored.
Feel uncomfortable yet? After implementing a fix, the uneasiness doesn’t necessarily go away:
“Maybe I could have fixed it sooner/better!”
“Does this smell/is this part of a much bigger problem?”
“This was a rookie mistake, I can’t believe that made it into production.”
It’s all growing pains in becoming a better, more confident developer. I still feel like kicking myself when our company #bugs slack channel lights up and I know it’s my code that introduced the bug. I’ve learned to embrace the subtle art of dealing with quicksand and work with my team to get the job done.
Happy Coding
While appearing to be machines, developers are human. Putting their game faces on while internally trying to maneuver their way out of quicksand. There’s no other option but to embrace bugs, be comfortable in their presence and take on the responsibility of removing them. After all, they’re just bugs.
When a problem arises, developers look at it as if it’s a chance to dive deeper. Search fixes, read articles from developers who’ve managed to elegantly solve the problem at hand, and implement. The best developers are hooked on learning and growth. When you look at it from that perspective, suddenly the quicksand eases and the problem solving addiction kicks back in.
We’re always looking for amazing people to join the Creative Market team. We value our culture as much as we value our mission, so if helping creators turn passion into opportunity sounds like something you’d love to do with a group of folks who feel the same way, then check out our job openings and apply today!
